| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace ZeroKey |
|
|
| section |
|
|
| open scoped MatrixOrder ComplexOrder Kronecker |
|
|
| open Matrix |
|
|
| universe v17_0 |
|
|
| theorem exists_isometry_comp_of_norm_eq {V : Type v17_0} [inst17_0 : NormedAddCommGroup V] |
| [inst17_1 : InnerProductSpace ℂ V] [inst17_2 : FiniteDimensional ℂ V] |
| (f g : V →ₗ[ℂ] V) |
| (h : ∀ x, ‖f x‖ = ‖g x‖) : |
| ∃ U : V →ₗᵢ[ℂ] V, U.toLinearMap.comp g = f := by |
| have hb : ∃ C : ℝ, ∀ x, ‖f x‖ ≤ C * ‖g x‖ := ⟨1, fun x => by simp [h x]⟩ |
| let L : LinearMap.range g →ₗᵢ[ℂ] V := |
| { toLinearMap := (f.compLeftInverse g).toLinearMap |
| norm_map' := by |
| rintro ⟨y, x, rfl⟩ |
| simpa only [ContinuousLinearMap.coe_coe, |
| LinearMap.compLeftInverse_apply_of_bdd f g hb x (g x) rfl, |
| ← Submodule.norm_coe] using h x } |
| 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 LinearMap.compLeftInverse_apply_of_bdd f g hb x (g x) rfl |
|
|
| universe v43_0 |
|
|
| lemma norm_eq_of_gram_eq {ι : Type v43_0} [inst43_0 : Fintype ι] [inst43_1 : DecidableEq ι] |
| (A B : Matrix ι ι ℂ) (h : Aᴴ * A = Bᴴ * B) |
| (x : EuclideanSpace ℂ ι) : ‖A.toEuclideanLin x‖ = ‖B.toEuclideanLin x‖ := by |
| have hh := congrArg (fun M : Matrix ι ι ℂ => |
| inner ℂ x (M.toEuclideanLin x)) h |
| simp only [Matrix.toLpLin_mul_same, Matrix.toEuclideanLin_conjTranspose_eq_adjoint, |
| LinearMap.comp_apply, LinearMap.adjoint_inner_right] at hh |
| change inner ℂ (A.toEuclideanLin x) (A.toEuclideanLin x) = |
| inner ℂ (B.toEuclideanLin x) (B.toEuclideanLin x) at hh |
| have hh' := congrArg (RCLike.re : ℂ → ℝ) hh |
| simpa only [inner_self_eq_norm_sq, sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)] using hh' |
|
|
| theorem exists_unitary_mul_of_gram_eq {ι : Type v43_0} [inst43_0 : Fintype ι] |
| [inst43_1 : DecidableEq ι] |
| (A B : Matrix ι ι ℂ) |
| (h : Aᴴ * A = Bᴴ * B) : |
| ∃ U : Matrix.unitaryGroup ι ℂ, A = (U : Matrix ι ι ℂ) * B := by |
| obtain ⟨U, hU⟩ := exists_isometry_comp_of_norm_eq A.toEuclideanLin B.toEuclideanLin |
| (norm_eq_of_gram_eq A B h) |
| let e := U.toLinearIsometryEquiv rfl |
| let V : Matrix ι ι ℂ := Matrix.toEuclideanLin.symm U.toLinearMap |
| have hV : V ∈ Matrix.unitaryGroup ι ℂ := by |
| exact e.toMatrix_mem_unitaryGroup (EuclideanSpace.basisFun ι ℂ) |
| (EuclideanSpace.basisFun ι ℂ) |
| refine ⟨⟨V, hV⟩, ?_⟩ |
| apply Matrix.toEuclideanLin.injective |
| simp only [Matrix.toLpLin_mul_same] |
| have hVlin : V.toEuclideanLin = U.toLinearMap := by simp [V] |
| change A.toEuclideanLin = V.toEuclideanLin.comp B.toEuclideanLin |
| rw [hVlin, hU] |
|
|
| universe v84_0 |
|
|
| def traceNorm {ι : Type v84_0} [inst84_0 : Fintype ι] [inst84_1 : DecidableEq ι] |
| (A : Matrix ι ι ℂ) : ℝ := (Matrix.trace (CFC.sqrt (Aᴴ * A))).re |
|
|
| universe v155_0 v155_1 |
|
|
| def matrixVector {ι : Type v155_0} {κ : Type v155_1} |
| (A : Matrix ι κ ℂ) : EuclideanSpace ℂ (ι × κ) := |
| WithLp.toLp 2 (fun x => A x.1 x.2) |
|
|
| abbrev Mat (d : ℕ) := Matrix (Fin d) (Fin d) ℂ |
|
|
| universe v217_0 |
|
|
| def matrixUnit {ι : Type v217_0} [DecidableEq ι] (i j : ι) : Matrix ι ι ℂ := |
| fun a b => if a = i ∧ b = j then 1 else 0 |
|
|
| def amplify {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (k : ℕ) |
| (U : Matrix (Fin k × Fin a) (Fin k × Fin a) ℂ) : |
| Matrix (Fin k × Fin b) (Fin k × Fin b) ℂ := |
| fun i j => L (fun x y => U (i.1, x) (j.1, y)) i.2 j.2 |
| |
| def CompletelyPositive {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) : Prop := |
| ∀ k U, U.PosSemidef → (amplify L k U).PosSemidef |
|
|
| def transposeLinear (a : ℕ) : Mat a →ₗ[ℂ] Mat a where |
| toFun := Matrix.transpose |
| map_add' := Matrix.transpose_add |
| map_smul' _ _ := rfl |
|
|
| def PPTType {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) : Prop := |
| CompletelyPositive L ∧ CompletelyPositive (L.comp (transposeLinear a)) |
|
|
| def tensorMap {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) |
| (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) : |
| Matrix (Fin b × Fin d) (Fin b × Fin d) ℂ := |
| fun i j => ∑ x, ∑ y, ∑ z, ∑ w, |
| U (x,z) (y,w) * L (matrixUnit x y) i.1 j.1 * M (matrixUnit z w) i.2 j.2 |
| |
| universe v243_0 |
|
|
| def outer {ι : Type v243_0} (u v : ι → ℂ) : Matrix ι ι ℂ := |
| fun i j => u i * star (v j) |
| |
| universe v246_0 |
|
|
| def Density {ι : Type v246_0} [Fintype ι] (R : Matrix ι ι ℂ) : Prop := |
| R.PosSemidef ∧ Matrix.trace R = 1 |
|
|
| universe v264_0 |
|
|
| def amplifyIndex {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) {κ : Type v264_0} |
| (U : Matrix (κ × Fin a) (κ × Fin a) ℂ) : |
| Matrix (κ × Fin b) (κ × Fin b) ℂ := |
| fun i j => L (fun x y => U (i.1,x) (j.1,y)) i.2 j.2 |
| |
| universe v269_0 |
|
|
| lemma cp_amplifyIndex {a b : ℕ} {L : Mat a →ₗ[ℂ] Mat b} (hL : CompletelyPositive L) |
| {κ : Type v269_0} [Fintype κ] (U : Matrix (κ × Fin a) (κ × Fin a) ℂ) |
| (hU : U.PosSemidef) : (amplifyIndex L U).PosSemidef := by |
| let e := Fintype.equivFin κ |
| have h := hL (Fintype.card κ) |
| (U.submatrix (fun i => (e.symm i.1, i.2)) (fun i => (e.symm i.1, i.2))) |
| (hU.submatrix _) |
| have h' := h.submatrix (fun i : κ × Fin b => (e i.1, i.2)) |
| convert h' using 1 |
| ext i j |
| simp [amplifyIndex, amplify, Matrix.submatrix] |
| |
| lemma matrix_sum_units {a : ℕ} (U : Mat a) : |
| U = ∑ x, ∑ y, U x y • matrixUnit x y := by |
| ext i j |
| simp [matrixUnit, Matrix.sum_apply, Matrix.smul_apply, ite_and] |
|
|
| lemma linearMap_matrix_units {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (U : Mat a) : |
| L U = ∑ x, ∑ y, U x y • L (matrixUnit x y) := by |
| conv_lhs => rw [matrix_sum_units U] |
| simp |
|
|
| lemma linearMap_matrix_units_apply {a b : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (U : Mat a) |
| (i j : Fin b) : L U i j = ∑ x, ∑ y, U x y * L (matrixUnit x y) i j := by |
| have h := congrArg (fun A : Mat b => A i j) (linearMap_matrix_units L U) |
| simpa only [Matrix.sum_apply, Matrix.smul_apply, smul_eq_mul] using h |
|
|
| lemma tensorMap_apply {a b c d : ℕ} (L : Mat a →ₗ[ℂ] Mat b) (M : Mat c →ₗ[ℂ] Mat d) |
| (U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ) (i j : Fin b) (k l : Fin d) : |
| tensorMap L M U (i,k) (j,l) = |
| L (fun x y => M (fun z w => U (x,z) (y,w)) k l) i j := by |
| calc |
| _ = ∑ x, ∑ y, (∑ z, ∑ w, U (x,z) (y,w) * M (matrixUnit z w) k l) * |
| L (matrixUnit x y) i j := by |
| simp only [tensorMap, Finset.sum_mul] |
| 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 |
| _ = ∑ x, ∑ y, M (fun z w => U (x,z) (y,w)) k l * L (matrixUnit x y) i j := by |
| apply Finset.sum_congr rfl |
| intro x _ |
| apply Finset.sum_congr rfl |
| intro y _ |
| exact congrArg (fun t => t * L (matrixUnit x y) i j) |
| (linearMap_matrix_units_apply M (fun z w => U (x,z) (y,w)) k l).symm |
| _ = _ := (linearMap_matrix_units_apply L _ i j).symm |
| |
| lemma tensorMap_positive {a b c d : ℕ} {L : Mat a →ₗ[ℂ] Mat b} |
| {M : Mat c →ₗ[ℂ] Mat d} (hL : CompletelyPositive L) (hM : CompletelyPositive M) |
| {U : Matrix (Fin a × Fin c) (Fin a × Fin c) ℂ} (hU : U.PosSemidef) : |
| (tensorMap L M U).PosSemidef := by |
| have h₁ := cp_amplifyIndex hM U hU |
| have h₂ := cp_amplifyIndex hL _ (h₁.submatrix Prod.swap) |
| have h₃ := h₂.submatrix Prod.swap |
| convert h₃ using 1 |
| ext i j |
| exact tensorMap_apply L M U i.1 j.1 i.2 j.2 |
| |
| universe v375_0 |
|
|
| lemma outer_posSemidef {ι : Type v375_0} [Fintype ι] (u : ι → ℂ) : (outer u u).PosSemidef := by |
| exact Matrix.posSemidef_vecMulVec_self_star u |
|
|
| universe v1019_0 |
|
|
| lemma cp_of_kraus_representation {a b : ℕ} {ν : Type v1019_0} [Fintype ν] |
| (L : Mat a →ₗ[ℂ] Mat b) (K : ν → Matrix (Fin b) (Fin a) ℂ) |
| (hK : ∀ U, L U = ∑ s, K s * U * (K s)ᴴ) : CompletelyPositive L := by |
| intro r U hU |
| have he : amplify L r U = ∑ s, ((1 : Mat r) ⊗ₖ K s) * U * ((1 : Mat r) ⊗ₖ K s)ᴴ := by |
| ext ⟨i,x⟩ ⟨j,y⟩ |
| change L (fun v w => U (i,v) (j,w)) x y = _ |
| erw [hK] |
| simp only [Matrix.sum_apply] |
| apply Finset.sum_congr rfl |
| intro s _ |
| change (K s * U.submatrix (fun v => (i,v)) (fun w => (j,w)) * (K s)ᴴ) x y = _ |
| simp [Matrix.mul_apply, Matrix.conjTranspose_apply, Matrix.submatrix, |
| Fintype.sum_prod_type, Matrix.one_apply, apply_ite] |
|
|
| rw [he] |
| apply Matrix.posSemidef_sum |
| intro s _ |
| exact hU.mul_mul_conjTranspose_same _ |
|
|
| end |
|
|
| open Matrix |
|
|
| open scoped MatrixOrder ComplexOrder Kronecker |
|
|
| section |
|
|
| universe v1102_0 v1102_1 |
|
|
| variable {σ : Type v1102_0} {ι : σ → Type v1102_1} [inst1102_0 : Fintype σ] [inst1102_1 : DecidableEq σ] |
| [inst1102_2 : ∀ s, Fintype (ι s)] [inst1102_3 : ∀ s, DecidableEq (ι s)] |
|
|
| def tensorPi (A : ∀ s, Matrix (ι s) (ι s) ℂ) : Matrix (∀ s, ι s) (∀ s, ι s) ℂ := |
| fun i j => ∏ s, A s (i s) (j s) |
|
|
| omit inst1102_3 in |
| lemma tensorPi_mul [∀ s, DecidableEq (ι s)] (A B : ∀ s, Matrix (ι s) (ι s) ℂ) : |
| tensorPi (fun s => A s * B s) = tensorPi A * tensorPi B := by |
| ext i j |
| simp only [tensorPi, Matrix.mul_apply] |
| rw [Fintype.prod_sum] |
| apply Finset.sum_congr rfl |
| intro k _ |
| exact Finset.prod_mul_distrib |
|
|
| omit inst1102_1 inst1102_2 in |
| lemma tensorPi_one [DecidableEq σ] [∀ s, Fintype (ι s)] : tensorPi (fun s => (1 : Matrix (ι s) (ι s) ℂ)) = 1 := by |
| ext i j |
| by_cases h : i=j |
| · subst j |
| simp [tensorPi] |
| · obtain ⟨s,hs⟩ := Function.ne_iff.mp h |
| simp only [tensorPi, Matrix.one_apply, ite_eq_right h] |
| apply Finset.prod_eq_zero (Finset.mem_univ s) |
| simp [hs] |
|
|
| omit inst1102_1 inst1102_2 inst1102_3 in |
| lemma tensorPi_star [DecidableEq σ] [∀ s, Fintype (ι s)] [∀ s, DecidableEq (ι s)] (A : ∀ s, Matrix (ι s) (ι s) ℂ) : |
| tensorPi (fun s => (A s)ᴴ) = (tensorPi A)ᴴ := by |
| ext i j |
| simp [tensorPi, Matrix.conjTranspose_apply] |
|
|
| lemma tensorPi_projection (A : ∀ s, Matrix (ι s) (ι s) ℂ) |
| (hA : ∀ s, IsStarProjection (A s)) : IsStarProjection (tensorPi A) := by |
| constructor |
| · change tensorPi A * tensorPi A = tensorPi A |
| rw [← tensorPi_mul] |
| congr 1 |
| funext s |
| exact (hA s).isIdempotentElem |
| · change (tensorPi A)ᴴ = tensorPi A |
| rw [← tensorPi_star] |
| congr 1 |
| funext s |
| exact (hA s).isSelfAdjoint |
|
|
| universe v1163_0 |
|
|
| omit inst1102_2 inst1102_3 in |
| lemma tensorPi_sum [∀ s, Fintype (ι s)] [∀ s, DecidableEq (ι s)] {α : σ → Type v1163_0} [∀ s, Fintype (α s)] |
| (A : ∀ s, α s → Matrix (ι s) (ι s) ℂ) : |
| (∑ a : ∀ s, α s, tensorPi (fun s => A s (a s))) = |
| tensorPi (fun s => ∑ a, A s a) := by |
| ext i j |
| simp only [Matrix.sum_apply, tensorPi] |
| exact (Fintype.prod_sum (fun s a => A s a (i s) (j s))).symm |
|
|
| end |
|
|
| namespace Explicit |
|
|
| section |
|
|
| abbrev p : ℕ := 257 |
|
|
| abbrev k : ℕ := 1028 |
|
|
| @[irreducible] def b : ℕ := Nat.choose 1027 513 |
|
|
| @[irreducible] def Q : ℕ := b^3 |
| |
| @[irreducible] def K : ℕ := k^3 |
|
|
| def dimensionFunction (q : ℕ) : ℕ := 4^(Nat.choose q 8) |
|
|
| lemma dimensionFunction_eq (q : ℕ) : dimensionFunction q = 4^(Nat.choose q 8) := rfl |
|
|
| @[irreducible] def D : ℕ := dimensionFunction Q |
|
|
| lemma D_eq : D = 4^(Nat.choose Q 8) := by |
| unfold D |
| exact dimensionFunction_eq Q |
|
|
| def outputDimensionFunction (q d : ℕ) : ℕ := q*d |
|
|
| lemma outputDimensionFunction_eq (q d : ℕ) : outputDimensionFunction q d = q*d := rfl |
|
|
| @[irreducible] def m : ℕ := outputDimensionFunction Q D |
|
|
| lemma m_eq : m = Q*D := by |
| unfold m |
| exact outputDimensionFunction_eq Q D |
|
|
| def Base := {A : Finset (Fin k) // A.card = 514 ∧ (0 : Fin k) ∈ A} |
|
|
| instance : Finite Base := by unfold Base; infer_instance |
|
|
| instance : Fintype Base := Fintype.ofFinite _ |
|
|
| instance : DecidableEq Base := Classical.decEq _ |
|
|
| instance : LinearOrder Base := LinearOrder.lift' (fun A : Base => A.1.sort (· ≤ ·)) (by |
| intro A B h |
| apply Subtype.ext |
| simpa only [Finset.sort_toFinset] using congrArg List.toFinset h) |
| |
| def Question := Lex (Fin 3 → Base) |
| |
| instance : Finite Question := by unfold Question; infer_instance |
| |
| instance : Fintype Question := Fintype.ofFinite _ |
| |
| instance : DecidableEq Question := Classical.decEq _ |
| |
| instance : LinearOrder Question := inferInstanceAs (LinearOrder (Lex (Fin 3 → Base))) |
| |
| def baseVector (A : Base) (h : Fin k) : ℝ := |
| (if h ∈ A.1 then 1 else -1) / Real.sqrt k |
| |
| def vector (q : Question) (h : Fin 3 → Fin k) : ℝ := |
| ∏ l, baseVector (ofLex q l) (h l) |
| |
| def overlap (q r : Question) : ℝ := ∑ h, vector q h * vector r h |
| |
| def EightSet := {S : Finset Question // S.card = 8} |
| |
| instance : Finite EightSet := by unfold EightSet; infer_instance |
| |
| instance : Fintype EightSet := Fintype.ofFinite _ |
| |
| instance : DecidableEq EightSet := Classical.decEq _ |
| |
| instance : LinearOrder EightSet := LinearOrder.lift' |
| (fun S : EightSet => S.1.sort (· ≤ ·)) (by |
| intro S T h |
| apply Subtype.ext |
| simpa only [Finset.sort_toFinset] using congrArg List.toFinset h) |
|
|
| def PairwiseOrthogonal (S : EightSet) : Prop := |
| ∀ q ∈ S.1, ∀ r ∈ S.1, q ≠ r → overlap q r = 0 |
|
|
| abbrev Sign := Fin 2 |
|
|
| def signValue (s : Sign) : ℂ := if s=0 then -1 else 1 |
|
|
| abbrev Outcome := Lex (Sign × Sign) |
|
|
| abbrev LocalBasis := Lex (Fin 2 × Fin 2) |
|
|
| def pauliX : Matrix (Fin 2) (Fin 2) ℂ := !![0,1 |
|
|
| def pauliY : Matrix (Fin 2) (Fin 2) ℂ := !![0,-Complex.I |
|
|
| def pauliZ : Matrix (Fin 2) (Fin 2) ℂ := !![1,0 |
|
|
| def tensor₂ (A B : Matrix (Fin 2) (Fin 2) ℂ) : Matrix LocalBasis LocalBasis ℂ := |
| (A ⊗ₖ B).submatrix ofLex ofLex |
|
|
| def observable : Fin 3 → Fin 3 → Matrix LocalBasis LocalBasis ℂ |
| | 0,0 => tensor₂ pauliX 1 |
| | 0,1 => tensor₂ 1 pauliX |
| | 0,2 => tensor₂ pauliX pauliX |
| | 1,0 => tensor₂ 1 pauliZ |
| | 1,1 => tensor₂ pauliZ 1 |
| | 1,2 => tensor₂ pauliZ pauliZ |
| | 2,0 => tensor₂ pauliX pauliZ |
| | 2,1 => tensor₂ pauliZ pauliX |
| | 2,2 => tensor₂ pauliY pauliY |
| |
| def contextObservable (t : Fin 6) (j : Fin 3) : Matrix LocalBasis LocalBasis ℂ := |
| if h : t.val < 3 then observable ⟨t.val,h⟩ j |
| else observable j ⟨t.val-3, by omega⟩ |
| |
| def contextProjection (t : Fin 6) (a : Outcome) : Matrix LocalBasis LocalBasis ℂ := |
| (1/4 : ℂ) • ((1+signValue (ofLex a).1 • contextObservable t 0) * |
| (1+signValue (ofLex a).2 • contextObservable t 1)) |
| |
| def trivialProjection (a : Outcome) : Matrix LocalBasis LocalBasis ℂ := |
| if ofLex a = (1,1) then 1 else 0 |
| |
| def localProjection (S : EightSet) (q : Question) (a : Outcome) : |
| Matrix LocalBasis LocalBasis ℂ := |
| by |
| classical |
| exact |
| if PairwiseOrthogonal S then |
| if h : q ∈ S.1 then |
| let rank := (S.1.orderIsoOfFin S.2).symm ⟨q,h⟩ |
| if hr : rank.val < 6 then contextProjection ⟨rank.val,hr⟩ a |
| else trivialProjection a |
| else trivialProjection a |
| else trivialProjection a |
| |
| def Basis := Lex (EightSet → LocalBasis) |
| |
| instance : Finite Basis := by unfold Basis; infer_instance |
| |
| instance : Fintype Basis := Fintype.ofFinite _ |
| |
| instance : DecidableEq Basis := Classical.decEq _ |
| |
| instance : LinearOrder Basis := inferInstanceAs (LinearOrder (Lex (EightSet → LocalBasis))) |
| |
| def OutcomeString := Lex (EightSet → Outcome) |
| |
| instance : Finite OutcomeString := by unfold OutcomeString; infer_instance |
| |
| instance : Fintype OutcomeString := Fintype.ofFinite _ |
| |
| instance : DecidableEq OutcomeString := Classical.decEq _ |
| |
| instance : LinearOrder OutcomeString := inferInstanceAs (LinearOrder (Lex (EightSet → Outcome))) |
| |
| def Label := Lex (Question × OutcomeString) |
| |
| instance : Finite Label := by unfold Label; infer_instance |
| |
| instance : Fintype Label := Fintype.ofFinite _ |
| |
| instance : DecidableEq Label := Classical.decEq _ |
| |
| instance : LinearOrder Label := inferInstanceAs (LinearOrder (Lex (Question × OutcomeString))) |
| |
| def projection (i : Label) : Matrix Basis Basis ℂ := fun h l => |
| ∏ S, localProjection S (ofLex i).1 (ofLex (ofLex i).2 S) (ofLex h S) (ofLex l S) |
| |
| def block (i j : Label) : Matrix Basis Basis ℂ := |
| (overlap (ofLex i).1 (ofLex j).1 : ℂ) • (projection i * projection j) |
| |
| universe v1312_0 v1312_1 |
| |
| def traceBlockMap {α : Type v1312_0} {β : Type v1312_1} [Fintype α] [DecidableEq α] |
| (H : β → β → Matrix α α ℂ) : Matrix α α ℂ →ₗ[ℂ] Matrix β β ℂ where |
| toFun U i j := trace (H i j * U) |
| map_add' U V := by |
| ext i j |
| change trace (H i j * (U+V)) = trace (H i j * U)+trace (H i j * V) |
| rw [mul_add, Matrix.trace_add] |
| map_smul' c U := by |
| ext i j |
| change trace (H i j * (c • U)) = c * trace (H i j * U) |
| rw [Matrix.mul_smul, Matrix.trace_smul] |
| rfl |
| |
| def rawOutput : Matrix (Label × Label) (Label × Label) ℂ := fun i j => |
| ∑ h, ∑ l, block i.1 j.1 l h * block i.2 j.2 l h |
| |
| def rho : Matrix (Label × Label) (Label × Label) ℂ := |
| ((Q^2*D : ℕ) : ℂ)⁻¹ • rawOutput |
| |
| lemma tensor₂_apply (A B : Matrix (Fin 2) (Fin 2) ℂ) (i j : LocalBasis) : |
| tensor₂ A B i j = A (ofLex i).1 (ofLex j).1 * B (ofLex i).2 (ofLex j).2 := rfl |
| |
| lemma sum_localBasis (f : LocalBasis → ℂ) : (∑ i, f i) = |
| f (toLex (0,0)) + f (toLex (0,1)) + (f (toLex (1,0)) + f (toLex (1,1))) := by |
| change (∑ i : Fin 2 × Fin 2, f (toLex i)) = _ |
| rw [Fintype.sum_prod_type, Fin.sum_univ_two, Fin.sum_univ_two, Fin.sum_univ_two] |
| |
| lemma signValue_sq (a : Sign) : signValue a * signValue a = 1 := by |
| fin_cases a <;> norm_num [signValue] |
| |
| lemma signValue_conj (a : Sign) : star (signValue a) = signValue a := by |
| fin_cases a <;> norm_num [signValue] |
| |
| lemma localBasis_one_apply (i j : LocalBasis) : |
| (1 : Matrix LocalBasis LocalBasis ℂ) i j = if ofLex i = ofLex j then 1 else 0 := by |
| simp only [Matrix.one_apply, ofLex.injective.eq_iff] |
| |
| lemma context_hermitian (t : Fin 6) (j : Fin 3) : |
| (contextObservable t j).IsHermitian := by |
| fin_cases t <;> fin_cases j <;> change (tensor₂ _ _).IsHermitian |
| all_goals |
| rw [Matrix.IsHermitian] |
| ext i l |
| rw [Matrix.conjTranspose_apply, tensor₂_apply, tensor₂_apply] |
| generalize hi : ofLex i = ii |
| generalize hl : ofLex l = ll |
| rcases ii with ⟨i,h⟩ |
| rcases ll with ⟨l,k⟩ |
| fin_cases i <;> fin_cases h <;> fin_cases l <;> fin_cases k <;> |
| norm_num [pauliX, pauliY, pauliZ, Matrix.one_apply] |
| |
| lemma context_real (t : Fin 6) (j : Fin 3) (i l : LocalBasis) : |
| star (contextObservable t j i l) = contextObservable t j i l := by |
| fin_cases t <;> fin_cases j <;> change star (tensor₂ _ _ i l) = tensor₂ _ _ i l |
| all_goals |
| rw [tensor₂_apply] |
| generalize hi : ofLex i = ii |
| generalize hl : ofLex l = ll |
| rcases ii with ⟨i,h⟩ |
| rcases ll with ⟨l,k⟩ |
| fin_cases i <;> fin_cases h <;> fin_cases l <;> fin_cases k <;> |
| norm_num [pauliX, pauliY, pauliZ, Matrix.one_apply] |
| |
| lemma context_involution (t : Fin 6) (j : Fin 3) : |
| contextObservable t j * contextObservable t j = 1 := by |
| fin_cases t <;> fin_cases j <;> change tensor₂ _ _ * tensor₂ _ _ = (1 : Matrix LocalBasis LocalBasis ℂ) |
| all_goals |
| ext i l |
| rw [Matrix.mul_apply, sum_localBasis, localBasis_one_apply] |
| simp only [tensor₂_apply, ofLex_toLex] |
| generalize hi : ofLex i = ii |
| generalize hl : ofLex l = ll |
| rcases ii with ⟨i,h⟩ |
| rcases ll with ⟨l,k⟩ |
| fin_cases i <;> fin_cases h <;> fin_cases l <;> fin_cases k <;> |
| norm_num [pauliX, pauliY, pauliZ, Matrix.one_apply] |
| |
| lemma context_commute (t : Fin 6) : |
| Commute (contextObservable t 0) (contextObservable t 1) := by |
| change contextObservable t 0 * contextObservable t 1 = contextObservable t 1 * contextObservable t 0 |
| fin_cases t <;> change tensor₂ _ _ * tensor₂ _ _ = tensor₂ _ _ * tensor₂ _ _ |
| all_goals |
| ext i l |
| simp only [Matrix.mul_apply, sum_localBasis, tensor₂_apply, ofLex_toLex] |
| generalize hi : ofLex i = ii |
| generalize hl : ofLex l = ll |
| rcases ii with ⟨i,h⟩ |
| rcases ll with ⟨l,k⟩ |
| fin_cases i <;> fin_cases h <;> fin_cases l <;> fin_cases k <;> |
| norm_num [pauliX, pauliY, pauliZ, Matrix.one_apply] |
| |
| def contextParity (t : Fin 6) : ℂ := if t=5 then -1 else 1 |
| |
| lemma context_third (t : Fin 6) : contextObservable t 2 = |
| contextParity t • (contextObservable t 0 * contextObservable t 1) := by |
| fin_cases t <;> change tensor₂ _ _ = _ • (tensor₂ _ _ * tensor₂ _ _) |
| all_goals |
| ext i l |
| simp only [Matrix.smul_apply, smul_eq_mul, Matrix.mul_apply, sum_localBasis, tensor₂_apply, ofLex_toLex] |
| generalize hi : ofLex i = ii |
| generalize hl : ofLex l = ll |
| rcases ii with ⟨i,h⟩ |
| rcases ll with ⟨l,k⟩ |
| fin_cases i <;> fin_cases h <;> fin_cases l <;> fin_cases k <;> |
| norm_num [contextParity, pauliX, pauliY, pauliZ, Matrix.one_apply, Fin.ext_iff] |
| |
| def spectralSign (O : Matrix LocalBasis LocalBasis ℂ) (a : Sign) := |
| (1/2 : ℂ) • (1 + signValue a • O) |
| |
| lemma sign_eigen_aux (O : Matrix LocalBasis LocalBasis ℂ) (hO : O*O=1) (a : Sign) : |
| O*(1+signValue a • O) = signValue a • (1+signValue a • O) := by |
| simp only [mul_add, mul_one, mul_smul_comm, hO, smul_add, smul_smul, |
| signValue_sq, one_smul] |
| exact add_comm _ _ |
| |
| lemma spectralSign_projection (O : Matrix LocalBasis LocalBasis ℂ) |
| (hO : O.IsHermitian) (hO2 : O*O=1) (a : Sign) : |
| IsStarProjection (spectralSign O a) := by |
| refine ⟨?_, ?_⟩ |
| · change spectralSign O a * spectralSign O a = spectralSign O a |
| dsimp [spectralSign] |
| rw [smul_mul_smul_comm, add_mul, one_mul, smul_mul_assoc, sign_eigen_aux O hO2] |
| rw [smul_smul, signValue_sq, one_smul] |
| module |
| · change star (spectralSign O a) = spectralSign O a |
| dsimp [spectralSign] |
| simp only [star_smul, star_add, star_one, signValue_conj, hO.star_eq] |
| norm_num |
| |
| lemma spectralSign_commute (O T : Matrix LocalBasis LocalBasis ℂ) |
| (h : Commute O T) (a b : Sign) : Commute (spectralSign O a) (spectralSign T b) := by |
| unfold spectralSign |
| exact ((Commute.one_left _).add_left ((Commute.one_right _).add_right |
| (h.smul_left _ |>.smul_right _))).smul_left _ |>.smul_right _ |
| |
| lemma contextProjection_factor (t : Fin 6) (a : Outcome) : contextProjection t a = |
| spectralSign (contextObservable t 0) (ofLex a).1 * |
| spectralSign (contextObservable t 1) (ofLex a).2 := by |
| simp only [contextProjection, spectralSign, smul_mul_smul_comm] |
| norm_num |
| |
| lemma contextProjection_projection (t : Fin 6) (a : Outcome) : |
| IsStarProjection (contextProjection t a) := by |
| rw [contextProjection_factor] |
| exact (spectralSign_projection _ (context_hermitian t 0) (context_involution t 0) _).mul |
| (spectralSign_projection _ (context_hermitian t 1) (context_involution t 1) _) |
| (spectralSign_commute _ _ (context_commute t) _ _) |
| |
| lemma contextProjection_real (t : Fin 6) (a : Outcome) (i j : LocalBasis) : |
| star (contextProjection t a i j) = contextProjection t a i j := by |
| simp only [contextProjection, Matrix.smul_apply, smul_eq_mul, Matrix.mul_apply, |
| star_mul, star_sum, Matrix.add_apply, Matrix.smul_apply, smul_eq_mul, |
| star_add, context_real, signValue_conj] |
| simp [Matrix.one_apply, mul_comm] |
| |
| lemma contextParity_conj (t : Fin 6) : star (contextParity t) = contextParity t := by |
| unfold contextParity |
| split <;> norm_num |
| |
| def contextEigenvalue (t : Fin 6) (a : Outcome) : Fin 3 → ℂ := |
| ![signValue (ofLex a).1, signValue (ofLex a).2, |
| contextParity t * signValue (ofLex a).1 * signValue (ofLex a).2] |
| |
| lemma context_eigen_first (t : Fin 6) (a : Outcome) : |
| contextObservable t 0 * contextProjection t a = |
| signValue (ofLex a).1 • contextProjection t a := by |
| unfold contextProjection |
| rw [mul_smul_comm, ← mul_assoc, sign_eigen_aux _ (context_involution t 0), |
| smul_mul_assoc, smul_comm] |
| |
| lemma context_eigen_second (t : Fin 6) (a : Outcome) : |
| contextObservable t 1 * contextProjection t a = |
| signValue (ofLex a).2 • contextProjection t a := by |
| unfold contextProjection |
| rw [mul_smul_comm] |
| have hc : Commute (contextObservable t 1) |
| (1+signValue (ofLex a).1 • contextObservable t 0) := |
| (Commute.one_right _).add_right ((context_commute t).symm.smul_right _) |
| rw [← mul_assoc, hc, mul_assoc, sign_eigen_aux _ (context_involution t 1), |
| mul_smul_comm, smul_comm] |
| |
| lemma context_eigen (t : Fin 6) (a : Outcome) (j : Fin 3) : |
| contextObservable t j * contextProjection t a = |
| contextEigenvalue t a j • contextProjection t a := by |
| fin_cases j |
| · exact context_eigen_first t a |
| · exact context_eigen_second t a |
| · change contextObservable t 2 * contextProjection t a = |
| (contextParity t * signValue (ofLex a).1 * signValue (ofLex a).2) • _ |
| rw [context_third, smul_mul_assoc, mul_assoc, context_eigen_second, |
| mul_smul_comm, context_eigen_first] |
| simp only [smul_smul] |
| congr 1 |
| ring |
| |
| lemma contextEigenvalue_conj (t : Fin 6) (a : Outcome) (j : Fin 3) : |
| star (contextEigenvalue t a j) = contextEigenvalue t a j := by |
| (fin_cases j <;> simp [contextEigenvalue, star_mul, signValue_conj, contextParity_conj]); ring |
| |
| lemma context_eigen_right (t : Fin 6) (a : Outcome) (j : Fin 3) : |
| contextProjection t a * contextObservable t j = |
| contextEigenvalue t a j • contextProjection t a := by |
| have h := congrArg star (context_eigen t a j) |
| simpa only [star_mul, (contextProjection_projection t a).isSelfAdjoint.star_eq, |
| (context_hermitian t j).star_eq, star_smul, contextEigenvalue_conj] using h |
| |
| lemma spectralSign_sum (O : Matrix LocalBasis LocalBasis ℂ) : |
| ∑ a, spectralSign O a = 1 := by |
| rw [Fin.sum_univ_two] |
| norm_num [spectralSign, signValue] |
| module |
| |
| lemma contextProjection_sum (t : Fin 6) : ∑ a, contextProjection t a = 1 := by |
| simp_rw [contextProjection_factor] |
| change (∑ a : Sign × Sign, spectralSign (contextObservable t 0) a.1 * |
| spectralSign (contextObservable t 1) a.2) = _ |
| rw [Fintype.sum_prod_type] |
| simp only [← Finset.mul_sum, ← Finset.sum_mul, spectralSign_sum, one_mul] |
| |
| universe v1552_0 |
| |
| lemma eigenvalues_agree {ι : Type v1552_0} [Fintype ι] (E F O : Matrix ι ι ℂ) |
| (a b : ℂ) (hE : E*O=a • E) (hF : O*F=b • F) (hEF : E*F≠0) : a=b := by |
| apply smul_left_injective ℂ hEF |
| calc a • (E*F) = (E*O)*F := by rw [hE, smul_mul_assoc] |
| _ = E*(O*F) := mul_assoc _ _ _ |
| _ = b • (E*F) := by rw [hF, mul_smul_comm] |
| |
| lemma signValue_injective : Function.Injective signValue := by |
| intro a b hab |
| fin_cases a <;> fin_cases b <;> first | rfl | norm_num [signValue] at hab |
| |
| lemma contextProjection_orthogonal (t : Fin 6) (a b : Outcome) (hab : a≠b) : |
| contextProjection t a * contextProjection t b = 0 := by |
| by_contra h |
| have he (j : Fin 3) := eigenvalues_agree _ _ _ _ _ |
| (context_eigen_right t a j) (context_eigen t b j) h |
| apply hab |
| apply ofLex.injective |
| apply Prod.ext |
| · exact signValue_injective (he 0) |
| · exact signValue_injective (he 1) |
| |
| lemma trivialProjection_projection (a : Outcome) : IsStarProjection (trivialProjection a) := by |
| unfold trivialProjection |
| split <;> simp only [IsStarProjection.one, IsStarProjection.zero] |
| |
| lemma trivialProjection_sum : ∑ a, trivialProjection a = 1 := by |
| classical |
| have h : ∀ a, trivialProjection a = if a = toLex (1,1) then 1 else 0 := by |
| intro a |
| simp [trivialProjection, ← ofLex.injective.eq_iff] |
| simp only [h] |
| simp |
| |
| lemma trivialProjection_orthogonal (a b : Outcome) (hab : a≠b) : |
| trivialProjection a * trivialProjection b = 0 := by |
| by_cases ha : ofLex a = (1,1) |
| · have hb : ofLex b ≠ (1,1) := fun hb => hab (ofLex.injective (ha.trans hb.symm)) |
| simp [trivialProjection, hb] |
| · simp [trivialProjection, ha] |
| |
| lemma localProjection_type (S : EightSet) (q : Question) : |
| (localProjection S q = trivialProjection) ∨ |
| (∃ t : Fin 6, localProjection S q = contextProjection t) := by |
| classical |
| unfold localProjection |
| split |
| · split |
| · dsimp only |
| split |
| · exact Or.inr ⟨_,rfl⟩ |
| · exact Or.inl rfl |
| · exact Or.inl rfl |
| · exact Or.inl rfl |
| |
| lemma localProjection_projection (S : EightSet) (q : Question) (a : Outcome) : |
| IsStarProjection (localProjection S q a) := by |
| rcases localProjection_type S q with h | ⟨t,h⟩ |
| · rw [h] |
| · rw [h] |
|
|
| lemma localProjection_real (S : EightSet) (q : Question) (a : Outcome) (i j : LocalBasis) : |
| star (localProjection S q a i j) = localProjection S q a i j := by |
| rcases localProjection_type S q with h | ⟨t,h⟩ |
| · rw [h] |
| unfold trivialProjection |
| split <;> simp [Matrix.one_apply] |
| · rw [h]; exact contextProjection_real t a i j |
| |
| lemma localProjection_sum (S : EightSet) (q : Question) : |
| ∑ a, localProjection S q a = 1 := by |
| rcases localProjection_type S q with h | ⟨t,h⟩ |
| · rw [h] |
| · rw [h] |
|
|
| lemma localProjection_orthogonal (S : EightSet) (q : Question) (a b : Outcome) (hab : a≠b) : |
| localProjection S q a * localProjection S q b = 0 := by |
| rcases localProjection_type S q with h | ⟨t,h⟩ |
| · rw [h]; exact trivialProjection_orthogonal a b hab |
| · rw [h]; exact contextProjection_orthogonal t a b hab |
| |
| lemma projection_tensor (i : Label) : projection i = |
| (tensorPi (fun S => localProjection S (ofLex i).1 (ofLex (ofLex i).2 S))).submatrix |
| (show Basis ≃ (EightSet → LocalBasis) from Equiv.refl _) (show Basis ≃ (EightSet → LocalBasis) from Equiv.refl _) := rfl |
| |
| lemma projection_projection (i : Label) : IsStarProjection (projection i) := by |
| let e : Basis ≃ (EightSet → LocalBasis) := Equiv.refl _ |
| let A := tensorPi (fun S => localProjection S (ofLex i).1 (ofLex (ofLex i).2 S)) |
| have hA : IsStarProjection A := tensorPi_projection _ (fun S => localProjection_projection _ _ _) |
| rw [projection_tensor] |
| change IsStarProjection (A.submatrix e e) |
| constructor |
| · change A.submatrix e e * A.submatrix e e = A.submatrix e e |
| rw [Matrix.submatrix_mul_equiv, hA.isIdempotentElem] |
| · change (A.submatrix e e)ᴴ = A.submatrix e e |
| rw [Matrix.conjTranspose_submatrix, show Aᴴ=A from hA.isSelfAdjoint] |
| |
| lemma projection_real (i : Label) (h l : Basis) : star (projection i h l) = projection i h l := by |
| change (starRingEnd ℂ) (∏ S, localProjection S (ofLex i).1 (ofLex (ofLex i).2 S) (ofLex h S) (ofLex l S)) = _ |
| rw [map_prod] |
| simp only [starRingEnd_apply, localProjection_real] |
| rfl |
| |
| lemma projection_sum (q : Question) : ∑ a : OutcomeString, projection (toLex (q,a)) = 1 := by |
| ext h l |
| simp only [Matrix.sum_apply, projection, ofLex_toLex] |
| have he := congr_fun (congr_fun (tensorPi_sum (fun S a => localProjection S q a)) (ofLex h)) (ofLex l) |
| have hr : tensorPi (fun S => ∑ a, localProjection S q a) = 1 := by |
| simp only [localProjection_sum, tensorPi_one] |
| rw [hr] at he |
| calc |
| _ = ∑ a : EightSet → Outcome, ∏ S, localProjection S q (a S) (ofLex h S) (ofLex l S) := |
| (Equiv.sum_comp (show (EightSet → Outcome) ≃ OutcomeString from Equiv.refl _) |
| (fun a : OutcomeString => ∏ S, localProjection S q (ofLex a S) (ofLex h S) (ofLex l S))).symm |
| _ = _ := by |
| simpa only [tensorPi, Matrix.sum_apply, Matrix.one_apply, |
| show (ofLex h = ofLex l) ↔ h=l from Iff.rfl] using he |
| |
| lemma projection_mul_apply (i j : Label) (h l : Basis) : |
| (projection i * projection j) h l = ∏ S, |
| (localProjection S (ofLex i).1 (ofLex (ofLex i).2 S) * |
| localProjection S (ofLex j).1 (ofLex (ofLex j).2 S)) (ofLex h S) (ofLex l S) := by |
| let e : Basis ≃ (EightSet → LocalBasis) := Equiv.refl _ |
| let A := tensorPi (fun S => localProjection S (ofLex i).1 (ofLex (ofLex i).2 S)) |
| let B := tensorPi (fun S => localProjection S (ofLex j).1 (ofLex (ofLex j).2 S)) |
| change (A.submatrix e e * B.submatrix e e) h l = _ |
| rw [Matrix.submatrix_mul_equiv] |
| exact congr_fun (congr_fun (tensorPi_mul _ _).symm (ofLex h)) (ofLex l) |
| |
| lemma trivialProjection_commute (a : Outcome) (A : Matrix LocalBasis LocalBasis ℂ) : |
| Commute (trivialProjection a) A := by |
| unfold trivialProjection |
| split <;> simp |
| |
| lemma localProjection_self_commute (S : EightSet) (q : Question) (a b : Outcome) : |
| Commute (localProjection S q a) (localProjection S q b) := by |
| by_cases h : a=b |
| · subst b; exact Commute.refl _ |
| · change _ * _ = _ * _ |
| rw [localProjection_orthogonal _ _ _ _ h, |
| localProjection_orthogonal _ _ _ _ (Ne.symm h)] |
| |
| lemma localProjection_trivial_of_not_orthogonal (S : EightSet) (q : Question) |
| (h : ¬PairwiseOrthogonal S) : localProjection S q = trivialProjection := by |
| funext a |
| simp only [localProjection, ite_eq_right h] |
| |
| lemma localProjection_trivial_of_not_mem (S : EightSet) (q : Question) |
| (h : q∉S.1) : localProjection S q = trivialProjection := by |
| funext a |
| simp only [localProjection, dite_eq_right h, ite_self] |
| |
| lemma localProjection_commute (S : EightSet) (q r : Question) (a b : Outcome) |
| (hqr : overlap q r ≠ 0) : Commute (localProjection S q a) (localProjection S r b) := by |
| by_cases he : q=r |
| · subst r; exact localProjection_self_commute S q a b |
| by_cases hS : PairwiseOrthogonal S |
| · by_cases hq : q∈S.1 |
| · have hr : r∉S.1 := fun hr => hqr (hS q hq r hr he) |
| rw [localProjection_trivial_of_not_mem S r hr] |
| exact (trivialProjection_commute b _).symm |
| · rw [localProjection_trivial_of_not_mem S q hq] |
| exact trivialProjection_commute a _ |
| · rw [localProjection_trivial_of_not_orthogonal S q hS] |
| exact trivialProjection_commute a _ |
| |
| lemma projection_commute (i j : Label) (hij : overlap (ofLex i).1 (ofLex j).1 ≠ 0) : |
| Commute (projection i) (projection j) := by |
| change _ * _ = _ * _ |
| ext h l |
| rw [projection_mul_apply, projection_mul_apply] |
| apply Finset.prod_congr rfl |
| intro S _ |
| rw [(localProjection_commute S _ _ _ _ hij).eq] |
| |
| universe v1965_0 |
| |
| lemma card_subsets_containing {α : Type v1965_0} [Fintype α] [DecidableEq α] |
| (a : α) (r : ℕ) (hr : 1 ≤ r) |
| [Fintype {A : Finset α // A.card=r ∧ a ∈ A}] : |
| Fintype.card {A : Finset α // A.card=r ∧ a ∈ A} = |
| Nat.choose (Fintype.card α - 1) (r-1) := by |
| rw [Fintype.card_of_subtype |
| (((Finset.univ : Finset α).powersetCard r).filter ({a} ⊆ ·)) (by |
| intro A |
| simp only [Finset.mem_filter, Finset.mem_powersetCard, Finset.subset_univ, |
| true_and, Finset.singleton_subset_iff])] |
| rw [Finset.card_filter_powersetCard_subset _ _ _ (Finset.subset_univ _) |
| (by simpa only [Finset.card_singleton] using hr)] |
| simp only [Finset.card_univ, Finset.card_singleton] |
| |
| lemma card_base : Fintype.card Base = b := by |
| let : Fintype {A : Finset (Fin k) // A.card=514 ∧ (0 : Fin k) ∈ A} := |
| inferInstanceAs (Fintype Base) |
| have h := card_subsets_containing (0 : Fin k) 514 (by decide) |
| change Fintype.card Base = Nat.choose (Fintype.card (Fin k)-1) (514-1) at h |
| rw [Fintype.card_fin] at h |
| delta b |
| exact h.trans (congrArg₂ Nat.choose (show k-1=1027 from rfl) (show 514-1=513 from rfl)) |
| |
| lemma card_question : Fintype.card Question = Q := by |
| rw [Fintype.card_congr (show Question ≃ (Fin 3 → Base) from Equiv.refl _)] |
| rw [Fintype.card_fun, Fintype.card_fin, card_base] |
| delta Q |
| rfl |
| |
| universe v1995_0 |
| |
| lemma signed_overlap {α : Type v1995_0} [Fintype α] [DecidableEq α] (A B : Finset α) : |
| (∑ h, (if h ∈ A then (1:ℝ) else -1) * (if h ∈ B then 1 else -1)) = |
| Fintype.card α - 2*(A.card:ℝ) - 2*(B.card:ℝ) + 4*(A ∩ B).card := by |
| have hp (h : α) : |
| (if h ∈ A then (1:ℝ) else -1) * (if h ∈ B then 1 else -1) = |
| 1 - 2*(if h ∈ A then 1 else 0) - 2*(if h ∈ B then 1 else 0) + |
| 4*(if h ∈ A ∩ B then 1 else 0) := by |
| by_cases ha : h ∈ A <;> by_cases hb : h ∈ B <;> simp [ha,hb] <;> norm_num |
| simp only [hp, Finset.sum_add_distrib, Finset.sum_sub_distrib, ← Finset.mul_sum] |
| simp |
| congr 1 |
| ext x |
| simp |
| |
| lemma base_inner (A B : Base) : |
| (∑ h, baseVector A h * baseVector B h) = (A.1 ∩ B.1).card / (p:ℝ) - 1 := by |
| simp only [baseVector, div_mul_div_comm, ← Finset.sum_div] |
| rw [Real.mul_self_sqrt (by norm_num : (0:ℝ) ≤ k), signed_overlap] |
| rw [A.2.1,B.2.1] |
| simp only [Fintype.card_fin, k, p] |
| push_cast |
| ring |
| |
| lemma base_unit (A : Base) : ∑ h, baseVector A h * baseVector A h = 1 := by |
| rw [base_inner, Finset.inter_self, A.2.1] |
| norm_num [p] |
| |
| lemma vector_unit (q : Question) : overlap q q = 1 := by |
| change Lex (Fin 3 → Base) at q |
| unfold overlap vector |
| simp only [← Finset.prod_mul_distrib] |
| rw [← Fintype.prod_sum (fun l h => baseVector (ofLex q l) h * baseVector (ofLex q l) h)] |
| simp only [base_unit, Finset.prod_const_one] |
| |
| @[irreducible] def a₀ : ℕ := ∑ j ∈ Finset.range p, Nat.choose k j |
| |
| open Finset |
| |
| lemma choose_mono_small {n i j : ℕ} (hij : i ≤ j) (hj : j ≤ n/2) : |
| Nat.choose n i ≤ Nat.choose n j := by |
| induction hij with |
| | refl => rfl |
| | @step j hij ih => |
| exact (ih (by omega)).trans (Nat.choose_le_succ_of_lt_half_left (by omega)) |
| |
| lemma a₀_upper : a₀ ≤ 257 * Nat.choose 1028 257 := by |
| delta a₀ |
| calc |
| (∑ j ∈ range 257, Nat.choose 1028 j) ≤ ∑ _j ∈ range 257, Nat.choose 1028 257 := by |
| apply sum_le_sum |
| intro j hj |
| exact choose_mono_small (Nat.le_of_lt (mem_range.mp hj)) (by decide) |
| _ = _ := by rw [sum_const, card_range, nsmul_eq_mul, Nat.cast_id] |
| |
| lemma binomial_term_le (n j x y : ℕ) (hj : j ≤ n) : |
| x^j*y^(n-j)*Nat.choose n j ≤ (x+y)^n := by |
| rw [add_pow] |
| exact single_le_sum (f := fun m => x^m*y^(n-m)*Nat.choose n m) |
| (fun _ _ => Nat.zero_le _) (show j ∈ range (n+1) from mem_range.mpr (by omega)) |
| |
| lemma choose_upper : Nat.choose 1028 257 < 12^257 := by |
| have ht := binomial_term_le 1028 257 1 3 (by decide) |
| simp only [one_pow, one_mul, show 1028-257=771 from rfl, show 1+3=4 from rfl] at ht |
| have hn : (4:ℕ)^1028 < 3^771*12^257 := by |
| have hh := pow_lt_pow_left₀ (by norm_num : (4:ℕ)^4 < 3^3*12) (by positivity) (by decide : 257 ≠ 0) |
| have hl : ((4:ℕ)^4)^257 = 4^1028 := by rw [← pow_mul] |
| have hr : ((3:ℕ)^3*12)^257 = 3^771*12^257 := |
| by rw [mul_pow, ← pow_mul] |
| exact (congrArg₂ (fun x y : ℕ => x<y) hl hr).mp hh |
| have hh : 3^771 * Nat.choose 1028 257 < 3^771 * 12^257 := lt_of_le_of_lt ht hn |
| exact Nat.lt_of_mul_lt_mul_left hh |
| |
| lemma double_b : Nat.choose 1028 514 = 2*b := by |
| delta b |
| have hs : Nat.choose 1027 514 = Nat.choose 1027 513 := |
| Nat.choose_symm_of_eq_add (show 1027=514+513 from rfl) |
| calc |
| Nat.choose 1028 514 = Nat.choose 1027 513 + Nat.choose 1027 514 := |
| (congrArg₂ Nat.choose (show 1028=Nat.succ 1027 from rfl) |
| (show 514=Nat.succ 513 from rfl)).trans ((Nat.choose_succ_succ 1027 513).trans |
| (congrArg (fun x => Nat.choose 1027 513 + x) |
| (congrArg (Nat.choose 1027) (show Nat.succ 513=514 from rfl)))) |
| _ = 2 * Nat.choose 1027 513 := by rw [hs]; omega |
| |
| lemma b_lower : 2^1028 ≤ 2058*b := by |
| have h : (∑ j ∈ range (1028+1), Nat.choose 1028 j) ≤ |
| ∑ _j ∈ range (1028+1), Nat.choose 1028 514 := |
| sum_le_sum (fun j _ => Nat.choose_le_middle j 1028) |
| rw [Nat.sum_range_choose, sum_const, card_range, nsmul_eq_mul, double_b] at h |
| simpa only [Nat.cast_id, show 1028+1=1029 from rfl, ← Nat.mul_assoc, show 1029*2=2058 from rfl] using h |
| |
| lemma strict_parameter_bound : 3*a₀*K < b := by |
| have ha := a₀_upper |
| have hc := choose_upper |
| have hb := b_lower |
| have ha' : a₀ < 257*12^257 := lt_of_le_of_lt ha (Nat.mul_lt_mul_of_pos_left hc (by decide)) |
| have hn : (2058:ℕ)*(3*(257*12^257)*1028^3) < 2^1028 := by |
| calc |
| (2058:ℕ)*(3*(257*12^257)*1028^3) < 16^257 := by |
| rw [show 257=256+1 from rfl, pow_add, pow_add] |
| norm_num |
| _ = 2^1028 := by |
| calc |
| (16 : ℕ)^257 = ((2 : ℕ)^4)^257 := congrArg (fun value : ℕ => value^257) (show 16 = 2^4 from rfl) |
| _ = 2^1028 := by rw [← pow_mul] |
| delta K |
| change 3*a₀*1028^3 < b |
| apply Nat.lt_of_mul_lt_mul_left (a := 2058) |
| exact lt_of_le_of_lt (Nat.mul_le_mul_left 2058 |
| (Nat.mul_le_mul_right (1028^3) (Nat.mul_le_mul_left 3 (Nat.le_of_lt ha')))) (hn.trans_le hb) |
| |
| lemma b_pos : 0 < b := lt_of_le_of_lt (Nat.zero_le _) strict_parameter_bound |
| |
| end |
| |
| universe v2431_0 |
| |
| lemma card_subsets {α : Type v2431_0} [Fintype α] [DecidableEq α] (r : ℕ) |
| [Fintype {S : Finset α // S.card=r}] : |
| Fintype.card {S : Finset α // S.card=r} = Nat.choose (Fintype.card α) r := by |
| rw [Fintype.card_of_subtype ((Finset.univ : Finset α).powersetCard r) (by |
| intro S |
| simp only [Finset.mem_powersetCard, Finset.subset_univ, true_and])] |
| rw [Finset.card_powersetCard, Finset.card_univ] |
| |
| lemma card_eightSet : Fintype.card EightSet = Nat.choose Q 8 := by |
| let : Fintype {S : Finset Question // S.card=8} := inferInstanceAs (Fintype EightSet) |
| exact (card_subsets (α := Question) 8).trans (congrArg (fun n => Nat.choose n 8) card_question) |
| |
| lemma card_basis_aux : Fintype.card Basis = Fintype.card LocalBasis ^ Fintype.card EightSet := by |
| rw [← Nat.card_eq_fintype_card, ← Nat.card_eq_fintype_card, ← Nat.card_eq_fintype_card] |
| exact (Nat.card_congr (show Basis ≃ (EightSet → LocalBasis) from Equiv.refl _)).trans Nat.card_fun |
| |
| lemma card_localBasis : Fintype.card LocalBasis = 4 := by |
| rw [Fintype.card_congr (show LocalBasis ≃ (Fin 2 × Fin 2) from Equiv.refl _), |
| Fintype.card_prod, Fintype.card_fin] |
| |
| lemma card_basis : Fintype.card Basis = D := by |
| exact (card_basis_aux.trans (congrArg₂ (fun a b : ℕ => a^b) card_localBasis card_eightSet)).trans D_eq.symm |
| |
| lemma card_outcomeString : Fintype.card OutcomeString = D := |
| (Fintype.card_congr (show OutcomeString ≃ Basis from Equiv.refl _)).trans card_basis |
| |
| lemma card_label : Fintype.card Label = m := by |
| rw [Fintype.card_congr (show Label ≃ (Question × OutcomeString) from Equiv.refl _)] |
| rw [Fintype.card_prod, card_question, card_outcomeString] |
| exact m_eq.symm |
| |
| def basisOrder : Fin D ≃o Basis := Fintype.orderIsoFinOfCardEq Basis card_basis |
| |
| def labelOrder : Fin m ≃o Label := Fintype.orderIsoFinOfCardEq Label (by |
| have cardContaining {α : Type} [Fintype α] [DecidableEq α] |
| (a : α) (r : ℕ) (hr : 1 ≤ r) |
| [Fintype {A : Finset α // A.card = r ∧ a ∈ A}] : |
| Fintype.card {A : Finset α // A.card = r ∧ a ∈ A} = |
| Nat.choose (Fintype.card α - 1) (r - 1) := by |
| as_aux_lemma => |
| rw [Fintype.card_of_subtype |
| (((Finset.univ : Finset α).powersetCard r).filter ({a} ⊆ ·)) (by |
| intro A |
| simp only [Finset.mem_filter, Finset.mem_powersetCard, Finset.subset_univ, |
| true_and, Finset.singleton_subset_iff])] |
| rw [Finset.card_filter_powersetCard_subset _ _ _ (Finset.subset_univ _) |
| (by simpa only [Finset.card_singleton] using hr)] |
| simp only [Finset.card_univ, Finset.card_singleton] |
| have hbase : Fintype.card Base = b := by |
| as_aux_lemma => |
| let : Fintype {A : Finset (Fin k) // A.card = 514 ∧ (0 : Fin k) ∈ A} := |
| inferInstanceAs (Fintype Base) |
| have h := cardContaining (0 : Fin k) 514 (by decide) |
| change Fintype.card Base = Nat.choose (Fintype.card (Fin k) - 1) (514 - 1) at h |
| rw [Fintype.card_fin] at h |
| delta b |
| exact h.trans (congrArg₂ Nat.choose (show k - 1 = 1027 from rfl) |
| (show 514 - 1 = 513 from rfl)) |
| have hquestion : Fintype.card Question = Q := by |
| calc |
| Fintype.card Question = Fintype.card (Fin 3 → Base) := |
| Fintype.card_congr (show Question ≃ (Fin 3 → Base) from Equiv.refl _) |
| _ = Fintype.card Base ^ Fintype.card (Fin 3) := Fintype.card_fun |
| _ = b ^ 3 := congrArg₂ (fun x y : ℕ => x ^ y) hbase (Fintype.card_fin 3) |
| _ = Q := Q.eq_def.symm |
| |
| have height : Fintype.card EightSet = Nat.choose Q 8 := by |
| as_aux_lemma => |
| let : Fintype {S : Finset Question // S.card = 8} := inferInstanceAs (Fintype EightSet) |
| change Fintype.card {S : Finset Question // S.card = 8} = _ |
| rw [Fintype.card_of_subtype ((Finset.univ : Finset Question).powersetCard 8) (by |
| intro S |
| simp only [Finset.mem_powersetCard, Finset.subset_univ, true_and])] |
| rw [Finset.card_powersetCard, Finset.card_univ, hquestion] |
| have hlocal : Fintype.card Outcome = 4 := by |
| as_aux_lemma => |
| rw [Fintype.card_congr (show Outcome ≃ (Fin 2 × Fin 2) from Equiv.refl _), |
| Fintype.card_prod, Fintype.card_fin] |
| have houtcome : Fintype.card OutcomeString = D := by |
| as_aux_lemma => |
| calc |
| Fintype.card OutcomeString = Fintype.card Outcome ^ Fintype.card EightSet := by |
| rw [Fintype.card_congr (show OutcomeString ≃ (EightSet → Outcome) from Equiv.refl _), |
| Fintype.card_fun] |
| _ = 4 ^ Nat.choose Q 8 := congrArg₂ (fun a b : ℕ => a ^ b) hlocal height |
| _ = D := by |
| have hd (q : ℕ) : dimensionFunction q = 4 ^ Nat.choose q 8 := rfl |
| symm |
| unfold D |
| exact hd Q |
| rw [Fintype.card_congr (show Label ≃ (Question × OutcomeString) from Equiv.refl _)] |
| rw [Fintype.card_prod, hquestion, houtcome] |
| have hm (q d : ℕ) : outputDimensionFunction q d = q * d := rfl |
| symm |
| unfold m |
| exact hm Q D) |
| |
| def rhoFin : Matrix (Fin m × Fin m) (Fin m × Fin m) ℂ := |
| rho.submatrix (Prod.map labelOrder labelOrder) (Prod.map labelOrder labelOrder) |
| |
| lemma overlap_symm (q r : Question) : overlap q r = overlap r q := by |
| unfold overlap |
| exact Finset.sum_congr rfl (fun h _ => mul_comm _ _) |
| |
| lemma projection_transpose (i : Label) : (projection i)ᵀ = projection i := by |
| ext h l |
| have hh := congrArg (fun A : Matrix Basis Basis ℂ => A h l) |
| (show (projection i)ᴴ=projection i from (projection_projection i).isSelfAdjoint) |
| exact (projection_real i l h).symm.trans hh |
| |
| lemma block_swap (i j : Label) : block i j = block j i := by |
| by_cases h : overlap (ofLex i).1 (ofLex j).1 = 0 |
| · simp only [block, ← overlap_symm (ofLex i).1 (ofLex j).1, h, |
| Complex.ofReal_zero, zero_smul] |
| · unfold block |
| rw [overlap_symm, (projection_commute i j h).eq] |
| |
| lemma block_transpose (i j : Label) : (block i j)ᵀ = block i j := by |
| by_cases h : overlap (ofLex i).1 (ofLex j).1 = 0 |
| · simp only [block, h, Complex.ofReal_zero, zero_smul, Matrix.transpose_zero] |
| · unfold block |
| rw [Matrix.transpose_smul, Matrix.transpose_mul, projection_transpose, projection_transpose, |
| (projection_commute i j h).eq] |
| |
| lemma block_diag (i : Label) : block i i = projection i := by |
| unfold block |
| rw [vector_unit, Complex.ofReal_one, one_smul, (projection_projection i).isIdempotentElem] |
| |
| lemma rawOutput_trace (i j : Label × Label) : |
| rawOutput i j = trace (block i.1 j.1 * block i.2 j.2) := by |
| rw [← block_transpose i.1 j.1] |
| simp only [rawOutput, trace, Matrix.diag_apply, Matrix.mul_apply, Matrix.transpose_apply] |
| |
| lemma rawOutput_crossed_diagonal (i j : Label) : |
| rawOutput (i,j) (i,j) = trace (projection i * projection j) := by |
| rw [rawOutput_trace, block_diag, block_diag] |
| |
| def makeLabel (q : Question) (a : OutcomeString) : Label := toLex (q,a) |
| |
| lemma projection_sum_makeLabel (q : Question) : ∑ a, projection (makeLabel q a) = 1 := projection_sum q |
| |
| universe v2545_0 |
| |
| lemma sum_label {M : Type v2545_0} [AddCommMonoid M] (f : Label → M) : |
| ∑ i, f i = ∑ q : Question, ∑ a : OutcomeString, f (makeLabel q a) := by |
| exact (Equiv.sum_comp (show (Question × OutcomeString) ≃ Label from Equiv.refl _) f).symm.trans |
| (Fintype.sum_prod_type _) |
| |
| lemma sum_projection_pair_trace (q r : Question) : |
| (∑ a : OutcomeString, ∑ b : OutcomeString, |
| trace (projection (makeLabel q a) * projection (makeLabel r b))) = (D : ℂ) := by |
| have h : (∑ a : OutcomeString, ∑ b : OutcomeString, |
| projection (makeLabel q a) * projection (makeLabel r b)) = 1 := by |
| simp_rw [← Finset.mul_sum, projection_sum_makeLabel, mul_one] |
| exact projection_sum_makeLabel q |
| have hh := congrArg Matrix.trace h |
| simpa only [trace_sum, trace_one, card_basis] using hh |
| |
| lemma rawOutput_trace_total : trace rawOutput = (Q^2*D : ℕ) := by |
| change (∑ i : Label × Label, rawOutput i i) = _ |
| rw [Fintype.sum_prod_type] |
| simp_rw [rawOutput_crossed_diagonal, sum_label] |
| conv_lhs => |
| arg 2; ext q |
| rw [Finset.sum_comm] |
| simp_rw [sum_projection_pair_trace] |
| simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, card_question, |
| Nat.cast_mul, Nat.cast_pow] |
| ring |
| |
| end Explicit |
| |
| open scoped MatrixOrder ComplexOrder Kronecker |
| |
| open Matrix |
| |
| universe v2604_0 v2604_1 |
| |
| def Separable {ι : Type v2604_0} {κ : Type v2604_1} [Fintype ι] [Fintype κ] |
| (R : Matrix (ι × κ) (ι × κ) ℂ) : Prop := |
| ∃ (n : ℕ) (A : Fin n → Matrix ι ι ℂ) (B : Fin n → Matrix κ κ ℂ), |
| (∀ s, (A s).PosSemidef) ∧ (∀ s, (B s).PosSemidef) ∧ R = ∑ s, A s ⊗ₖ B s |
| |
| open Finset |
| |
| namespace Explicit |
| |
| lemma Q_pos : 0 < Q := by unfold Q; exact pow_pos b_pos 3 |
| |
| lemma D_pos : 0 < D := by rw [D_eq]; exact pow_pos (by decide) _ |
| |
| end Explicit |
| |
| open scoped ComplexOrder MatrixOrder Kronecker |
| |
| open Matrix |
| |
| section |
| |
| universe v2846_0 v2846_1 v2846_2 |
| |
| variable {α : Type v2846_0} {β : Type v2846_1} {γ : Type v2846_2} [inst2846_0 : Fintype α] [inst2846_1 : Fintype β] [inst2846_2 : Fintype γ] |
| |
| def projectionKraus (u : β → γ → ℝ) (P : β → Matrix α α ℂ) : |
| (γ × α) → Matrix β α ℂ := fun s i a => (u i s.1 : ℂ) * P i s.2 a |
| |
| omit inst2846_1 in |
| lemma projectionKraus_coeff [Fintype β] (u : β → γ → ℝ) (P : β → Matrix α α ℂ) |
| (hP : ∀ i, (P i).IsHermitian) (i j : β) (a b : α) : |
| (∑ s, projectionKraus u P s i a * star (projectionKraus u P s j b)) = |
| (∑ h, (u i h : ℂ) * (u j h : ℂ)) * (P j * P i) b a := by |
| simp only [projectionKraus, Fintype.sum_prod_type, star_mul, Complex.star_def, |
| Complex.conj_ofReal] |
| have hp (l : α) : star (P j l b) = P j b l := congrArg (fun A : Matrix α α ℂ => A b l) (hP j).eq |
| simp only [← Complex.star_def, hp, Matrix.mul_apply, Finset.sum_mul, Finset.mul_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro h _ |
| apply Finset.sum_congr rfl |
| intro l _ |
| ring |
| |
| lemma projectionKraus_formula (u : β → γ → ℝ) (P : β → Matrix α α ℂ) |
| (hP : ∀ i, (P i).IsHermitian) (U : Matrix α α ℂ) (i j : β) : |
| (∑ s, projectionKraus u P s * U * (projectionKraus u P s)ᴴ) i j = |
| trace (((∑ h, (u i h : ℂ) * (u j h : ℂ)) • (P j * P i)) * U) := by |
| simp only [Matrix.sum_apply, Matrix.mul_apply, Matrix.conjTranspose_apply] |
| simp only [Finset.sum_mul] |
| calc |
| _ = ∑ b, ∑ a, (∑ s, projectionKraus u P s i a * star (projectionKraus u P s j b)) * U a b := by |
| simp only [Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro b _ |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro a _ |
| apply Finset.sum_congr rfl |
| intro s _ |
| ring |
| _ = _ := by |
| simp only [projectionKraus_coeff u P hP, trace, Matrix.diag_apply, |
| Matrix.mul_apply, Matrix.smul_apply, smul_eq_mul] |
| |
| end |
| |
| namespace Explicit |
| |
| def questionFin (i : Fin m) : Question := (ofLex (labelOrder i)).1 |
| |
| def projectionFin (i : Fin m) : Mat D := (projection (labelOrder i)).submatrix basisOrder basisOrder |
| |
| def blockFin (i j : Fin m) : Mat D := (block (labelOrder i) (labelOrder j)).submatrix basisOrder basisOrder |
| |
| def constructionMapFin : Mat D →ₗ[ℂ] Mat m := traceBlockMap blockFin |
| |
| lemma projectionFin_hermitian (i : Fin m) : (projectionFin i).IsHermitian := |
| (show (projection (labelOrder i)).IsHermitian from |
| (projection_projection (labelOrder i)).isSelfAdjoint).submatrix _ |
| |
| lemma blockFin_swap (i j : Fin m) : blockFin i j = blockFin j i := by |
| unfold blockFin |
| rw [block_swap] |
| |
| lemma blockFin_formula (i j : Fin m) : blockFin i j = |
| (overlap (questionFin i) (questionFin j) : ℂ) • |
| (projectionFin i * projectionFin j) := by |
| unfold blockFin block projectionFin |
| change _ = (overlap (questionFin i) (questionFin j) : ℂ) • _ |
| have hh := (Matrix.submatrix_mul_equiv (projection (labelOrder i)) (projection (labelOrder j)) |
| basisOrder basisOrder.toEquiv basisOrder).symm |
| exact congrArg (fun A : Mat D => (overlap (questionFin i) (questionFin j) : ℂ) • A) hh |
| |
| lemma constructionMapFin_kraus (U : Mat D) : constructionMapFin U = |
| ∑ s, projectionKraus (fun i => vector (questionFin i)) projectionFin s * U * |
| (projectionKraus (fun i => vector (questionFin i)) projectionFin s)ᴴ := by |
| ext i j |
| change trace (blockFin i j * U) = _ |
| rw [projectionKraus_formula _ _ projectionFin_hermitian] |
| rw [blockFin_swap i j, blockFin_formula] |
| have hc : (overlap (questionFin j) (questionFin i) : ℂ) = |
| ∑ h, (vector (questionFin i) h : ℂ) * (vector (questionFin j) h : ℂ) := by |
| rw [overlap_symm] |
| simp only [← Complex.ofReal_mul, ← Complex.ofReal_sum] |
| rfl |
| rw [hc] |
| |
| lemma constructionMapFin_cp : CompletelyPositive constructionMapFin := |
| cp_of_kraus_representation _ _ constructionMapFin_kraus |
| |
| lemma constructionMapFin_unit (x y : Fin D) (i j : Fin m) : |
| constructionMapFin (matrixUnit x y) i j = blockFin i j y x := by |
| change trace (blockFin i j * matrixUnit x y) = _ |
| simp [trace, Matrix.diag_apply, Matrix.mul_apply, matrixUnit, ite_and] |
| |
| def omegaVector : Fin D × Fin D → ℂ := fun i => if i.1=i.2 then 1 else 0 |
| |
| def rawOutputFin : Matrix (Fin m × Fin m) (Fin m × Fin m) ℂ := |
| rawOutput.submatrix (Prod.map labelOrder labelOrder) (Prod.map labelOrder labelOrder) |
| |
| lemma rawOutputFin_tensor : rawOutputFin = |
| tensorMap constructionMapFin constructionMapFin (outer omegaVector omegaVector) := by |
| ext ⟨i,a⟩ ⟨j,b⟩ |
| change rawOutput (labelOrder i, labelOrder a) (labelOrder j, labelOrder b) = _ |
| simp only [tensorMap, outer, omegaVector, constructionMapFin_unit, apply_ite, |
| star_one, star_zero, ite_mul, one_mul, zero_mul, mul_zero] |
| simp only [Finset.sum_ite_eq, Finset.mem_univ, ite_true] |
| change (∑ h, ∑ l, block (labelOrder i) (labelOrder j) l h * |
| block (labelOrder a) (labelOrder b) l h) = |
| ∑ h : Fin D, ∑ l : Fin D, block (labelOrder i) (labelOrder j) (basisOrder l) (basisOrder h) * |
| block (labelOrder a) (labelOrder b) (basisOrder l) (basisOrder h) |
| rw [← Equiv.sum_comp basisOrder.toEquiv] |
| apply Finset.sum_congr rfl |
| intro h _ |
| exact (Equiv.sum_comp basisOrder.toEquiv _).symm |
| |
| lemma rawOutputFin_psd : rawOutputFin.PosSemidef := by |
| rw [rawOutputFin_tensor] |
| exact tensorMap_positive constructionMapFin_cp constructionMapFin_cp (outer_posSemidef _) |
| |
| lemma rawOutputFin_trace : trace rawOutputFin = ((Q^2*D : ℕ) : ℂ) := by |
| rw [← rawOutput_trace_total] |
| unfold trace |
| exact Equiv.sum_comp (labelOrder.toEquiv.prodCongr labelOrder.toEquiv) |
| (fun x : Label × Label => rawOutput x x) |
| |
| lemma rhoFin_eq : rhoFin = ((Q^2*D : ℕ) : ℂ)⁻¹ • rawOutputFin := rfl |
| |
| lemma symbolic_normalization_ne_zero (q d : ℕ) (hq : 0 < q) (hd : 0 < d) : |
| ((q^2*d : ℕ) : ℂ) ≠ 0 := by |
| exact Nat.cast_ne_zero.mpr (mul_pos (pow_pos hq 2) hd).ne' |
| |
| lemma normalization_ne_zero : ((Q^2*D : ℕ) : ℂ) ≠ 0 := |
| symbolic_normalization_ne_zero Q D Q_pos D_pos |
| |
| lemma rhoFin_density : Density rhoFin := by |
| rw [rhoFin_eq] |
| constructor |
| · exact rawOutputFin_psd.smul (inv_nonneg.mpr (Nat.cast_nonneg _)) |
| · rw [trace_smul, rawOutputFin_trace, smul_eq_mul, inv_mul_cancel₀ normalization_ne_zero] |
| |
| end Explicit |
| |
| end ZeroKey |
| |
| namespace UnrestrictedQuantum |
| |
| open Matrix MeasureTheory |
| |
| open scoped ComplexOrder MatrixOrder |
| |
| universe v3096_0 v3096_1 v3096_2 v3096_3 v3096_4 |
| |
| variable {A : Type v3096_0} {B : Type v3096_1} {C : Type v3096_2} [inst3096_0 : AddCommGroup A] [inst3096_1 : Module ℂ A] [inst3096_2 : One A] |
| [inst3096_3 : AddCommGroup B] [inst3096_4 : Module ℂ B] [inst3096_5 : One B] |
| [inst3096_6 : AddCommGroup C] [inst3096_7 : Module ℂ C] [inst3096_8 : One C] |
| {ι : Type v3096_3} {κ : Type v3096_4} [inst3096_9 : Fintype ι] [inst3096_10 : Fintype κ] [inst3096_11 : DecidableEq ι] [inst3096_12 : DecidableEq κ] |
| |
| universe v3101_0 v3101_1 |
| |
| abbrev ReferenceFunctional (A : Type v3101_0) [AddCommGroup A] [Module ℂ A] |
| (ι : Type v3101_1) := A →ₗ[ℂ] Matrix ι ι ℂ |
| |
| def PositiveFunctional [LE A] (S : ReferenceFunctional A ι) : Prop := |
| ∀ x, 0 ≤ x → (S x).PosSemidef |
| |
| universe v3140_0 v3140_1 v3140_2 |
| |
| structure ObservableInstrument (O : Type v3140_0) [MeasurableSpace O] |
| (A : Type v3140_1) (B : Type v3140_2) [AddCommGroup A] [Module ℂ A] [One A] [LE A] |
| [AddCommGroup B] [Module ℂ B] [One B] [LE B] where |
| operation : Set O → B →ₗ[ℂ] A |
| positive : ∀ E, MeasurableSet E → ∀ x, 0 ≤ x → 0 ≤ operation E x |
| total_unit : operation Set.univ 1 = 1 |
| |
| universe v3147_0 |
| |
| variable {O : Type v3147_0} [inst3147_0 : MeasurableSpace O] [inst3147_1 : LE A] [inst3147_2 : LE B] |
| (J : ObservableInstrument O A B) (S : ReferenceFunctional A ι) |
| |
| structure InstrumentRun where |
| law : Measure O |
| probability : IsProbabilityMeasure law |
| posterior : O → ReferenceFunctional B ι |
| posterior_positive : ∀ o, PositiveFunctional (posterior o) |
| posterior_trace : ∀ o, trace (posterior o 1) = 1 |
| integrable : ∀ x i j, Integrable (fun o => posterior o x i j) law |
| update : ∀ E, MeasurableSet E → ∀ x i j, |
| (∫ o in E, posterior o x i j ∂law) = S (J.operation E x) i j |
| |
| namespace InstrumentRun |
| |
| variable (r : InstrumentRun J S) |
| |
| omit inst3096_11 in |
| theorem reference_mean [DecidableEq ι] (i j : ι) : |
| (∫ o, r.posterior o 1 i j ∂r.law) = S 1 i j := by |
| simpa only [Measure.restrict_univ, J.total_unit] using |
| r.update Set.univ MeasurableSet.univ 1 i j |
| |
| end InstrumentRun |
| |
| end UnrestrictedQuantum |
| |
| namespace ZeroKey |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory Set Function unitInterval |
| |
| open scoped ENNReal |
| |
| section |
| |
| universe v3216_0 v3216_1 |
| |
| theorem sample_instrument_kernel {S : Type v3216_0} {O : Type v3216_1} [MeasurableSpace S] |
| [MeasurableSpace O] [StandardBorelSpace O] [Nonempty O] |
| (κ : Kernel S O) [IsMarkovKernel κ] : |
| ∃ f : S → I → O, Measurable (uncurry f) ∧ |
| (∀ s, volume.map (f s) = κ s) ∧ |
| ∀ (μ : Measure S) [IsFiniteMeasure μ], |
| (μ.prod (volume : Measure I)).map (fun p => (p.1, f p.1 p.2)) = μ ⊗ₘ κ := by |
| obtain ⟨f,hf,hfLaw⟩ := κ.exists_measurable_map_eq_unitInterval |
| change Measurable (fun p : S × I => f p.1 p.2) at hf |
| refine ⟨f,hf,hfLaw,?_⟩ |
| intro μ hμ |
| ext B hB |
| rw [Measure.map_apply (measurable_fst.prodMk hf) hB, |
| Measure.prod_apply (hB.preimage (measurable_fst.prodMk hf)), |
| Measure.compProd_apply hB] |
| congr 1 |
| funext s |
| rw [← hfLaw s, Measure.map_apply hf.of_uncurry_left (measurable_prodMk_left hB)] |
| rfl |
| |
| abbrev UniformTape := ℕ → I |
| |
| def uniformTapeLaw : Measure UniformTape := |
| Measure.infinitePi (fun _ : ℕ => (volume : Measure I)) |
| |
| instance : IsProbabilityMeasure uniformTapeLaw := by |
| unfold uniformTapeLaw |
| infer_instance |
| |
| end |
| |
| open MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ENNReal |
| |
| section |
| |
| universe v3447_0 |
| |
| variable {Ω : Type v3447_0} {mΩ : MeasurableSpace Ω} [inst3447_0 : StandardBorelSpace Ω] |
| {μ : Measure Ω} [inst3447_1 : IsFiniteMeasure μ] |
| |
| lemma indicator_one_mul (s : Set Ω) (f : Ω → ℝ) : |
| s.indicator (fun _ => (1:ℝ)) * f = s.indicator f := by |
| ext x |
| by_cases hx : x∈s <;> simp [hx] |
| |
| lemma indicator_inter_one (s t : Set Ω) : |
| (s∩t).indicator (fun _ => (1:ℝ)) = |
| s.indicator (t.indicator (fun _ => (1:ℝ))) := by |
| ext x |
| by_cases hs : x∈s <;> by_cases ht : x∈t <;> simp [hs,ht] |
| |
| lemma condIndep_condExp_right {C A B : MeasurableSpace Ω} |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) (hCA : C ≤ A) |
| (h : CondIndep C A B hC μ) {t : Set Ω} (ht : MeasurableSet[B] t) : |
| μ[t.indicator (fun _ => (1:ℝ)) | A] =ᵐ[μ] |
| μ[t.indicator (fun _ => (1:ℝ)) | C] := by |
| let f := t.indicator (fun _ : Ω => (1:ℝ)) |
| have hf : Integrable f μ := (integrable_const (1:ℝ)).indicator (hB t ht) |
| symm |
| apply ae_eq_condExp_of_forall_setIntegral_eq hA hf |
| · intro s hs hμs |
| exact integrable_condExp.integrableOn |
| · intro s hs hμs |
| have hs' : MeasurableSet[mΩ] s := hA s hs |
| have hsi : Integrable (s.indicator (fun _ : Ω => (1:ℝ))) μ := |
| (integrable_const (1:ℝ)).indicator hs' |
| have hprod : Integrable (s.indicator (fun _ : Ω => (1:ℝ)) * μ[f | C]) μ := by |
| rw [indicator_one_mul] |
| exact integrable_condExp.indicator hs' |
| have hp := condExp_mul_of_stronglyMeasurable_right |
| (stronglyMeasurable_condExp (μ := μ) (m := C) (f := f)) hprod hsi |
| rw [indicator_one_mul] at hp |
| have hh := ((condIndep_iff C A B hC hA hB μ).mp h) s t hs ht |
| change μ[(s∩t).indicator (fun _ => (1:ℝ)) | C] =ᵐ[μ] |
| μ[s.indicator (fun _ => (1:ℝ)) | C] * μ[f | C] at hh |
| calc |
| (∫ x in s, μ[f | C] x ∂μ) = ∫ x, s.indicator (μ[f | C]) x ∂μ := |
| (integral_indicator hs').symm |
| _ = ∫ x, μ[s.indicator (μ[f | C]) | C] x ∂μ := (integral_condExp hC).symm |
| _ = ∫ x, μ[(s∩t).indicator (fun _ => (1:ℝ)) | C] x ∂μ := |
| integral_congr_ae (hp.trans hh.symm) |
| _ = ∫ x, (s∩t).indicator (fun _ => (1:ℝ)) x ∂μ := integral_condExp hC |
| _ = ∫ x in s, f x ∂μ := by |
| rw [indicator_inter_one, integral_indicator hs'] |
| · exact (stronglyMeasurable_condExp.mono hCA).aestronglyMeasurable |
| |
| lemma condIndep_local_refinement {C N A B : MeasurableSpace Ω} |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (hCA : C ≤ A) (hCN : C ≤ N) (hNA : N ≤ A) |
| (h : CondIndep C A B hC μ) : |
| CondIndep N A B (hNA.trans hA) μ := by |
| have hN := hNA.trans hA |
| rw [condIndep_iff N A B hN hA hB] |
| intro s t hs ht |
| let f := t.indicator (fun _ : Ω => (1:ℝ)) |
| have hf : Integrable f μ := (integrable_const (1:ℝ)).indicator (hB t ht) |
| have hp : μ[f | A] =ᵐ[μ] μ[f | C] := condIndep_condExp_right hC hA hB hCA h ht |
| have hcN : μ[μ[f | C] | N] = μ[f | C] := |
| condExp_of_stronglyMeasurable hN (stronglyMeasurable_condExp.mono hCN) integrable_condExp |
| have htN : μ[f | N] =ᵐ[μ] μ[f | C] := by |
| calc |
| _ =ᵐ[μ] μ[μ[f | A] | N] := (condExp_condExp_of_le hNA hA).symm |
| _ =ᵐ[μ] μ[μ[f | C] | N] := condExp_congr_ae hp |
| _ =ᵐ[μ] μ[f | C] := by rw [hcN] |
| have hsep : μ[s.indicator f | A] =ᵐ[μ] s.indicator (μ[f | C]) := by |
| apply (condExp_indicator hf hs).trans |
| filter_upwards [hp] with x hx |
| by_cases hxs : x∈s <;> simp [hxs,hx] |
| have hsi : Integrable (s.indicator (fun _ : Ω => (1:ℝ))) μ := |
| (integrable_const (1:ℝ)).indicator (hA s hs) |
| have hprod : Integrable (s.indicator (fun _ : Ω => (1:ℝ)) * μ[f | C]) μ := by |
| rw [indicator_one_mul] |
| exact integrable_condExp.indicator (hA s hs) |
| have hpull := condExp_mul_of_stronglyMeasurable_right |
| (stronglyMeasurable_condExp.mono hCN) hprod hsi |
| rw [indicator_one_mul] at hpull |
| change μ[(s∩t).indicator (fun _ => (1:ℝ)) | N] =ᵐ[μ] |
| μ[s.indicator (fun _ => (1:ℝ)) | N] * μ[f | N] |
| rw [indicator_inter_one] |
| calc |
| _ =ᵐ[μ] μ[μ[s.indicator f | A] | N] := (condExp_condExp_of_le hNA hA).symm |
| _ =ᵐ[μ] μ[s.indicator (μ[f | C]) | N] := condExp_congr_ae hsep |
| _ =ᵐ[μ] μ[s.indicator (fun _ => (1:ℝ)) | N] * μ[f | C] := hpull |
| _ =ᵐ[μ] _ := by |
| filter_upwards [htN] with x hx |
| simp only [Pi.mul_apply, hx] |
| |
| def recordInterFamily (B C : MeasurableSpace Ω) : Set (Set Ω) := |
| {s | ∃ b n, MeasurableSet[B] b ∧ MeasurableSet[C] n ∧ s = b∩n} |
| |
| lemma recordInterFamily_pi (B C : MeasurableSpace Ω) : IsPiSystem (recordInterFamily B C) := by |
| rintro s ⟨b,n,hb,hn,rfl⟩ t ⟨b',n',hb',hn',rfl⟩ _ |
| refine ⟨b∩b',n∩n',hb.inter hb',hn.inter hn',?_⟩ |
| ext x |
| simp only [Set.mem_inter_iff] |
| tauto |
|
|
| lemma recordInterFamily_generate (B C : MeasurableSpace Ω) : |
| MeasurableSpace.generateFrom (recordInterFamily B C) = B ⊔ C := by |
| apply le_antisymm |
| · apply MeasurableSpace.generateFrom_le |
| rintro s ⟨b,n,hb,hn,rfl⟩ |
| exact ((show B ≤ B ⊔ C from le_sup_left) b hb).inter |
| ((show C ≤ B ⊔ C from le_sup_right) n hn) |
| · apply sup_le |
| · intro s hs |
| apply MeasurableSpace.measurableSet_generateFrom |
| exact ⟨s,Set.univ,hs,MeasurableSet.univ,(Set.inter_univ s).symm⟩ |
| · intro s hs |
| apply MeasurableSpace.measurableSet_generateFrom |
| exact ⟨Set.univ,s,MeasurableSet.univ,hs,(Set.univ_inter s).symm⟩ |
|
|
| lemma condIndep_join_public_right {C A B : MeasurableSpace Ω} |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (h : CondIndep C A B hC μ) : CondIndep C A (B ⊔ C) hC μ := by |
| let p : Set (Set Ω) := {s | MeasurableSet[A] s} |
| have hp : IsPiSystem p := by |
| intro s hs t ht _ |
| exact hs.inter ht |
| have hpg : A = MeasurableSpace.generateFrom p := |
| (@MeasurableSpace.generateFrom_measurableSet Ω A).symm |
| have hpM : ∀ s ∈ p, MeasurableSet[mΩ] s := hA |
| have hrM : ∀ s ∈ recordInterFamily B C, MeasurableSet[mΩ] s := by |
| rintro s ⟨b,n,hb,hn,rfl⟩ |
| exact (hB b hb).inter (hC n hn) |
| apply CondIndepSets.condIndep hA (sup_le hB hC) hp (recordInterFamily_pi B C) |
| hpg (recordInterFamily_generate B C).symm |
| rw [condIndepSets_iff C hC p (recordInterFamily B C) hpM hrM μ] |
| rintro s _ hs ⟨b,n,hb,hn,rfl⟩ |
| have hsb : Integrable ((s∩b).indicator (fun _ : Ω => (1:ℝ))) μ := |
| (integrable_const (1:ℝ)).indicator ((hA s hs).inter (hB b hb)) |
| have hbI : Integrable (b.indicator (fun _ : Ω => (1:ℝ))) μ := |
| (integrable_const (1:ℝ)).indicator (hB b hb) |
| have hleft := condExp_indicator hsb hn |
| have hright := condExp_indicator hbI hn |
| have he1 : (s∩(b∩n)).indicator (fun _ : Ω => (1:ℝ)) = |
| n.indicator ((s∩b).indicator (fun _ : Ω => (1:ℝ))) := by |
| ext x |
| by_cases hx : x∈n <;> by_cases hsx : x∈s <;> by_cases hbx : x∈b <;> simp [hx,hsx,hbx] |
| have he2 : (b∩n).indicator (fun _ : Ω => (1:ℝ)) = |
| n.indicator (b.indicator (fun _ : Ω => (1:ℝ))) := by |
| ext x |
| by_cases hx : x∈n <;> by_cases hbx : x∈b <;> simp [hx,hbx] |
| have hfactor := (condIndep_iff C A B hC hA hB μ).mp h s b hs hb |
| change μ[(s∩(b∩n)).indicator (fun _ => (1:ℝ)) | C] =ᵐ[μ] |
| μ[s.indicator (fun _ => (1:ℝ)) | C] * μ[(b∩n).indicator (fun _ => (1:ℝ)) | C] |
| rw [he1,he2] |
| filter_upwards [hleft,hright,hfactor] with x hx hy hz |
| change μ[n.indicator ((s∩b).indicator (fun _ => (1:ℝ))) | C] x = |
| μ[s.indicator (fun _ => (1:ℝ)) | C] x * |
| μ[n.indicator (b.indicator (fun _ => (1:ℝ))) | C] x |
| rw [hx,hy] |
| by_cases hxn : x∈n <;> simp [hxn,Pi.mul_apply] at hz ⊢ |
| exact hz |
| |
| lemma condIndep_local_message {C N A B : MeasurableSpace Ω} |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) (hCN : C ≤ N) |
| (hNA : N ≤ A ⊔ C) (h : CondIndep C A B hC μ) : |
| CondIndep N A B (hNA.trans (sup_le hA hC)) μ := by |
| have hjoin : CondIndep C (A ⊔ C) B hC μ := |
| (condIndep_join_public_right hC hB hA h.symm).symm |
| have href := condIndep_local_refinement hC (sup_le hA hC) hB |
| le_sup_right hCN hNA hjoin |
| exact condIndep_of_condIndep_of_le_left href le_sup_left |
| |
| end |
| |
| universe v3643_0 |
| |
| lemma condFactor_full_transcript {Ω : Type v3643_0} {mΩ : MeasurableSpace Ω} {μ : Measure Ω} |
| [inst3643_0 : IsFiniteMeasure μ] |
| (ℱ : Filtration ℕ mΩ) (f g : Ω → ℝ) |
| (h : ∀ n, μ[f*g | ℱ n] =ᵐ[μ] μ[f | ℱ n] * μ[g | ℱ n]) : |
| μ[f*g | ⨆ n, ℱ n] =ᵐ[μ] μ[f | ⨆ n, ℱ n] * μ[g | ⨆ n, ℱ n] := by |
| have he : ∀ᵐ x ∂μ, ∀ n, μ[f*g | ℱ n] x = μ[f | ℱ n] x * μ[g | ℱ n] x := |
| ae_all_iff.mpr h |
| filter_upwards [he, tendsto_ae_condExp (ℱ := ℱ) (f*g), |
| tendsto_ae_condExp (ℱ := ℱ) f, tendsto_ae_condExp (ℱ := ℱ) g] with x hx hfg hf hg |
| exact tendsto_nhds_unique hfg ((hf.mul hg).congr (fun n => (hx n).symm)) |
|
|
| lemma condIndep_full_transcript {Ω : Type v3643_0} {mΩ : MeasurableSpace Ω} {μ : Measure Ω} |
| [inst3643_0 : IsFiniteMeasure μ] |
| [StandardBorelSpace Ω] |
| (ℱ : Filtration ℕ mΩ) (mA mB : MeasurableSpace Ω) (hA : mA ≤ mΩ) (hB : mB ≤ mΩ) |
| (h : ∀ n, CondIndep (ℱ n) mA mB (ℱ.le n) μ) : |
| CondIndep (⨆ n, ℱ n) mA mB (iSup_le fun n => ℱ.le n) μ := by |
| rw [condIndep_iff _ _ _ _ hA hB] |
| intro s t hs ht |
| have hh (n : ℕ) := (condIndep_iff _ _ _ _ hA hB μ).mp (h n) s t hs ht |
| have he : (s ∩ t).indicator (fun _ : Ω => (1:ℝ)) = |
| s.indicator (fun _ : Ω => (1:ℝ)) * t.indicator (fun _ : Ω => (1:ℝ)) := by |
| ext x |
| by_cases hxs : x∈s < |
| simpa only [he] using condFactor_full_transcript ℱ (s.indicator (fun _ => (1:ℝ))) |
| (t.indicator (fun _ => (1:ℝ))) (by simpa only [he] using hh) |
|
|
| open MeasureTheory ProbabilityTheory Function Set |
|
|
| section |
|
|
| universe v3698_0 |
|
|
| lemma indep_condIndep_bot {Ω : Type v3698_0} {mΩ : MeasurableSpace Ω} |
| [StandardBorelSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {A B : MeasurableSpace Ω} (hA : A ≤ mΩ) (hB : B ≤ mΩ) (h : Indep A B P) : |
| CondIndep ⊥ A B bot_le P := by |
| rw [condIndep_iff _ _ _ _ hA hB] |
| intro s t hs ht |
| have hmul := (h.indepSet_of_measurableSet hs ht).measure_inter_eq_mul |
| simp only [condExp_bot, integral_indicator (hA s hs), integral_indicator (hB t ht), |
| integral_indicator ((hA s hs).inter (hB t ht)), integral_const, |
| smul_eq_mul, mul_one] |
| exact Filter.Eventually.of_forall fun _ => by |
| simpa only [Measure.real, Measure.restrict_apply_univ, Pi.mul_apply, ENNReal.toReal_mul] using congrArg ENNReal.toReal hmul |
|
|
| universe v3715_0 v3715_1 v3715_2 |
|
|
| structure LocalTapeProgram (U : Type v3715_0) (V : Type v3715_1) (M : Type v3715_2) [MeasurableSpace U] |
| [MeasurableSpace V] [MeasurableSpace M] where |
| alice : ℕ → Bool |
| sendA : (n : ℕ) → U × (Fin n → M) → M |
| sendB : (n : ℕ) → V × (Fin n → M) → M |
| measA : ∀ n, Measurable (sendA n) |
| measB : ∀ n, Measurable (sendB n) |
|
|
| namespace LocalTapeProgram |
|
|
| universe v3724_0 v3724_1 v3724_2 |
|
|
| variable {U : Type v3724_0} {V : Type v3724_1} {M : Type v3724_2} [inst3724_0 : MeasurableSpace U] [inst3724_1 : MeasurableSpace V] [inst3724_2 : MeasurableSpace M] |
| (p : LocalTapeProgram U V M) |
|
|
| def publicPrefix : (n : ℕ) → U × V → (Fin n → M) |
| | 0, _ => Fin.elim0 |
| | n+1, ω => Fin.snoc (publicPrefix n ω) |
| (if p.alice n then p.sendA n (ω.1,publicPrefix n ω) else p.sendB n (ω.2,publicPrefix n ω)) |
|
|
| end LocalTapeProgram |
|
|
| end |
|
|
| open MeasureTheory ProbabilityTheory Function Set unitInterval |
|
|
| universe v3943_0 v3943_1 |
|
|
| structure LocalOutcomeSampler (O : Type v3943_0) (M : Type v3943_1) [MeasurableSpace O] [MeasurableSpace M] where |
| alice : ℕ → Bool |
| sampleA : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × I → O |
| sampleB : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × I → O |
| sendA : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × O → M |
| sendB : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × O → M |
| sampleA_meas : ∀ n, Measurable (sampleA n) |
| sampleB_meas : ∀ n, Measurable (sampleB n) |
| sendA_meas : ∀ n, Measurable (sendA n) |
| sendB_meas : ∀ n, Measurable (sendB n) |
|
|
| namespace LocalOutcomeSampler |
|
|
| universe v3955_0 v3955_1 |
|
|
| variable {O : Type v3955_0} {M : Type v3955_1} [inst3955_0 : MeasurableSpace O] [inst3955_1 : MeasurableSpace M] |
| (p : LocalOutcomeSampler O M) |
|
|
| def privatePrefix (a : Bool) : (n : ℕ) → UniformTape × (Fin n → M) → (Fin n → (O ⊕ Unit)) |
| | 0, _ => Fin.elim0 |
| | n+1, pair => |
| let old := privatePrefix a n (pair.1,fun i => pair.2 i.castSucc) |
| let pubPast := fun i : Fin n => pair.2 i.castSucc |
| Fin.snoc old (if p.alice n = a then Sum.inl |
| (if a then p.sampleA n ((old,pubPast),pair.1 n) |
| else p.sampleB n ((old,pubPast),pair.1 n)) else Sum.inr ()) |
|
|
| def extractPrivate (a : Bool) (n : ℕ) (x : Fin n → O) : Fin n → (O ⊕ Unit) := |
| fun i => if p.alice i = a then Sum.inl (x i) else Sum.inr () |
|
|
| def publicFrom : (n : ℕ) → (Fin n → O) → (Fin n → M) |
| | 0, _ => Fin.elim0 |
| | n+1, x => |
| let old := fun i : Fin n => x i.castSucc |
| let pubPast := publicFrom n old |
| Fin.snoc pubPast (if p.alice n then |
| p.sendA n ((p.extractPrivate true n old,pubPast),x (Fin.last n)) else |
| p.sendB n ((p.extractPrivate false n old,pubPast),x (Fin.last n))) |
|
|
| end LocalOutcomeSampler |
|
|
| end |
|
|
| section |
|
|
| open MeasureTheory Matrix Filter |
|
|
| open scoped ComplexOrder MatrixOrder |
|
|
| universe v4350_0 v4350_1 |
|
|
| open scoped Matrix.Norms.L2Operator in |
| instance matrixMeasurableSpace {m : Type v4350_0} {n : Type v4350_1} [Fintype m] [Fintype n] : |
| MeasurableSpace (Matrix m n ℂ) := borel _ |
|
|
| universe v4353_0 v4353_1 |
|
|
| open scoped Matrix.Norms.L2Operator in |
| instance matrixBorelSpace {m : Type v4353_0} {n : Type v4353_1} [Fintype m] [Fintype n] : |
| BorelSpace (Matrix m n ℂ) := ⟨rfl⟩ |
|
|
| universe v4357_0 v4357_1 |
|
|
| variable {Ω : Type v4357_0} {ι : Type v4357_1} [inst4357_0 : MeasurableSpace Ω] [inst4357_1 : Fintype ι] [inst4357_2 : DecidableEq ι] |
|
|
| universe v4361_0 v4361_1 |
|
|
| structure PositiveMatrixMeasure (Ω : Type v4361_0) (ι : Type v4361_1) [MeasurableSpace Ω] [Fintype ι] where |
| entry : ι → ι → ComplexMeasure Ω |
| positive : ∀ S, MeasurableSet S → Matrix.PosSemidef (fun i j => entry i j S) |
|
|
| namespace PositiveMatrixMeasure |
|
|
| def value (W : PositiveMatrixMeasure Ω ι) (S : Set Ω) : Matrix ι ι ℂ := fun i j => W.entry i j S |
|
|
| def density (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) : Ω → Matrix ι ι ℂ := |
| fun t i j => (W.entry i j).rnDeriv μ t |
|
|
| omit inst4357_2 in |
| lemma measurable_density [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) : |
| Measurable (W.density μ) := by |
| have hh : Measurable (fun t i j => (W.entry i j).rnDeriv μ t) := by |
| apply Measurable.of_eval |
| apply Measurable.of_eval |
| unfold ComplexMeasure.rnDeriv |
| simp only [Complex.mk_eq_add_mul_I] |
| apply Measurable.add |
| · exact Complex.measurable_ofReal.comp ((W.entry i j).re.measurable_rnDeriv μ) |
| · exact (Complex.measurable_ofReal.comp ((W.entry i j).im.measurable_rnDeriv μ)).mul_const Complex.I |
|
|
| have hc : Continuous (Matrix.of : (ι → ι → ℂ) → Matrix ι ι ℂ) := by |
| exact continuous_matrix (fun i j => continuous_apply_apply i j) |
| exact hc.measurable.comp hh |
|
|
| omit inst4357_2 in |
| lemma integrable_entry [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) (i j : ι) : |
| Integrable (fun t => W.density μ t i j) μ := (W.entry i j).integrable_rnDeriv μ |
|
|
| omit inst4357_2 in |
| lemma entry_absolutelyContinuous [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) |
| (hAC : ∀ S, MeasurableSet S → μ S = 0 → W.value S = 0) (i j : ι) : |
| W.entry i j ≪ᵥ μ.toENNRealVectorMeasure := by |
| intro S hS |
| by_cases hs : MeasurableSet S |
| · have hm : μ S = 0 := by simpa [Measure.toENNRealVectorMeasure_apply,hs] using hS |
| exact congrArg (fun M : Matrix ι ι ℂ => M i j) (hAC S hs hm) |
| · exact (W.entry i j).not_measurable hs |
|
|
| lemma integral_density_entry (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ S, MeasurableSet S → μ S = 0 → W.value S = 0) |
| (S : Set Ω) (hS : MeasurableSet S) (i j : ι) : |
| (∫ t in S, W.density μ t i j ∂μ) = W.value S i j := by |
| have h := (ComplexMeasure.absolutelyContinuous_ennreal_iff _ _).mp |
| (W.entry_absolutelyContinuous μ hAC i j) |
| apply Complex.ext |
| · have hh := congrArg (fun s : SignedMeasure Ω => s S) |
| (SignedMeasure.withDensityᵥ_rnDeriv_eq (W.entry i j).re μ h.1) |
| rw [withDensityᵥ_apply (SignedMeasure.integrable_rnDeriv _ _) hS] at hh |
| change RCLike.re (∫ t in S, W.density μ t i j ∂μ) = _ |
| rw [← integral_re ((W.integrable_entry μ i j).integrableOn)] |
| exact hh |
| · have hh := congrArg (fun s : SignedMeasure Ω => s S) |
| (SignedMeasure.withDensityᵥ_rnDeriv_eq (W.entry i j).im μ h.2) |
| rw [withDensityᵥ_apply (SignedMeasure.integrable_rnDeriv _ _) hS] at hh |
| change RCLike.im (∫ t in S, W.density μ t i j ∂μ) = _ |
| rw [← integral_im ((W.integrable_entry μ i j).integrableOn)] |
| exact hh |
|
|
| end PositiveMatrixMeasure |
|
|
| lemma ae_complex_nonneg_of_integral_nonneg {μ : Measure Ω} {f : Ω → ℂ} |
| (hf : Integrable f μ) |
| (h : ∀ S, MeasurableSet S → μ S < ⊤ → 0 ≤ ∫ t in S, f t ∂μ) : |
| ∀ᵐ t ∂μ, 0 ≤ f t := by |
| have hre : ∀ᵐ t ∂μ, 0 ≤ (f t).re := by |
| apply ae_nonneg_of_forall_setIntegral_nonneg hf.re |
| intro S hs hm |
| rw [integral_re hf.integrableOn] |
| exact (RCLike.nonneg_iff.mp (h S hs hm)).1 |
| have him : (fun t => (f t).im) =ᵐ[μ] fun _ => (0:ℝ) := by |
| apply Integrable.ae_eq_of_forall_setIntegral_eq _ _ hf.im (integrable_zero _ _ _) |
| intro S hs hm |
| rw [integral_im hf.integrableOn] |
| simp only [Pi.zero_apply,integral_zero] |
| exact (RCLike.nonneg_iff.mp (h S hs hm)).2 |
| filter_upwards [hre,him] with t ht hi |
| exact RCLike.nonneg_iff.mpr ⟨ht,hi⟩ |
|
|
| def quadraticValue (v : ι → ℂ) (M : Matrix ι ι ℂ) : ℂ := |
| ∑ i, ∑ j, star (v i) * M i j * v j |
| |
| omit inst4357_2 in |
| lemma quadraticValue_eq [DecidableEq ι] (v : ι → ℂ) (M : Matrix ι ι ℂ) : |
| quadraticValue v M = star v ⬝ᵥ (M *ᵥ v) := by |
| simp [quadraticValue,dotProduct,Matrix.mulVec,Finset.mul_sum,mul_assoc] |
| |
| omit inst4357_2 in |
| lemma integrable_quadraticValue [DecidableEq ι] {μ : Measure Ω} {F : Ω → Matrix ι ι ℂ} |
| (hF : ∀ i j, Integrable (fun t => F t i j) μ) (v : ι → ℂ) : |
| Integrable (fun t => quadraticValue v (F t)) μ := by |
| apply integrable_finsetSum |
| apply integrable_finsetSum |
| exact ((hF i j).const_mul _).mul_const _ |
|
|
| omit inst4357_2 in |
| lemma integral_quadraticValue [DecidableEq ι] {μ : Measure Ω} {F : Ω → Matrix ι ι ℂ} |
| (hF : ∀ i j, Integrable (fun t => F t i j) μ) (v : ι → ℂ) : |
| (∫ t, quadraticValue v (F t) ∂μ) = quadraticValue v (fun i j => ∫ t, F t i j ∂μ) := by |
| unfold quadraticValue |
| rw [integral_finsetSum _ (fun i _ => integrable_finsetSum _ |
| (fun j _ => ((hF i j).const_mul _).mul_const _))] |
| apply Finset.sum_congr rfl |
| rw [integral_finsetSum _ (fun j _ => ((hF i j).const_mul _).mul_const _)] |
| apply Finset.sum_congr rfl |
| rw [integral_mul_const,integral_const_mul] |
|
|
| lemma density_posSemidef_ae (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ S, MeasurableSet S → μ S = 0 → W.value S = 0) : |
| ∀ᵐ t ∂μ, (W.density μ t).PosSemidef := by |
| have hherm : ∀ᵐ t ∂μ, (W.density μ t).IsHermitian := by |
| have hij (i j : ι) : (fun t => star (W.density μ t j i)) =ᵐ[μ] |
| (fun t => W.density μ t i j) := by |
| apply Integrable.ae_eq_of_forall_setIntegral_eq _ _ |
| ((Complex.conjCLE.integrable_comp_iff).mpr (W.integrable_entry μ j i)) (W.integrable_entry μ i j) |
| intro S hs hm |
| simp only [Complex.conjCLE_apply,integral_conj,W.integral_density_entry μ hAC S hs] |
| exact congrArg (fun M : Matrix ι ι ℂ => M i j) (W.positive S hs).isHermitian.eq |
| have hh : ∀ᵐ t ∂μ, ∀ i j, star (W.density μ t j i)=W.density μ t i j := |
| ae_all_iff.mpr (fun i => ae_all_iff.mpr (hij i)) |
| filter_upwards [hh] with t ht |
| exact Matrix.IsHermitian.ext ht |
| have hq (v : ι → ℂ) : ∀ᵐ t ∂μ, 0 ≤ quadraticValue v (W.density μ t) := by |
| apply ae_complex_nonneg_of_integral_nonneg |
| (integrable_quadraticValue (W.integrable_entry μ) v) |
| intro S hs hm |
| rw [integral_quadraticValue (fun i j => (W.integrable_entry μ i j).integrableOn)] |
| simp only [W.integral_density_entry μ hAC S hs] |
| change 0 ≤ quadraticValue v (W.value S) |
| rw [quadraticValue_eq] |
| exact (W.positive S hs).dotProduct_mulVec_nonneg v |
| obtain ⟨s,hs,hd⟩ := TopologicalSpace.exists_countable_dense (ι → ℂ) |
| let : Countable s := hs.to_subtype |
| have hqs : ∀ᵐ t ∂μ, ∀ v : s, 0 ≤ quadraticValue v (W.density μ t) := |
| ae_all_iff.mpr (fun v => hq v) |
| filter_upwards [hherm,hqs] with t ht hqt |
| apply Matrix.posSemidef_iff_dotProduct_mulVec.mpr |
| refine ⟨ht,fun v => ?_⟩ |
| rw [← quadraticValue_eq] |
| refine hd.denseRange_val.induction_on (p := fun v => 0 ≤ quadraticValue v (W.density μ t)) v ?_ hqt |
| · apply isClosed_le continuous_const |
| unfold quadraticValue |
| fun_prop |
|
|
| end |
|
|
| section |
|
|
| open MeasureTheory Matrix Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator ProbabilityTheory ENNReal NNReal Topology |
|
|
| universe v4526_0 |
|
|
| lemma psd_entry_norm_le_trace {ι : Type v4526_0} [inst4526_0 : Fintype ι] |
| [inst4526_1 : DecidableEq ι] |
| {M : Matrix ι ι ℂ} (hM : M.PosSemidef) (i j : ι) : |
| ‖M i j‖ ≤ (trace M).re := by |
| let S := CFC.sqrt M |
| have hS : S.IsHermitian := (CFC.sqrt_nonneg M).isSelfAdjoint.isHermitian |
| have hSS : S * Sᴴ = M := by rw [hS.eq] |
| let v (i : ι) : EuclideanSpace ℂ ι := WithLp.toLp 2 (fun k => S i k) |
| have he (i j : ι) : M i j = inner ℂ (v j) (v i) := by |
| rw [← hSS] |
| simp [v,Matrix.mul_apply,EuclideanSpace.inner_toLp_toLp,dotProduct] |
| have hv (i : ι) : ‖v i‖ = Real.sqrt (M i i).re := by |
| rw [he] |
| have hdiag (i : ι) : (M i i).re ≤ (trace M).re := by |
| change (M i i).re ≤ (∑ k, M k k).re |
| rw [Complex.re_sum] |
| exact Finset.single_le_sum (fun k _ => (RCLike.nonneg_iff.mp (hM.diag_nonneg (i:=k))).1) (Finset.mem_univ i) |
| have ht : 0 ≤ (trace M).re := (RCLike.nonneg_iff.mp hM.trace_nonneg).1 |
| calc |
| ‖M i j‖ ≤ ‖v j‖ * ‖v i‖ := by rw [he] |
| _ ≤ Real.sqrt (trace M).re * Real.sqrt (trace M).re := by |
| rw [hv,hv] |
| exact mul_le_mul (Real.sqrt_le_sqrt (hdiag j)) (Real.sqrt_le_sqrt (hdiag i)) |
| (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) |
| _ = (trace M).re := Real.mul_self_sqrt ht |
|
|
| universe v4553_0 |
|
|
| lemma uniformIntegrable_of_ae_norm_le_one {Ω : Type v4553_0} {mΩ : MeasurableSpace Ω} |
| {μ : Measure Ω} [inst4553_0 : IsFiniteMeasure μ] |
| {f : ℕ → Ω → ℝ} |
| (hf : ∀ n, AEStronglyMeasurable (f n) μ) (hb : ∀ n, ∀ᵐ ω ∂μ, ‖f n ω‖ ≤ 1) : |
| UniformIntegrable f 1 μ := by |
| apply uniformIntegrable_of le_rfl ENNReal.one_ne_top hf |
| intro ε hε |
| refine ⟨2, fun n => ?_⟩ |
| have hz : ({ω | (2:ℝ≥0) ≤ ‖f n ω‖₊}.indicator (f n)) =ᵐ[μ] 0 := by |
| filter_upwards [hb n] with ω hω |
| rw [Set.indicator_of_notMem] |
| · rfl |
| · simp only [Set.mem_ofPred_eq,not_le] |
| have : ‖f n ω‖₊ ≤ (1:ℝ≥0) := hω |
| exact lt_of_le_of_lt this (by norm_num) |
| rw [eLpNorm_congr_ae hz,eLpNorm_zero] |
| exact bot_le |
| |
| lemma bounded_martingale_limit {Ω : Type v4553_0} {mΩ : MeasurableSpace Ω} {μ : Measure Ω} |
| [inst4553_0 : IsFiniteMeasure μ] {F : Filtration ℕ mΩ} |
| {f : ℕ → Ω → ℝ} (hf : Martingale f F μ) |
| (hb : ∀ n, ∀ᵐ ω ∂μ, ‖f n ω‖ ≤ 1) : |
| ∃ g : Ω → ℝ, Integrable g μ ∧ |
| (∀ᵐ ω ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))) ∧ |
| (∀ n, f n =ᵐ[μ] μ[g | F n]) := by |
| have hui := uniformIntegrable_of_ae_norm_le_one |
| (fun n => ((hf.stronglyMeasurable n).mono (F.le n)).aestronglyMeasurable) hb |
| refine ⟨F.limitProcess f μ, ?_, hf.submartingale.ae_tendsto_limitProcess_of_uniformIntegrable hui, |
| hf.ae_eq_condExp_limitProcess hui⟩ |
| obtain ⟨R,hR⟩ := hui.2 |
| exact (hf.submartingale.memLp_limitProcess hR).integrable le_rfl |
|
|
| universe v4584_0 v4584_1 |
|
|
| variable {Ω : Type v4584_0} {ι : Type v4584_1} [inst4584_0 : MeasurableSpace Ω] [inst4584_1 : Fintype ι] [inst4584_2 : DecidableEq ι] |
| {μ : Measure Ω} {G : Ω → Matrix ι ι ℂ} |
|
|
| lemma integrable_matrix_of_entries (hG : ∀ i j, Integrable (fun ω => G ω i j) μ) : |
| Integrable G μ := by |
| have h : Integrable (fun ω i j => G ω i j) μ := |
| integrable_pi_iff.mpr (fun i => integrable_pi_iff.mpr (hG i)) |
| let L : (ι → ι → ℂ) →L[ℂ] Matrix ι ι ℂ := |
| LinearMap.toContinuousLinearMap (Matrix.ofLinearEquiv ℂ).toLinearMap |
| exact L.integrable_comp h |
|
|
| lemma integral_matrix_entry (hG : Integrable G μ) (i j : ι) : |
| (∫ ω, G ω ∂μ) i j = ∫ ω, G ω i j ∂μ := by |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap |
| exact (L.integral_comp_comm hG).symm |
|
|
| def positiveMatrixMeasureOfDensity (hG : ∀ i j, Integrable (fun ω => G ω i j) μ) |
| (hp : ∀ᵐ ω ∂μ, (G ω).PosSemidef) : PositiveMatrixMeasure Ω ι where |
| entry i j := μ.withDensityᵥ (fun ω => G ω i j) |
| positive S hS := by |
| have he : (fun i j => μ.withDensityᵥ (fun ω => G ω i j) S) = ∫ ω in S, G ω ∂μ := by |
| ext i j |
| rw [withDensityᵥ_apply (hG i j) hS, |
| integral_matrix_entry (integrable_matrix_of_entries hG).integrableOn] |
| rw [he] |
| exact (integral_nonneg_of_ae ((ae_restrict_of_ae hp).mono (fun _ h => h.nonneg))).posSemidef |
|
|
| lemma positiveMatrixMeasureOfDensity_value |
| (hG : ∀ i j, Integrable (fun ω => G ω i j) μ) |
| (hp : ∀ᵐ ω ∂μ, (G ω).PosSemidef) (S : Set Ω) (hS : MeasurableSet S) : |
| (positiveMatrixMeasureOfDensity hG hp).value S = ∫ ω in S, G ω ∂μ := by |
| ext i j |
| change μ.withDensityᵥ (fun ω => G ω i j) S = _ |
| rw [withDensityᵥ_apply (hG i j) hS, |
| integral_matrix_entry (integrable_matrix_of_entries hG).integrableOn] |
|
|
| end |
|
|
| section |
|
|
| open scoped ComplexOrder MatrixOrder Kronecker |
|
|
| open Matrix |
|
|
| universe v4714_0 v4714_1 v4714_2 |
|
|
| variable {ι : Type v4714_0} {κ : Type v4714_1} {η : Type v4714_2} [inst4714_0 : Fintype ι] [inst4714_1 : Fintype κ] [inst4714_2 : Fintype η] |
| [inst4714_3 : DecidableEq ι] [inst4714_4 : DecidableEq κ] [inst4714_5 : DecidableEq η] |
|
|
| def keepReference (U : Matrix (ι × η) (ι × η) ℂ) : Matrix η η ℂ := |
| fun x y => ∑ i, U (i,x) (i,y) |
|
|
| def referenceFilter (K : Matrix κ η ℂ) (U : Matrix (ι × η) (ι × η) ℂ) : |
| Matrix (ι × κ) (ι × κ) ℂ := |
| ((1 : Matrix ι ι ℂ) ⊗ₖ K) * U * ((1 : Matrix ι ι ℂ) ⊗ₖ K)ᴴ |
|
|
| omit inst4714_1 inst4714_4 inst4714_5 in |
| lemma referenceFilter_apply [Fintype κ] [DecidableEq κ] [DecidableEq η] (K : Matrix κ η ℂ) (U : Matrix (ι × η) (ι × η) ℂ) |
| (i j : ι) (x y : κ) : |
| referenceFilter K U (i,x) (j,y) = ∑ s, ∑ t, K x s * U (i,s) (j,t) * star (K y t) := by |
| simp only [referenceFilter,Matrix.conjTranspose_kronecker,Matrix.conjTranspose_one] |
| simp [Matrix.mul_apply,Fintype.sum_prod_type,Matrix.one_apply, |
| Matrix.conjTranspose_apply,Finset.sum_mul] |
| rw [Finset.sum_comm] |
|
|
| lemma keepReference_filter (K : Matrix κ η ℂ) (U : Matrix (ι × η) (ι × η) ℂ) : |
| keepReference (referenceFilter K U) = K * keepReference U * Kᴴ := by |
| ext x y |
| simp only [keepReference,referenceFilter_apply,Matrix.mul_apply,Matrix.conjTranspose_apply] |
| simp_rw [Finset.mul_sum,Finset.sum_mul] |
| conv_rhs => rw [Finset.sum_comm] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| rw [Finset.sum_comm] |
|
|
| def vectorize (S : Matrix ι η ℂ) : ι × η → ℂ := fun p => S p.1 p.2 |
|
|
| omit inst4714_2 inst4714_3 inst4714_5 in |
| lemma keepReference_vectorize [Fintype η] [DecidableEq ι] [DecidableEq η] (S : Matrix ι η ℂ) : |
| keepReference (outer (vectorize S) (vectorize S)) = (Sᴴ*S)ᵀ := by |
| ext x y |
| simp only [keepReference,outer,vectorize,Matrix.transpose_apply,Matrix.mul_apply, |
| Matrix.conjTranspose_apply] |
| apply Finset.sum_congr rfl |
|
|
| lemma referenceFilter_vectorize (K : Matrix κ η ℂ) (S : Matrix ι η ℂ) : |
| referenceFilter K (outer (vectorize S) (vectorize S)) = |
| outer (vectorize (S*Kᵀ)) (vectorize (S*Kᵀ)) := by |
| ext ⟨i,x⟩ ⟨j,y⟩ |
| rw [referenceFilter_apply] |
| simp only [outer,vectorize,Matrix.mul_apply,Matrix.transpose_apply,star_sum,star_mul] |
| simp_rw [Finset.mul_sum,Finset.sum_mul] |
| conv_rhs => rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| apply Finset.sum_congr rfl |
| ring |
|
|
| def localProbe : ι × ι → ℂ := |
| vectorize (((Real.sqrt (Fintype.card ι : ℝ))⁻¹ : ℂ) • (1 : Matrix ι ι ℂ)) |
|
|
| def canonicalPurification (R : Matrix ι ι ℂ) : ι × ι → ℂ := vectorize (CFC.sqrt R) |
|
|
| def preparationFilter (R : Matrix ι ι ℂ) : Matrix ι ι ℂ := |
| (Real.sqrt (Fintype.card ι : ℝ) : ℂ) • (CFC.sqrt R)ᵀ |
|
|
| lemma preparation_filter_identity [Nonempty ι] (R : Matrix ι ι ℂ) : |
| referenceFilter (preparationFilter R) (outer (localProbe (ι := ι)) localProbe) = |
| outer (canonicalPurification R) (canonicalPurification R) := by |
| unfold localProbe canonicalPurification preparationFilter |
| rw [referenceFilter_vectorize,Matrix.transpose_smul,Matrix.transpose_transpose, |
| Matrix.smul_mul,Matrix.mul_smul,one_mul,smul_smul] |
| have hc : (Real.sqrt (Fintype.card ι : ℝ) : ℂ) ≠ 0 := by |
| exact Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr (by exact_mod_cast Fintype.card_pos)).ne' |
| rw [inv_mul_cancel₀ hc,one_smul] |
| |
| lemma canonical_reference (R : Matrix ι ι ℂ) (hR : R.PosSemidef) : |
| keepReference (outer (canonicalPurification R) (canonicalPurification R)) = Rᵀ := by |
| rw [canonicalPurification,keepReference_vectorize, |
| (CFC.sqrt_nonneg R).posSemidef.isHermitian.eq,CFC.sqrt_mul_sqrt_self R hR.nonneg] |
| |
| end |
| |
| namespace PositiveMatrixMeasure |
| |
| section |
| |
| open MeasureTheory Matrix Filter |
| |
| open scoped ComplexOrder MatrixOrder |
| |
| universe v4860_0 v4860_1 |
| |
| variable {Ω : Type v4860_0} {ι : Type v4860_1} [inst4860_0 : MeasurableSpace Ω] [inst4860_1 : Fintype ι] [inst4860_2 : DecidableEq ι] |
| |
| def traceSigned (W : PositiveMatrixMeasure Ω ι) : SignedMeasure Ω := |
| ∑ i, (W.entry i i).re |
| |
| omit inst4860_2 in |
| lemma traceSigned_apply [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (S : Set Ω) : |
| W.traceSigned S = (trace (W.value S)).re := by |
| simp [traceSigned,trace,value,ComplexMeasure.re_apply] |
| apply Finset.sum_congr rfl; intro i _; rfl |
| |
| lemma traceSigned_nonneg (W : PositiveMatrixMeasure Ω ι) : |
| (0 : SignedMeasure Ω) ≤[Set.univ] W.traceSigned := by |
| simpa only [VectorMeasure.restrict_univ] using (show (0 : SignedMeasure Ω) ≤ W.traceSigned from by |
| intro S hS |
| change 0 ≤ W.traceSigned S |
| rw [traceSigned_apply] |
| have hh : (0:ℂ) ≤ trace (W.value S) := (W.positive S hS).trace_nonneg |
| exact (RCLike.nonneg_iff.mp hh).1) |
| |
| def traceMeasure (W : PositiveMatrixMeasure Ω ι) : Measure Ω := |
| W.traceSigned.toMeasureOfZeroLE Set.univ MeasurableSet.univ (by |
| simpa only [VectorMeasure.restrict_univ] using |
| (show (0 : SignedMeasure Ω) ≤ W.traceSigned from by |
| intro S hS |
| have htrace : W.traceSigned S = (trace (W.value S)).re := by |
| simp [traceSigned, trace, value, ComplexMeasure.re_apply] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rfl |
| change 0 ≤ W.traceSigned S |
| rw [htrace] |
| exact (RCLike.nonneg_iff.mp (W.positive S hS).trace_nonneg).1)) |
| |
| instance traceMeasure_finite (W : PositiveMatrixMeasure Ω ι) : IsFiniteMeasure W.traceMeasure := |
| inferInstanceAs (IsFiniteMeasure (W.traceSigned.toMeasureOfZeroLE Set.univ |
| MeasurableSet.univ W.traceSigned_nonneg)) |
| |
| lemma integrable_trace_density (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) : |
| Integrable (fun t => trace (W.density μ t)) μ := by |
| exact integrable_finsetSum _ (fun i _ => W.integrable_entry μ i i) |
| |
| lemma integral_trace_density (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ S, MeasurableSet S → μ S=0 → W.value S=0) |
| (S : Set Ω) (hS : MeasurableSet S) : |
| (∫ t in S, trace (W.density μ t) ∂μ) = trace (W.value S) := by |
| unfold trace diag |
| rw [integral_finsetSum _ (fun i _ => (W.integrable_entry μ i i).integrableOn)] |
| apply Finset.sum_congr rfl; intro i _ |
| exact W.integral_density_entry μ hAC S hS i i |
| |
| universe v4989_0 |
| |
| def filter {κ : Type v4989_0} [Fintype κ] (W : PositiveMatrixMeasure Ω ι) (K : Matrix κ ι ℂ) : |
| PositiveMatrixMeasure Ω κ where |
| entry x y := ∑ i, ∑ j, (K x i * star (K y j)) • W.entry i j |
| positive S hS := by |
| have he : (fun x y => (∑ i, ∑ j, (K x i * star (K y j)) • W.entry i j) S) = |
| K * W.value S * Kᴴ := by |
| ext x y |
| simp only [_root_.sum_apply,_root_.smul_apply,Matrix.mul_apply, |
| Matrix.conjTranspose_apply,smul_eq_mul,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro i _ |
| apply Finset.sum_congr rfl; intro j _ |
| dsimp [value] |
| ring |
| rw [he] |
| exact (W.positive S hS).mul_mul_conjTranspose_same K |
| |
| universe v5006_0 |
| |
| omit inst4860_2 in |
| lemma filter_value [DecidableEq ι] {κ : Type v5006_0} [Fintype κ] (W : PositiveMatrixMeasure Ω ι) |
| (K : Matrix κ ι ℂ) (S : Set Ω) : (W.filter K).value S = K * W.value S * Kᴴ := by |
| ext x y |
| simp only [filter,value,_root_.sum_apply,_root_.smul_apply,Matrix.mul_apply, |
| Matrix.conjTranspose_apply,smul_eq_mul,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl; intro i _ |
| apply Finset.sum_congr rfl; intro j _ |
| ring |
| |
| end |
| |
| open Matrix MeasureTheory |
| |
| open scoped ComplexOrder MatrixOrder Kronecker Matrix.Norms.L2Operator |
| |
| universe v5077_0 v5077_1 v5077_2 |
| |
| variable {O : Type v5077_0} {ι : Type v5077_1} {η : Type v5077_2} [inst5077_0 : MeasurableSpace O] [inst5077_1 : Fintype ι] [inst5077_2 : Fintype η] |
| [inst5077_3 : DecidableEq ι] [inst5077_4 : DecidableEq η] |
| |
| universe v5098_0 |
| |
| def pushforward {T : Type v5098_0} [MeasurableSpace T] (W : PositiveMatrixMeasure O η) |
| (f : O → T) (hf : Measurable f) : PositiveMatrixMeasure T η where |
| entry i j := (W.entry i j).map f |
| positive S hS := by |
| simpa only [VectorMeasure.map_apply _ hf hS] using W.positive (f ⁻¹' S) (hf hS) |
|
|
| universe v5104_0 |
|
|
| omit inst5077_4 in |
| lemma pushforward_value [DecidableEq η] {T : Type v5104_0} [MeasurableSpace T] (W : PositiveMatrixMeasure O η) |
| (f : O → T) (hf : Measurable f) (S : Set T) (hS : MeasurableSet S) : |
| (W.pushforward f hf).value S = W.value (f ⁻¹' S) := by |
| ext i j; exact VectorMeasure.map_apply _ hf hS |
| |
| end PositiveMatrixMeasure |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe v5273_0 |
| |
| variable {O : Type v5273_0} [inst5273_0 : MeasurableSpace O] |
| |
| def historyPrefix (n : ℕ) (x : ℕ → O) : Fin n → O := fun i => x i |
| |
| lemma measurable_historyPrefix (n : ℕ) : Measurable (historyPrefix (O := O) n) := by |
| unfold historyPrefix |
| fun_prop |
| |
| def historyFiltration : Filtration ℕ (inferInstance : MeasurableSpace (ℕ → O)) where |
| seq n := MeasurableSpace.comap (historyPrefix n) inferInstance |
| mono' := by |
| intro n k hnk |
| apply MeasurableSpace.comap_le_iff_le_map.mpr |
| intro S hS |
| change MeasurableSet[MeasurableSpace.comap (historyPrefix k) inferInstance] |
| (historyPrefix n ⁻¹' S) |
| refine ⟨(fun s : Fin k → O => fun i : Fin n => s (Fin.castLE hnk i)) ⁻¹' S, |
| (show Measurable (fun s : Fin k → O => fun i : Fin n => s (Fin.castLE hnk i)) by fun_prop) hS,?_⟩ |
| rfl |
| le' n := (show Measurable (historyPrefix (O := O) n) by unfold historyPrefix; fun_prop).comap_le |
| |
| lemma historyPrefix_adapted (n : ℕ) : |
| Measurable[(historyFiltration (O := O)) n] (historyPrefix (O := O) n) := |
| Measurable.of_comap_le le_rfl |
| |
| lemma historyFiltration_generates : |
| (inferInstance : MeasurableSpace (ℕ → O)) = ⨆ n, historyFiltration (O := O) n := by |
| apply le_antisymm |
| · change (⨆ k : ℕ, MeasurableSpace.comap (fun x : ℕ → O => x k) inferInstance) ≤ _ |
| apply iSup_le |
| intro k |
| apply le_iSup_of_le (k+1) |
| have hk := (measurable_pi_apply (⟨k,Nat.lt_succ_self k⟩ : Fin (k+1))).comp |
| (historyPrefix_adapted (O := O) (k+1)) |
| exact hk.comap_le |
| · exact iSup_le (fun n => (historyFiltration (O := O)).le n) |
| |
| universe v5311_0 |
| |
| variable {ι : Type v5311_0} [inst5311_0 : Fintype ι] [inst5311_1 : DecidableEq ι] |
| |
| universe v5313_0 |
| |
| lemma density_entry_bound {Ω : Type v5313_0} [MeasurableSpace Ω] |
| (U : Ω → Matrix ι ι ℂ) (hU : ∀ x, Density (U x)) (i j : ι) (x : Ω) : |
| ‖U x i j‖ ≤ 1 := by |
| have h := psd_entry_norm_le_trace (hU x).1 i j |
| simpa only [(hU x).2,Complex.one_re] using h |
| |
| universe v5319_0 |
| |
| lemma integrable_density_entry {Ω : Type v5319_0} [MeasurableSpace Ω] |
| (U : Ω → Matrix ι ι ℂ) (hU : ∀ x, Density (U x)) (hm : Measurable U) |
| (μ : Measure Ω) [IsFiniteMeasure μ] (i j : ι) : |
| Integrable (fun x => U x i j) μ := by |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap |
| exact Integrable.of_bound (L.continuous.measurable.comp hm).aestronglyMeasurable 1 |
| (Filter.Eventually.of_forall (density_entry_bound U hU i j)) |
| |
| variable (P : Measure (ℕ → O)) [inst5327_0 : IsProbabilityMeasure P] |
| (K : (n : ℕ) → Kernel (Fin n → O) O) [inst5327_1 : ∀ n, IsMarkovKernel (K n)] |
| (hP : ∀ n, P.map (historyPrefix (n+1)) = |
| ((P.map (historyPrefix n)) ⊗ₘ K n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) |
| (U : (n : ℕ) → (Fin n → O) → Matrix ι ι ℂ) |
| (hU : ∀ n s, Density (U n s)) (hm : ∀ n, Measurable (U n)) |
| (hmean : ∀ n s i j, |
| (∫ o, U (n+1) (Fin.snoc (α := fun _ : Fin (n+1) => O) s o) i j ∂K n s) = U n s i j) |
| |
| include hP hU hm hmean in |
| lemma reference_history_step_integral (n : ℕ) (S : Set (ℕ → O)) |
| (hS : MeasurableSet[historyFiltration n] S) (i j : ι) : |
| (∫ x in S, U (n+1) (historyPrefix (n+1) x) i j ∂P) = |
| ∫ x in S, U n (historyPrefix n x) i j ∂P := by |
| classical |
| obtain ⟨A,hA,rfl⟩ := hS |
| let r : (Fin (n+1) → O) → (Fin n → O) := fun s i => s i.castSucc |
| have hr : Measurable r := by fun_prop |
| let snoc : (Fin n → O) × O → (Fin (n+1) → O) := fun s => Fin.snoc s.1 s.2 |
| have hs : Measurable snoc := by |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa [snoc] using measurable_snd |
| · simpa only [snoc, Fin.snoc_castSucc, Function.comp_def] using ((measurable_pi_apply j).comp measurable_fst) |
| let f : (Fin (n+1) → O) → ℂ := (r ⁻¹' A).indicator (fun s => U (n+1) s i j) |
| let g : (Fin n → O) → ℂ := A.indicator (fun s => U n s i j) |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap |
| have hf : Measurable f := (L.continuous.measurable.comp (hm (n+1))).indicator (hr hA) |
| have hg : Measurable g := (L.continuous.measurable.comp (hm n)).indicator hA |
| have hfi : Integrable (fun s => f (snoc s)) ((P.map (historyPrefix n)) ⊗ₘ K n) := by |
| apply Integrable.of_bound (hf.comp hs).aestronglyMeasurable 1 |
| apply Filter.Eventually.of_forall |
| intro s |
| exact (norm_indicator_le_norm_self (s := r ⁻¹' A) (fun t => U (n+1) t i j) (snoc s)).trans (density_entry_bound (U (n+1)) (hU (n+1)) i j _) |
| have he (s : Fin n → O) : (∫ o, f (snoc (s,o)) ∂K n s) = g s := by |
| have hh (o : O) : f (snoc (s,o)) = |
| if s ∈ A then U (n+1) (Fin.snoc s o) i j else 0 := by |
| simp only [f,Set.indicator,Set.mem_preimage,r,snoc] |
| have ht : (fun i : Fin n => Fin.snoc (α := fun _ : Fin (n+1) => O) s o i.castSucc) = s := by |
| ext i; simp |
| rw [ht] |
| simp_rw [hh] |
| by_cases h : s ∈ A |
| · simp only [h,ite_true,g,Set.indicator_of_mem] |
| exact hmean n s i j |
| · simp [h,g] |
| calc |
| _ = ∫ x, f (historyPrefix (n+1) x) ∂P := by |
| rw [← integral_indicator ((measurable_historyPrefix n) hA)] |
| congr 1 |
| _ = ∫ s, f s ∂P.map (historyPrefix (n+1)) := |
| (integral_map (measurable_historyPrefix _).aemeasurable hf.aestronglyMeasurable).symm |
| _ = ∫ s, f s ∂(((P.map (historyPrefix n)) ⊗ₘ K n).map snoc) := by rw [hP n] |
| _ = ∫ s, f (snoc s) ∂((P.map (historyPrefix n)) ⊗ₘ K n) := |
| integral_map hs.aemeasurable hf.aestronglyMeasurable |
| _ = ∫ s, ∫ o, f (snoc (s,o)) ∂K n s ∂P.map (historyPrefix n) := |
| MeasureTheory.Measure.integral_compProd hfi |
| _ = ∫ s, g s ∂P.map (historyPrefix n) := by simp_rw [he] |
| _ = ∫ x, g (historyPrefix n x) ∂P := |
| integral_map (measurable_historyPrefix n).aemeasurable hg.aestronglyMeasurable |
| _ = _ := by |
| rw [← integral_indicator ((measurable_historyPrefix n) hA)] |
| rfl |
| |
| include hP hU hm hmean in |
| lemma reference_history_integral (n k : ℕ) (hnk : n ≤ k) (S : Set (ℕ → O)) |
| (hS : MeasurableSet[historyFiltration n] S) (i j : ι) : |
| (∫ x in S, U k (historyPrefix k x) i j ∂P) = |
| ∫ x in S, U n (historyPrefix n x) i j ∂P := by |
| induction k, hnk using Nat.le_induction with |
| | base => rfl |
| | succ k hnk ih => |
| rw [reference_history_step_integral P K hP U hU hm hmean k S |
| (((historyFiltration (O := O)).mono hnk) S hS) i j] |
| exact ih |
| |
| omit inst5311_1 in |
| lemma reference_history_measurable [DecidableEq ι] (n : ℕ) (i j : ι) (hm : ∀ n, Measurable (U n)) : |
| Measurable[historyFiltration n] (fun x => U n (historyPrefix n x) i j) := by |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap |
| exact L.continuous.measurable.comp ((hm n).comp (historyPrefix_adapted n)) |
| |
| lemma reference_history_integrable (n : ℕ) (i j : ι) (hU : ∀ n s, Density (U n s)) |
| (hm : ∀ n, Measurable (U n)) : |
| Integrable (fun x => U n (historyPrefix n x) i j) P := by |
| exact integrable_density_entry (fun x => U n (historyPrefix n x)) |
| (fun x => hU n _) ((hm n).comp (measurable_historyPrefix n)) P i j |
| |
| include hP hU hm hmean in |
| lemma reference_history_martingale_re (i j : ι) : |
| Martingale (fun n x => (U n (historyPrefix n x) i j).re) historyFiltration P := by |
| refine ⟨fun n => ((reference_history_measurable U n i j hm).re).stronglyMeasurable, ?_⟩ |
| intro n k hnk |
| symm |
| apply ae_eq_condExp_of_forall_setIntegral_eq (historyFiltration.le n) |
| ((reference_history_integrable P U k i j hU hm).re) |
| · intro S _ _ |
| exact (reference_history_integrable P U n i j hU hm).re.integrableOn |
| · intro S hS _ |
| change (∫ x in S, RCLike.re (U n (historyPrefix n x) i j) ∂P) = _ |
| rw [integral_re (reference_history_integrable P U n i j hU hm).integrableOn, |
| integral_re (reference_history_integrable P U k i j hU hm).integrableOn, |
| reference_history_integral P K hP U hU hm hmean n k hnk S hS i j] |
| · exact ((reference_history_measurable U n i j hm).re).stronglyMeasurable.aestronglyMeasurable |
| |
| include hP hU hm hmean in |
| lemma reference_history_martingale_im (i j : ι) : |
| Martingale (fun n x => (U n (historyPrefix n x) i j).im) historyFiltration P := by |
| refine ⟨fun n => ((reference_history_measurable U n i j hm).im).stronglyMeasurable, ?_⟩ |
| intro n k hnk |
| symm |
| apply ae_eq_condExp_of_forall_setIntegral_eq (historyFiltration.le n) |
| ((reference_history_integrable P U k i j hU hm).im) |
| · intro S _ _ |
| exact (reference_history_integrable P U n i j hU hm).im.integrableOn |
| · intro S hS _ |
| change (∫ x in S, RCLike.im (U n (historyPrefix n x) i j) ∂P) = _ |
| rw [integral_im (reference_history_integrable P U n i j hU hm).integrableOn, |
| integral_im (reference_history_integrable P U k i j hU hm).integrableOn, |
| reference_history_integral P K hP U hU hm hmean n k hnk S hS i j] |
| · exact ((reference_history_measurable U n i j hm).im).stronglyMeasurable.aestronglyMeasurable |
| |
| end |
| |
| open MeasureTheory ProbabilityTheory Matrix Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Topology |
| |
| universe v5486_0 v5486_1 |
| |
| variable {Ω : Type v5486_0} {ι : Type v5486_1} {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| [inst5486_0 : Fintype ι] [inst5486_1 : DecidableEq ι] {μ : Measure Ω} [inst5486_2 : IsFiniteMeasure μ] |
| {F : Filtration ℕ mΩ} |
| |
| theorem local_reference_limit |
| (W : ℕ → Ω → Matrix ι ι ℂ) |
| (hW : ∀ n x, Density (W n x)) |
| (hlocal : ∀ n, Measurable[L] (W n)) |
| (hL : L ≤ mΩ) |
| (hr : ∀ i j, Martingale (fun n x => (W n x i j).re) F μ) |
| (hi : ∀ i j, Martingale (fun n x => (W n x i j).im) F μ) : |
| ∃ G : Ω → Matrix ι ι ℂ, |
| Measurable[L] G ∧ (∀ x, Density (G x)) ∧ |
| (∀ i j, Integrable (fun x => G x i j) μ) ∧ |
| (∀ᵐ x ∂μ, Tendsto (fun n => W n x) atTop (𝓝 (G x))) ∧ |
| (∀ n S, MeasurableSet[F n] S → |
| (∫ x in S, G x ∂μ) = ∫ x in S, W n x ∂μ) := by |
| classical |
| have hbound (n : ℕ) (i j : ι) (x : Ω) : ‖W n x i j‖ ≤ 1 := by |
| simpa only [(hW n x).2, Complex.one_re] using |
| psd_entry_norm_le_trace (hW n x).1 i j |
| have hbr (i j : ι) (n : ℕ) : ∀ᵐ x ∂μ, ‖(W n x i j).re‖ ≤ 1 := |
| Filter.Eventually.of_forall (fun x => |
| (show ‖(W n x i j).re‖ ≤ ‖W n x i j‖ from by |
| simpa only [Real.norm_eq_abs] using Complex.abs_re_le_norm (W n x i j)).trans |
| (hbound n i j x)) |
| have hbi (i j : ι) (n : ℕ) : ∀ᵐ x ∂μ, ‖(W n x i j).im‖ ≤ 1 := |
| Filter.Eventually.of_forall (fun x => |
| (show ‖(W n x i j).im‖ ≤ ‖W n x i j‖ from by |
| simpa only [Real.norm_eq_abs] using Complex.abs_im_le_norm (W n x i j)).trans |
| (hbound n i j x)) |
| choose gr hgr htr hcr using (fun i j => bounded_martingale_limit (hr i j) (hbr i j)) |
| choose gi hgi hti hci using (fun i j => bounded_martingale_limit (hi i j) (hbi i j)) |
| let H : Ω → Matrix ι ι ℂ := fun x i j => (gr i j x : ℂ) + (gi i j x : ℂ)*Complex.I |
| have hH (i j : ι) : Integrable (fun x => H x i j) μ := |
| ((hgr i j).ofReal).add (((hgi i j).ofReal).mul_const Complex.I) |
| have hlimH : ∀ᵐ x ∂μ, Tendsto (fun n => W n x) atTop (𝓝 (H x)) := by |
| have htr' := ae_all_iff.mpr (fun i => ae_all_iff.mpr (htr i)) |
| have hti' := ae_all_iff.mpr (fun i => ae_all_iff.mpr (hti i)) |
| filter_upwards [htr', hti'] with x hx hy |
| have hc : Tendsto (fun n i j => W n x i j) atTop (𝓝 (fun i j => H x i j)) := by |
| apply tendsto_pi_nhds.mpr; intro i |
| apply tendsto_pi_nhds.mpr; intro j |
| have hh := (Complex.continuous_ofReal.continuousAt.tendsto.comp (hx i j)).add |
| ((Complex.continuous_ofReal.continuousAt.tendsto.comp (hy i j)).mul_const Complex.I) |
| simpa only [Function.comp_apply, Pi.add_apply, Complex.re_add_im] using hh |
| have hcM : Continuous (Matrix.of : (ι → ι → ℂ) → Matrix ι ι ℂ) := |
| continuous_matrix (fun i j => continuous_apply_apply i j) |
| exact hcM.continuousAt.tendsto.comp hc |
| let raw : Ω → Matrix ι ι ℂ := fun x => limUnder atTop (fun n => W n x) |
| have hraw : Measurable[L] raw := |
| (@StronglyMeasurable.limUnder ℕ Ω (Matrix ι ι ℂ) L _ _ atTop _ _ _ _ |
| (fun n => (hlocal n).stronglyMeasurable)).measurable |
| have hgood : MeasurableSet[L] {x | 0 ≤ raw x ∧ trace (raw x) = 1} := by |
| exact (measurableSet_le measurable_const hraw).inter |
| (measurableSet_eq_fun ((Matrix.traceLinearMap ι ℂ ℂ).toContinuousLinearMap.continuous.measurable.comp hraw) measurable_const) |
| let G : Ω → Matrix ι ι ℂ := fun x => |
| if 0 ≤ raw x ∧ trace (raw x) = 1 then raw x else W 0 x |
| have hGm : Measurable[L] G := hraw.ite hgood (hlocal 0) |
| have hGp (x : Ω) : Density (G x) := by |
| dsimp [G] |
| split |
| · rename_i h |
| exact ⟨h.1.posSemidef, h.2⟩ |
| · exact hW 0 x |
| have hGH : G =ᵐ[μ] H := by |
| filter_upwards [hlimH] with x hx |
| have hrx : raw x = H x := hx.limUnder_eq |
| have hp : 0 ≤ H x := |
| isClosed_Ici.mem_of_tendsto hx (Eventually.of_forall (fun n => (hW n x).1.nonneg)) |
| have ht : trace (H x) = 1 := by |
| have htend := (Matrix.traceLinearMap ι ℂ ℂ).toContinuousLinearMap.continuous.continuousAt.tendsto.comp hx |
| have he : (fun n => trace (W n x)) = fun _ => (1 : ℂ) := funext (fun n => (hW n x).2) |
| change Tendsto (fun n => trace (W n x)) atTop (𝓝 (trace (H x))) at htend |
| rw [he] at htend |
| exact tendsto_nhds_unique htend tendsto_const_nhds |
| simp only [G, hrx, hp, ht, and_self, ↓reduceIte] |
| have hGi (i j : ι) : Integrable (fun x => G x i j) μ := |
| (hH i j).congr (hGH.mono (fun x hx => congrArg (fun M => M i j) hx.symm)) |
| refine ⟨G,hGm,hGp,hGi,?_,?_⟩ |
| · filter_upwards [hlimH,hGH] with x hx he |
| simpa only [he] using hx |
| · intro n S hS |
| have hc (i j : ι) : Integrable (fun x => W n x i j) μ := |
| Integrable.of_bound (((Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap).measurable.comp |
| ((hlocal n).mono hL le_rfl)).aestronglyMeasurable 1 |
| (Eventually.of_forall (hbound n i j)) |
| ext i j |
| rw [integral_matrix_entry (integrable_matrix_of_entries hGi).integrableOn, |
| integral_matrix_entry (integrable_matrix_of_entries hc).integrableOn] |
| calc |
| _ = ∫ x in S, H x i j ∂μ := integral_congr_ae |
| (ae_restrict_of_ae (hGH.mono (fun x hx => congrArg (fun M => M i j) hx))) |
| _ = ∫ x in S, W n x i j ∂μ := by |
| apply Complex.ext |
| · change RCLike.re (∫ x in S, H x i j ∂μ) = RCLike.re (∫ x in S, W n x i j ∂μ) |
| rw [← integral_re (hH i j).integrableOn, ← integral_re (hc i j).integrableOn] |
| have heH : (fun x => RCLike.re (H x i j)) = gr i j := by |
| funext x; simp [H] |
| rw [heH, ← setIntegral_condExp (F.le n) (hgr i j) hS] |
| exact integral_congr_ae (ae_restrict_of_ae (hcr i j n).symm) |
| · change RCLike.im (∫ x in S, H x i j ∂μ) = RCLike.im (∫ x in S, W n x i j ∂μ) |
| rw [← integral_im (hH i j).integrableOn, ← integral_im (hc i j).integrableOn] |
| have heH : (fun x => RCLike.im (H x i j)) = gi i j := by |
| funext x; simp [H] |
| rw [heH, ← setIntegral_condExp (F.le n) (hgi i j) hS] |
| exact integral_congr_ae (ae_restrict_of_ae (hci i j n).symm) |
| |
| end ZeroKey |
| |
| namespace UnrestrictedQuantum |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| universe v5616_0 v5616_1 |
| |
| abbrev LocalHistory (O : Type v5616_0) (M : Type v5616_1) (n : ℕ) := |
| (Fin n → (O ⊕ Unit)) × (Fin n → M) |
| |
| universe v5619_0 v5619_1 |
| |
| def localActive {O : Type v5619_0} {M : Type v5619_1} {n : ℕ} (h : LocalHistory O M n) (o : O) (m : M) : |
| LocalHistory O M (n+1) := |
| (Fin.snoc h.1 (Sum.inl o), Fin.snoc h.2 m) |
| |
| universe v5623_0 v5623_1 |
| |
| def localPassive {O : Type v5623_0} {M : Type v5623_1} {n : ℕ} (h : LocalHistory O M n) (m : M) : |
| LocalHistory O M (n+1) := |
| (Fin.snoc h.1 (Sum.inr ()), Fin.snoc h.2 m) |
| |
| universe v5628_0 v5628_1 v5628_2 v5628_3 |
| |
| variable {O : Type v5628_0} {M : Type v5628_1} {ι : Type v5628_2} [inst5628_0 : MeasurableSpace O] [inst5628_1 : MeasurableSpace M] |
| [inst5628_2 : Fintype ι] [inst5628_3 : DecidableEq ι] |
| (A : ℕ → Type v5628_3) [inst5628_4 : ∀ n, AddCommGroup (A n)] [inst5628_5 : ∀ n, Module ℂ (A n)] |
| [inst5628_6 : ∀ n, One (A n)] [inst5628_7 : ∀ n, LE (A n)] |
| (κ : (n : ℕ) → Kernel (LocalHistory O M n) O) |
| (send : (n : ℕ) → (LocalHistory O M n) × O → M) |
| |
| structure LocalObservableExecution where |
| state : (n : ℕ) → LocalHistory O M n → ReferenceFunctional (A n) ι |
| positive_state : ∀ n h, PositiveFunctional (state n h) |
| positive_unit : ∀ n, (0 : A n) ≤ 1 |
| normalized : ∀ n h, trace (state n h 1) = 1 |
| measurable_reference : ∀ n, Measurable (fun h => state n h 1) |
| instrument : (n : ℕ) → (h : LocalHistory O M n) → ObservableInstrument O (A n) (A (n+1)) |
| run : ∀ n h, InstrumentRun (instrument n h) (state n h) |
| run_law : ∀ n h, (run n h).law = κ n h |
| active_update : ∀ n h, |
| (fun o => state (n+1) (localActive h o (send n (h,o)))) =ᵐ[κ n h] (run n h).posterior |
| receive : (n : ℕ) → LocalHistory O M n → M → (A (n+1) →ₗ[ℂ] A n) |
| receive_positive : ∀ n h m x, 0 ≤ x → 0 ≤ receive n h m x |
| receive_unit : ∀ n h m, receive n h m 1 = 1 |
| passive_update : ∀ n h m, |
| state (n+1) (localPassive h m) = (state n h).comp (receive n h m) |
| |
| namespace LocalObservableExecution |
| |
| variable {A κ send} (e : LocalObservableExecution (ι := ι) A κ send) |
| |
| def reference (n : ℕ) (h : LocalHistory O M n) : Matrix ι ι ℂ := e.state n h 1 |
| |
| omit inst5628_3 in |
| lemma reference_density [DecidableEq ι] (n : ℕ) (h : LocalHistory O M n) : |
| ZeroKey.Density (e.reference n h) := |
| ⟨e.positive_state n h 1 (e.positive_unit n), e.normalized n h⟩ |
| |
| omit inst5628_3 in |
| lemma reference_measurable [DecidableEq ι] (n : ℕ) : Measurable (e.reference n) := e.measurable_reference n |
| |
| lemma active_mean (n : ℕ) (h : LocalHistory O M n) (i j : ι) : |
| (∫ o, e.reference (n+1) (localActive h o (send n (h,o))) i j ∂κ n h) = |
| e.reference n h i j := by |
| calc |
| _ = ∫ o, (e.run n h).posterior o 1 i j ∂κ n h := by |
| apply integral_congr_ae |
| filter_upwards [e.active_update n h] with o ho |
| exact congrArg (fun S : ReferenceFunctional (A (n+1)) ι => S 1 i j) ho |
| _ = _ := by |
| rw [← e.run_law] |
| exact InstrumentRun.reference_mean (e.instrument n h) (e.state n h) (e.run n h) i j |
| |
| omit inst5628_3 in |
| lemma passive_reference [DecidableEq ι] (n : ℕ) (h : LocalHistory O M n) (m : M) : |
| e.reference (n+1) (localPassive h m) = e.reference n h := by |
| simp only [reference,e.passive_update,LinearMap.comp_apply,e.receive_unit] |
| |
| end LocalObservableExecution |
| |
| end UnrestrictedQuantum |
| |
| namespace ZeroKey |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory |
| |
| universe v5828_0 v5828_1 |
| |
| theorem condIndep_adaptive_public_message {Ω : Type v5828_0} {M : Type v5828_1} |
| {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [MeasurableSpace M] |
| {P : Measure Ω} [IsFiniteMeasure P] |
| {C A B : MeasurableSpace Ω} |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (h : CondIndep C A B hC P) |
| (q : Ω → Bool) (a b : Ω → M) (d : M) |
| (hq : @Measurable Ω Bool C _ q) |
| (ha : @Measurable Ω M (A ⊔ C) _ a) |
| (hb : @Measurable Ω M (B ⊔ C) _ b) : |
| let message := fun x => if q x then a x else b x |
| let N := C ⊔ MeasurableSpace.comap message inferInstance |
| CondIndep N A B (sup_le hC ((ha.mono (sup_le hA hC) le_rfl).ite |
| ((measurableSet_singleton true).preimage (hq.mono hC le_rfl)) |
| (hb.mono (sup_le hB hC) le_rfl)).comap_le) P := by |
| let left := fun x => if q x then a x else d |
| let right := fun x => if q x then d else b x |
| let NA := C ⊔ MeasurableSpace.comap left inferInstance |
| let NB := NA ⊔ MeasurableSpace.comap right inferInstance |
| let g := fun x => if q x then a x else b x |
| let N := C ⊔ MeasurableSpace.comap g inferInstance |
| have hqset : MeasurableSet[C] {x | q x = true} := hq (measurableSet_singleton true) |
| have hleft : @Measurable Ω M (A ⊔ C) _ left := |
| ha.ite ((show C ≤ A ⊔ C from le_sup_right) _ hqset) measurable_const |
| have hCA : C ≤ NA := le_sup_left |
| have hNAA : NA ≤ A ⊔ C := sup_le le_sup_right hleft.comap_le |
| have hNAM : NA ≤ mΩ := hNAA.trans (sup_le hA hC) |
| have h₁ : CondIndep NA A B hNAM P := condIndep_local_message hC hA hB hCA hNAA h |
| have hright : @Measurable Ω M (B ⊔ NA) _ right := |
| measurable_const.ite ((hCA.trans le_sup_right) _ hqset) |
| (hb.mono (sup_le_sup_left hCA B) le_rfl) |
| have hNBB : NB ≤ B ⊔ NA := sup_le le_sup_right hright.comap_le |
| have hNBM : NB ≤ mΩ := hNBB.trans (sup_le hB hNAM) |
| have h₂ : CondIndep NB A B hNBM P := |
| (condIndep_local_message hNAM hB hA le_sup_left hNBB h₁.symm).symm |
| have hCN : C ≤ N := le_sup_left |
| have hgN : @Measurable Ω M N _ g := Measurable.of_comap_le le_sup_right |
| have hlN : @Measurable Ω M N _ left := by |
| have hh : @Measurable Ω M N _ (fun x => if q x then g x else d) := |
| hgN.ite (hCN _ hqset) measurable_const |
| convert hh using 1 |
| ext x |
| cases hqx : q x <;> simp [left,g,hqx] |
| have hrN : @Measurable Ω M N _ right := by |
| have hh : @Measurable Ω M N _ (fun x => if q x then d else g x) := |
| measurable_const.ite (hCN _ hqset) hgN |
| convert hh using 1 |
| ext x |
| cases hqx : q x <;> simp [right,g,hqx] |
| have hNBN : NB ≤ N := sup_le (sup_le hCN hlN.comap_le) hrN.comap_le |
| have hCNB : C ≤ NB := le_sup_left.trans le_sup_left |
| have hlNB : @Measurable Ω M NB _ left := |
| Measurable.of_comap_le (le_sup_right.trans le_sup_left) |
| have hrNB : @Measurable Ω M NB _ right := Measurable.of_comap_le le_sup_right |
| have hgNB : @Measurable Ω M NB _ g := by |
| have hh : @Measurable Ω M NB _ (fun x => if q x then left x else right x) := |
| hlNB.ite (hCNB _ hqset) hrNB |
| convert hh using 1 |
| ext x |
| cases hqx : q x <;> simp [left,right,g,hqx] |
| have he : NB = N := le_antisymm hNBN (sup_le hCNB hgNB.comap_le) |
| simpa only [he] using h₂ |
| |
| open MeasureTheory ProbabilityTheory |
| |
| universe v5898_0 v5898_1 |
| |
| theorem adaptive_tapes_given_full_transcript {Ω : Type v5898_0} {M : Type v5898_1} |
| {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [MeasurableSpace M] |
| {P : Measure Ω} [IsFiniteMeasure P] |
| (F : Filtration ℕ mΩ) (A B : MeasurableSpace Ω) |
| (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (hinitial : CondIndep (F 0) A B (F.le 0) P) |
| (q : ℕ → Ω → Bool) (a b : ℕ → Ω → M) (d : M) |
| (hq : ∀ n, @Measurable Ω Bool (F n) _ (q n)) |
| (ha : ∀ n, @Measurable Ω M (A ⊔ F n) _ (a n)) |
| (hb : ∀ n, @Measurable Ω M (B ⊔ F n) _ (b n)) |
| (hF : ∀ n, F (n+1) = F n ⊔ MeasurableSpace.comap |
| (fun x => if q n x then a n x else b n x) inferInstance) : |
| CondIndep (⨆ n, F n) (A ⊔ ⨆ n, F n) (B ⊔ ⨆ n, F n) |
| (iSup_le F.le) P := by |
| have hfinite : ∀ n, CondIndep (F n) A B (F.le n) P := by |
| intro n |
| induction n with |
| | zero => exact hinitial |
| | succ n ih => |
| have h := condIndep_adaptive_public_message (F.le n) hA hB ih |
| (q n) (a n) (b n) d (hq n) (ha n) (hb n) |
| simpa only [hF n] using h |
| have h := condIndep_full_transcript F A B hA hB hfinite |
| have hC := iSup_le F.le |
| have h1 := (condIndep_join_public_right hC hB hA h.symm).symm |
| exact condIndep_join_public_right hC (sup_le hA hC) hB h1 |
| |
| universe v5935_0 v5935_1 v5935_2 |
| |
| structure AdaptiveTapeProgram (U : Type v5935_0) (V : Type v5935_1) (M : Type v5935_2) [MeasurableSpace U] |
| [MeasurableSpace V] [MeasurableSpace M] where |
| alice : (n : ℕ) → (Fin n → M) → Bool |
| measAlice : ∀ n, Measurable (alice n) |
| sendA : (n : ℕ) → U × (Fin n → M) → M |
| sendB : (n : ℕ) → V × (Fin n → M) → M |
| measA : ∀ n, Measurable (sendA n) |
| measB : ∀ n, Measurable (sendB n) |
| |
| namespace AdaptiveTapeProgram |
| |
| universe v5945_0 v5945_1 v5945_2 |
| |
| variable {U : Type v5945_0} {V : Type v5945_1} {M : Type v5945_2} [inst5945_0 : MeasurableSpace U] [inst5945_1 : MeasurableSpace V] [inst5945_2 : MeasurableSpace M] |
| (p : AdaptiveTapeProgram U V M) |
| |
| def publicPrefix : (n : ℕ) → U × V → (Fin n → M) |
| | 0, _ => Fin.elim0 |
| | n+1, ω => Fin.snoc (publicPrefix n ω) |
| (if p.alice n (publicPrefix n ω) then p.sendA n (ω.1,publicPrefix n ω) else p.sendB n (ω.2,publicPrefix n ω)) |
| |
| def message (n : ℕ) (ω : U × V) : M := |
| if p.alice n (p.publicPrefix n ω) then p.sendA n (ω.1,p.publicPrefix n ω) else p.sendB n (ω.2,p.publicPrefix n ω) |
| |
| lemma prefix_succ (n : ℕ) (ω : U × V) : |
| p.publicPrefix (n+1) ω = Fin.snoc (p.publicPrefix n ω) (p.message n ω) := rfl |
| |
| lemma measurable_prefix : ∀ n, Measurable (p.publicPrefix n) := by |
| intro n |
| induction n with |
| | zero => exact Measurable.of_eval (fun i => Fin.elim0 i) |
| | succ n ih => |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simp only [publicPrefix, Fin.snoc_last] |
| exact ((p.measA n).comp (measurable_fst.prodMk ih)).ite |
| ((measurableSet_singleton true).preimage ((p.measAlice n).comp ih)) |
| ((p.measB n).comp (measurable_snd.prodMk ih)) |
| · simpa only [publicPrefix, Fin.snoc_castSucc] using ih.eval (a := j) |
| |
| lemma measurable_message (n : ℕ) : Measurable (p.message n) := by |
| exact ((p.measA n).comp (measurable_fst.prodMk (p.measurable_prefix n))).ite |
| ((measurableSet_singleton true).preimage ((p.measAlice n).comp (p.measurable_prefix n))) |
| ((p.measB n).comp (measurable_snd.prodMk (p.measurable_prefix n))) |
| |
| abbrev field (n : ℕ) : MeasurableSpace (U × V) := |
| MeasurableSpace.comap (p.publicPrefix n) inferInstance |
| |
| lemma field_le (n : ℕ) : p.field n ≤ (inferInstance : MeasurableSpace (U × V)) := (p.measurable_prefix n).comap_le |
| |
| lemma field_mono : Monotone p.field := by |
| apply monotone_nat_of_le_succ |
| intro n |
| have h : @Measurable (U × V) (Fin n → M) (p.field (n+1)) _ (p.publicPrefix n) := by |
| let : MeasurableSpace (U × V) := p.field (n+1) |
| apply Measurable.of_eval |
| intro i |
| have hh := (@Measurable.of_comap_le (U × V) (Fin (n+1) → M) |
| (p.field (n+1)) _ (p.publicPrefix (n+1)) le_rfl).eval (a := i.castSucc) |
| simpa only [publicPrefix, Fin.snoc_castSucc] using hh |
| exact h.comap_le |
| |
| def filtration : Filtration ℕ (inferInstance : MeasurableSpace (U × V)) where |
| seq := p.field |
| mono' := p.field_mono |
| le' := p.field_le |
| |
| lemma field_zero : p.field 0 = ⊥ := by |
| exact MeasurableSpace.comap_const Fin.elim0 |
| |
| lemma field_succ (n : ℕ) : |
| p.field (n+1) = p.field n ⊔ MeasurableSpace.comap (p.message n) inferInstance := by |
| apply le_antisymm |
| · let : MeasurableSpace (U × V) := p.field n ⊔ MeasurableSpace.comap (p.message n) inferInstance |
| apply Measurable.comap_le |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa only [prefix_succ,Fin.snoc_last] using |
| (Measurable.of_comap_le (f := p.message n) le_sup_right) |
| · simpa only [prefix_succ,Fin.snoc_castSucc,field] using |
| (Measurable.of_comap_le (f := p.publicPrefix n) le_sup_left).eval (a := j) |
| · apply sup_le (p.field_mono (Nat.le_succ n)) |
| let : MeasurableSpace (U × V) := p.field (n+1) |
| have h := (@Measurable.of_comap_le (U × V) (Fin (n+1) → M) |
| (p.field (n+1)) _ (p.publicPrefix (n+1)) le_rfl).eval (a := Fin.last n) |
| have hh : Measurable[p.field (n+1)] (p.message n) := by |
| simpa only [prefix_succ,Fin.snoc_last] using h |
| exact hh.comap_le |
| |
| theorem tapes_conditionally_independent [StandardBorelSpace U] [StandardBorelSpace V] |
| [Nonempty M] |
| (μ : Measure U) (ν : Measure V) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] : |
| CondIndep (⨆ n, p.field n) |
| (MeasurableSpace.comap Prod.fst ‹MeasurableSpace U› ⊔ ⨆ n, p.field n) |
| (MeasurableSpace.comap Prod.snd ‹MeasurableSpace V› ⊔ ⨆ n, p.field n) |
| (iSup_le p.field_le) (μ.prod ν) := by |
| refine adaptive_tapes_given_full_transcript (P := μ.prod ν) p.filtration _ _ |
| measurable_fst.comap_le measurable_snd.comap_le ?_ |
| (fun n ω => p.alice n (p.publicPrefix n ω)) |
| (fun n ω => p.sendA n (ω.1,p.publicPrefix n ω)) |
| (fun n ω => p.sendB n (ω.2,p.publicPrefix n ω)) (Classical.arbitrary M) ?_ ?_ ?_ ?_ |
| · change CondIndep (p.field 0) _ _ _ _ |
| have h0 := indep_condIndep_bot measurable_fst.comap_le measurable_snd.comap_le |
| (P := μ.prod ν) (indepFun_prod (μ := μ) (ν := ν) measurable_id measurable_id) |
| simpa only [p.field_zero] using h0 |
| · intro n |
| exact (p.measAlice n).comp (Measurable.of_comap_le le_rfl) |
| · intro n |
| exact (p.measA n).comp ((Measurable.of_comap_le le_sup_left).prodMk |
| (Measurable.of_comap_le le_sup_right)) |
| · intro n |
| exact (p.measB n).comp ((Measurable.of_comap_le le_sup_left).prodMk |
| (Measurable.of_comap_le le_sup_right)) |
| · exact p.field_succ |
| |
| def record (ω : U × V) (n : ℕ) : M := p.message n ω |
| |
| lemma measurable_record : Measurable p.record := |
| Measurable.of_eval p.measurable_message |
| |
| lemma prefix_eq_record (n : ℕ) (ω : U × V) (i : Fin n) : |
| p.publicPrefix n ω i = p.record ω i := by |
| induction n with |
| | zero => exact Fin.elim0 i |
| | succ n ih => |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simp only [publicPrefix, Fin.snoc_last, record, message, Fin.val_last] |
| · simpa only [publicPrefix, Fin.snoc_castSucc, Fin.val_castSucc] using ih j |
| |
| lemma full_record_field : |
| MeasurableSpace.comap p.record inferInstance = ⨆ n, p.field n := by |
| apply le_antisymm |
| · let : MeasurableSpace (U × V) := ⨆ n, p.field n |
| apply Measurable.comap_le |
| apply Measurable.of_eval |
| intro n |
| have h : @Measurable (U × V) (Fin (n+1) → M) (⨆ n, p.field n) _ |
| (p.publicPrefix (n+1)) := Measurable.of_comap_le (le_iSup p.field (n+1)) |
| simpa only [publicPrefix, Fin.snoc_last, record, message] using h.eval (a := Fin.last n) |
| · apply iSup_le |
| intro n |
| let : MeasurableSpace (U × V) := MeasurableSpace.comap p.record inferInstance |
| apply Measurable.comap_le |
| apply Measurable.of_eval |
| intro i |
| simp_rw [prefix_eq_record] |
| exact (Measurable.of_comap_le (f := p.record) le_rfl).eval |
| |
| universe v6086_0 v6086_1 |
| |
| theorem final_records_conditionally_independent [Nonempty M] |
| [StandardBorelSpace U] [StandardBorelSpace V] |
| (μ : Measure U) (ν : Measure V) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] |
| {A : Type v6086_0} {B : Type v6086_1} [MeasurableSpace A] [MeasurableSpace B] |
| (readA : U × (ℕ → M) → A) (readB : V × (ℕ → M) → B) |
| (ha : Measurable readA) (hb : Measurable readB) : |
| CondIndepFun (MeasurableSpace.comap p.record inferInstance) |
| p.measurable_record.comap_le |
| (fun ω => readA (ω.1,p.record ω)) |
| (fun ω => readB (ω.2,p.record ω)) (μ.prod ν) := by |
| have h := p.tapes_conditionally_independent μ ν |
| rw [condIndepFun_iff_condIndep] |
| have hA : MeasurableSpace.comap (fun ω => readA (ω.1,p.record ω)) inferInstance ≤ |
| MeasurableSpace.comap Prod.fst ‹MeasurableSpace U› ⊔ ⨆ n, p.field n := by |
| apply Measurable.comap_le |
| exact ha.comp ((Measurable.of_comap_le le_sup_left).prodMk |
| (Measurable.of_comap_le (p.full_record_field ▸ le_sup_right))) |
| have hB : MeasurableSpace.comap (fun ω => readB (ω.2,p.record ω)) inferInstance ≤ |
| MeasurableSpace.comap Prod.snd ‹MeasurableSpace V› ⊔ ⨆ n, p.field n := by |
| apply Measurable.comap_le |
| exact hb.comp ((Measurable.of_comap_le le_sup_left).prodMk |
| (Measurable.of_comap_le (p.full_record_field ▸ le_sup_right))) |
| have h' := condIndep_of_condIndep_of_le_right |
| (condIndep_of_condIndep_of_le_left h hA) hB |
| simpa only [p.full_record_field] using h' |
| |
| end AdaptiveTapeProgram |
| |
| end |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory Set Function unitInterval |
| |
| section |
| |
| universe v6124_0 |
| |
| variable {N : Type v6124_0} [inst6124_0 : MeasurableSpace N] (ν : Measure N) [inst6124_1 : IsProbabilityMeasure ν] |
| |
| def noiseTapeLaw : Measure (ℕ → N) := Measure.infinitePi (fun _ => ν) |
| |
| instance noiseTapeLaw_probability : IsProbabilityMeasure (noiseTapeLaw ν) := by |
| unfold noiseTapeLaw |
| infer_instance |
| |
| lemma noise_prefix_fresh_independent (n : ℕ) : |
| IndepFun (fun u : (ℕ → N) => fun i : Fin n => u i) (fun u => u n) (noiseTapeLaw ν) := by |
| have h := iIndepFun_infinitePi (P := fun _ : ℕ => ν) |
| (X := fun _ x => x) (fun _ => measurable_id) |
| have hd : Disjoint (Finset.range n) {n} := by simp |
| have hh := h.indepFun_finset (Finset.range n) {n} hd (fun i => measurable_pi_apply i) |
| have hh' := hh.comp |
| (show Measurable (fun x : (i : Finset.range n) → N => fun j : Fin n => |
| x ⟨j,Finset.mem_range.mpr j.isLt⟩) from by fun_prop) |
| (show Measurable (fun x : (i : ({n} : Finset ℕ)) → N => x ⟨n,by simp⟩) from by fun_prop) |
| exact hh' |
| |
| lemma noise_tape_eval (n : ℕ) : (noiseTapeLaw ν).map (fun u => u n) = ν := |
| Measure.infinitePi_map_eval _ _ |
| |
| universe v6146_0 v6146_1 |
| |
| structure NoiseSampler (N : Type v6146_0) (O : Type v6146_1) [MeasurableSpace N] [MeasurableSpace O] where |
| step : (n : ℕ) → (Fin n → O) × N → O |
| measurable_step : ∀ n, Measurable (step n) |
| |
| namespace NoiseSampler |
| |
| variable {ν} |
| |
| universe v6152_0 |
| |
| variable {O : Type v6152_0} [inst6152_0 : MeasurableSpace O] (f : NoiseSampler N O) |
| |
| def finiteHistory : (n : ℕ) → (Fin n → N) → (Fin n → O) |
| | 0, _ => Fin.elim0 |
| | n+1, u => Fin.snoc (finiteHistory n (fun i => u i.castSucc)) |
| (f.step n (finiteHistory n (fun i => u i.castSucc), u (Fin.last n))) |
| |
| lemma measurable_finiteHistory : ∀ n, Measurable (f.finiteHistory n) := by |
| intro n |
| induction n with |
| | zero => exact Measurable.of_eval (fun i => Fin.elim0 i) |
| | succ n ih => |
| have hr : Measurable (fun u : Fin (n+1) → N => fun i : Fin n => u i.castSucc) := by fun_prop |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa only [finiteHistory, Fin.snoc_last,Function.comp_def] using |
| (f.measurable_step n).comp ((ih.comp hr).prodMk (measurable_pi_apply (Fin.last n))) |
| · simpa only [finiteHistory, Fin.snoc_castSucc,Function.comp_def] using (ih.comp hr).eval (a := j) |
| |
| def history (n : ℕ) (u : (ℕ → N)) : Fin n → O := |
| f.finiteHistory n (fun i => u i) |
| |
| lemma measurable_prefix (n : ℕ) : Measurable (f.history n) := |
| (f.measurable_finiteHistory n).comp (by fun_prop) |
| |
| lemma prefix_succ (n : ℕ) (u : (ℕ → N)) : |
| f.history (n+1) u = Fin.snoc (f.history n u) (f.step n (f.history n u,u n)) := rfl |
| |
| lemma prefix_fresh_independent (n : ℕ) : |
| IndepFun (f.history n) (fun u => u n) (noiseTapeLaw ν) := |
| (noise_prefix_fresh_independent ν n).comp (f.measurable_finiteHistory n) measurable_id |
| |
| lemma prefix_fresh_law (n : ℕ) : |
| (noiseTapeLaw ν).map (fun u => (f.history n u,u n)) = |
| ((noiseTapeLaw ν).map (f.history n)).prod ν := by |
| rw [(f.prefix_fresh_independent (ν := ν) n).map_prod_eq_prod_map_map |
| (f.measurable_prefix n).aemeasurable (measurable_pi_apply n).aemeasurable, |
| noise_tape_eval] |
| |
| theorem prefix_law_succ (κ : (n : ℕ) → Kernel (Fin n → O) O) |
| [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, ν.map (fun u => f.step n (s,u)) = κ n s) |
| (n : ℕ) : |
| (noiseTapeLaw ν).map (f.history (n+1)) = |
| (((noiseTapeLaw ν).map (f.history n)) ⊗ₘ κ n).map (fun p : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) p.1 p.2) := by |
| have hfresh := f.prefix_fresh_law (ν := ν) n |
| have hsample : (((noiseTapeLaw ν).map (f.history n)).prod ν).map |
| (fun p => (p.1, f.step n p)) = ((noiseTapeLaw ν).map (f.history n)) ⊗ₘ κ n := by |
| ext B hB |
| rw [Measure.map_apply (measurable_fst.prodMk (f.measurable_step n)) hB, |
| Measure.prod_apply (hB.preimage (measurable_fst.prodMk (f.measurable_step n))), |
| Measure.compProd_apply hB] |
| congr 1 |
| funext s |
| have hm : Measurable (fun u : N => f.step n (s,u)) := by |
| simpa only [Function.comp_def, id_eq] using |
| ((f.measurable_step n).comp ((measurable_const (a := s)).prodMk measurable_id)) |
| rw [← hlaw n s, Measure.map_apply hm (measurable_prodMk_left hB)] |
| rfl |
| have hs : Measurable (fun p : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) 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 |
| rw [← hsample, ← hfresh, |
| Measure.map_map (measurable_fst.prodMk (f.measurable_step n)) |
| ((f.measurable_prefix n).prodMk (measurable_pi_apply n)), |
| Measure.map_map hs ((measurable_fst.prodMk (f.measurable_step n)).comp |
| ((f.measurable_prefix n).prodMk (measurable_pi_apply n)))] |
| rfl |
| |
| def record (u : (ℕ → N)) (n : ℕ) : O := f.step n (f.history n u,u n) |
| |
| lemma measurable_record : Measurable f.record := |
| Measurable.of_eval (fun n => |
| (f.measurable_step n).comp ((f.measurable_prefix n).prodMk (measurable_pi_apply n))) |
| |
| lemma prefix_eq_record (n : ℕ) (u : (ℕ → N)) (i : Fin n) : |
| f.history n u i = f.record u i := by |
| induction n with |
| | zero => exact Fin.elim0 i |
| | succ n ih => |
| rw [f.prefix_succ] |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simp only [Fin.snoc_last,record, Fin.val_last] |
| · simpa only [Fin.snoc_castSucc, Fin.val_castSucc] using ih j |
| |
| theorem finite_law_unique (κ : (n : ℕ) → Kernel (Fin n → O) O) |
| [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, ν.map (fun u => f.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (fun x => fun i : Fin (n+1) => x i) = |
| ((P.map (fun x => fun i : Fin n => x i)) ⊗ₘ κ n).map |
| (fun p : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) p.1 p.2)) : |
| ∀ n, P.map (fun x => fun i : Fin n => x i) = (noiseTapeLaw ν).map (f.history n) := by |
| intro n |
| induction n with |
| | zero => |
| have ht : (fun x : ℕ → O => fun i : Fin 0 => x i) = fun _ => Fin.elim0 := by |
| funext x i |
| exact Fin.elim0 i |
| rw [ht] |
| change P.map (fun _ : ℕ → O => Fin.elim0) = |
| (noiseTapeLaw ν).map (fun _ : (ℕ → N) => Fin.elim0) |
| simp |
| | succ n ih => rw [hP n, ih, f.prefix_law_succ κ hlaw] |
| |
| theorem record_law_unique (κ : (n : ℕ) → Kernel (Fin n → O) O) |
| [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, ν.map (fun u => f.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (fun x => fun i : Fin (n+1) => x i) = |
| ((P.map (fun x => fun i : Fin n => x i)) ⊗ₘ κ n).map |
| (fun p : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) p.1 p.2)) : |
| P = (noiseTapeLaw ν).map f.record := by |
| let Q := (noiseTapeLaw ν).map f.record |
| have hQ : IsProbabilityMeasure Q := inferInstance |
| apply IsProjectiveLimit.unique (P := fun J : Finset ℕ => Q.map J.restrict) ?_ |
| (show IsProjectiveLimit Q (fun J : Finset ℕ => Q.map J.restrict) from fun _ => rfl) |
| intro J |
| let n := J.sup id + 1 |
| let index : J → Fin n := fun j => ⟨j.1,Nat.lt_succ_of_le (Finset.le_sup (f := id) j.2)⟩ |
| let cut : (Fin n → O) → (J → O) := fun x j => x (index j) |
| have hc : Measurable cut := by fun_prop |
| have h := congrArg (fun ν : Measure (Fin n → O) => ν.map cut) |
| (f.finite_law_unique κ hlaw P hP n) |
| rw [Measure.map_map hc (by fun_prop), Measure.map_map hc (f.measurable_prefix n)] at h |
| change P.map J.restrict = ((noiseTapeLaw ν).map f.record).map J.restrict |
| rw [Measure.map_map (Finset.measurable_restrict J) f.measurable_record] |
| have heL : cut ∘ (fun x : ℕ → O => fun i : Fin n => x i) = J.restrict := rfl |
| have heR : cut ∘ f.history n = J.restrict ∘ f.record := by |
| funext u j |
| exact f.prefix_eq_record n u (index j) |
| rwa [heL,heR] at h |
| |
| end NoiseSampler |
| |
| end |
| |
| universe v6315_0 v6315_1 |
| |
| structure AdaptiveOutcomeSampler (O : Type v6315_0) (M : Type v6315_1) [MeasurableSpace O] [MeasurableSpace M] where |
| alice : (n : ℕ) → (Fin n → M) → Bool |
| alice_meas : ∀ n, Measurable (alice n) |
| sampleA : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × I → O |
| sampleB : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × I → O |
| sendA : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × O → M |
| sendB : (n : ℕ) → ((Fin n → (O ⊕ Unit)) × (Fin n → M)) × O → M |
| sampleA_meas : ∀ n, Measurable (sampleA n) |
| sampleB_meas : ∀ n, Measurable (sampleB n) |
| sendA_meas : ∀ n, Measurable (sendA n) |
| sendB_meas : ∀ n, Measurable (sendB n) |
| |
| namespace AdaptiveOutcomeSampler |
| |
| section |
| |
| universe v6328_0 v6328_1 |
| |
| variable {O : Type v6328_0} {M : Type v6328_1} [inst6328_0 : MeasurableSpace O] [inst6328_1 : MeasurableSpace M] |
| (p : AdaptiveOutcomeSampler O M) |
| |
| def privatePrefix (a : Bool) : (n : ℕ) → UniformTape × (Fin n → M) → (Fin n → (O ⊕ Unit)) |
| | 0, _ => Fin.elim0 |
| | n+1, pair => |
| let old := privatePrefix a n (pair.1,fun i => pair.2 i.castSucc) |
| let pubPast := fun i : Fin n => pair.2 i.castSucc |
| Fin.snoc old (if p.alice n pubPast = a then Sum.inl |
| (if a then p.sampleA n ((old,pubPast),pair.1 n) |
| else p.sampleB n ((old,pubPast),pair.1 n)) else Sum.inr ()) |
| |
| lemma measurable_privatePrefix (a : Bool) : ∀ n, Measurable (p.privatePrefix a n) := by |
| intro n |
| induction n with |
| | zero => exact Measurable.of_eval (fun i => Fin.elim0 i) |
| | succ n ih => |
| have hr : Measurable (fun pair : UniformTape × (Fin (n+1) → M) => |
| (pair.1,fun i : Fin n => pair.2 i.castSucc)) := by fun_prop |
| have hv : Measurable (fun pair : UniformTape × (Fin (n+1) → M) => |
| fun i : Fin n => pair.2 i.castSucc) := by fun_prop |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simp only [privatePrefix,Fin.snoc_last] |
| apply Measurable.ite ((measurableSet_singleton a).preimage ((p.alice_meas n).comp hv)) _ measurable_const |
| apply measurable_inl.comp |
| cases a |
| · exact (p.sampleB_meas n).comp (((ih.comp hr).prodMk hv).prodMk |
| ((measurable_pi_apply n).comp measurable_fst)) |
| · exact (p.sampleA_meas n).comp (((ih.comp hr).prodMk hv).prodMk |
| ((measurable_pi_apply n).comp measurable_fst)) |
| · simpa only [privatePrefix,Fin.snoc_castSucc,Function.comp_def] using |
| (ih.comp hr).eval (a := j) |
| |
| def tapeProgram : AdaptiveTapeProgram UniformTape UniformTape M where |
| alice := p.alice |
| measAlice := p.alice_meas |
| sendA n pair := p.sendA n ((p.privatePrefix true n pair,pair.2), |
| p.sampleA n ((p.privatePrefix true n pair,pair.2),pair.1 n)) |
| sendB n pair := p.sendB n ((p.privatePrefix false n pair,pair.2), |
| p.sampleB n ((p.privatePrefix false n pair,pair.2),pair.1 n)) |
| measA n := (p.sendA_meas n).comp |
| (((p.measurable_privatePrefix true n).prodMk measurable_snd).prodMk |
| ((p.sampleA_meas n).comp (((p.measurable_privatePrefix true n).prodMk measurable_snd).prodMk |
| ((measurable_pi_apply n).comp measurable_fst)))) |
| measB n := (p.sendB_meas n).comp |
| (((p.measurable_privatePrefix false n).prodMk measurable_snd).prodMk |
| ((p.sampleB_meas n).comp (((p.measurable_privatePrefix false n).prodMk measurable_snd).prodMk |
| ((measurable_pi_apply n).comp measurable_fst)))) |
| |
| def replay : (n : ℕ) → (Fin n → O) → |
| ((Fin n → (O ⊕ Unit)) × (Fin n → (O ⊕ Unit))) × (Fin n → M) := |
| Nat.rec (fun _ => ((Fin.elim0,Fin.elim0),Fin.elim0)) (fun n previous x => |
| let r := previous (fun i => x i.castSucc) |
| let o := x (Fin.last n) |
| let q := p.alice n r.2 |
| ((Fin.snoc r.1.1 (if q then Sum.inl o else Sum.inr ()), |
| Fin.snoc r.1.2 (if q then Sum.inr () else Sum.inl o)), |
| Fin.snoc r.2 (if q then p.sendA n ((r.1.1,r.2),o) else p.sendB n ((r.1.2,r.2),o)))) |
| |
| universe v6393_0 v6393_1 |
| |
| lemma measurable_snoc {Z : Type v6393_0} {X : Type v6393_1} [MeasurableSpace Z] [MeasurableSpace X] |
| {n : ℕ} (f : Z → (Fin n → X)) (g : Z → X) |
| (hf : Measurable f) (hg : Measurable g) : |
| Measurable (fun x => Fin.snoc (α := fun _ : Fin (n+1) => X) (f x) (g x)) := by |
| apply Measurable.of_eval |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa only [Fin.snoc_last] using hg |
| · simpa only [Fin.snoc_castSucc] using hf.eval (a := j) |
| |
| lemma measurable_replay : ∀ n, Measurable (p.replay n) := by |
| intro n |
| induction n with |
| | zero => exact measurable_const |
| | succ n ih => |
| have hr : Measurable (fun x : Fin (n+1) → O => fun i : Fin n => x i.castSucc) := by fun_prop |
| have hR := ih.comp hr |
| have hq := (p.alice_meas n).comp hR.snd |
| have hqs := (measurableSet_singleton true).preimage hq |
| exact ((measurable_snoc _ _ hR.fst.fst ((measurable_inl.comp (measurable_pi_apply (Fin.last n))).ite hqs measurable_const)).prodMk |
| (measurable_snoc _ _ hR.fst.snd (measurable_const.ite hqs (measurable_inl.comp (measurable_pi_apply (Fin.last n)))))).prodMk |
| (measurable_snoc _ _ hR.snd (((p.sendA_meas n).comp ((hR.fst.fst.prodMk hR.snd).prodMk (measurable_pi_apply (Fin.last n)))).ite hqs |
| ((p.sendB_meas n).comp ((hR.fst.snd.prodMk hR.snd).prodMk (measurable_pi_apply (Fin.last n)))))) |
| |
| def extractPrivate (a : Bool) (n : ℕ) (x : Fin n → O) : Fin n → O ⊕ Unit := |
| if a then (p.replay n x).1.1 else (p.replay n x).1.2 |
| |
| def publicFrom (n : ℕ) (x : Fin n → O) : Fin n → M := (p.replay n x).2 |
| |
| lemma measurable_extractPrivate (a : Bool) (n : ℕ) : Measurable (p.extractPrivate a n) := by |
| cases a |
| · exact (p.measurable_replay n).fst.snd |
| · exact (p.measurable_replay n).fst.fst |
| |
| lemma measurable_publicFrom (n : ℕ) : Measurable (p.publicFrom n) := (p.measurable_replay n).snd |
| |
| lemma extractPrivate_snoc (a : Bool) (n : ℕ) (x : Fin n → O) (z : O) : |
| p.extractPrivate a (n+1) (Fin.snoc (α := fun _ => O) x z) = |
| Fin.snoc (p.extractPrivate a n x) (if p.alice n (p.publicFrom n x) = a then Sum.inl z else Sum.inr ()) := by |
| cases a <;> cases hq : p.alice n (p.publicFrom n x) <;> |
| simp only [extractPrivate,replay,Fin.snoc_castSucc,Fin.snoc_last,publicFrom] at hq ⊢ <;> simp [hq] |
| |
| lemma publicFrom_snoc (n : ℕ) (x : Fin n → O) (z : O) : |
| p.publicFrom (n+1) (Fin.snoc (α := fun _ => O) x z) = |
| Fin.snoc (p.publicFrom n x) (if p.alice n (p.publicFrom n x) then |
| p.sendA n ((p.extractPrivate true n x,p.publicFrom n x),z) else |
| p.sendB n ((p.extractPrivate false n x,p.publicFrom n x),z)) := by |
| simp only [publicFrom,replay,extractPrivate,Fin.snoc_castSucc,Fin.snoc_last,Bool.false_eq_true,↓reduceIte] |
| |
| lemma privatePrefix_snoc (a : Bool) (n : ℕ) (u : UniformTape) (h : Fin n → M) (z : M) : |
| p.privatePrefix a (n+1) (u,Fin.snoc (α := fun _ => M) h z) = |
| Fin.snoc (p.privatePrefix a n (u,h)) (if p.alice n h = a then Sum.inl |
| (if a then p.sampleA n ((p.privatePrefix a n (u,h),h),u n) |
| else p.sampleB n ((p.privatePrefix a n (u,h),h),u n)) else Sum.inr ()) := by |
| simp only [privatePrefix,Fin.snoc_castSucc] |
| |
| /-- The sampled outcome history, without a bundled measurability certificate. -/ |
| def causalStep (n : ℕ) (pair : (Fin n → O) × (I × I)) : O := |
| if p.alice n (p.publicFrom n pair.1) then |
| p.sampleA n ((p.extractPrivate true n pair.1, p.publicFrom n pair.1), pair.2.1) |
| else p.sampleB n ((p.extractPrivate false n pair.1, p.publicFrom n pair.1), pair.2.2) |
| |
| def causalHistory : (n : ℕ) → (Fin n → I × I) → (Fin n → O) |
| | 0, _ => Fin.elim0 |
| | n+1, u => Fin.snoc (causalHistory n (fun i => u i.castSucc)) |
| (p.causalStep n (causalHistory n (fun i => u i.castSucc), u (Fin.last n))) |
| |
| def causalRecord (u : ℕ → I × I) (n : ℕ) : O := |
| p.causalStep n (p.causalHistory n (fun i => u i), u n) |
| |
| def causal : NoiseSampler (I × I) O where |
| step n pair := if p.alice n (p.publicFrom n pair.1) then |
| p.sampleA n ((p.extractPrivate true n pair.1,p.publicFrom n pair.1),pair.2.1) else |
| p.sampleB n ((p.extractPrivate false n pair.1,p.publicFrom n pair.1),pair.2.2) |
| measurable_step n := |
| ((p.sampleA_meas n).comp ((((p.measurable_extractPrivate true n).comp measurable_fst).prodMk |
| ((p.measurable_publicFrom n).comp measurable_fst)).prodMk measurable_snd.fst)).ite |
| ((measurableSet_singleton true).preimage ((p.alice_meas n).comp ((p.measurable_publicFrom n).comp measurable_fst))) |
| ((p.sampleB_meas n).comp ((((p.measurable_extractPrivate false n).comp measurable_fst).prodMk |
| ((p.measurable_publicFrom n).comp measurable_fst)).prodMk measurable_snd.snd)) |
| |
| lemma causalRecord_eq : p.causalRecord = p.causal.record := by |
| have h (n : ℕ) : p.causalHistory n = p.causal.finiteHistory n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| funext u |
| simp only [causalHistory, NoiseSampler.finiteHistory, ih] |
| rfl |
| funext u n |
| change p.causalStep n (p.causalHistory n (fun i => u i), u n) = |
| p.causal.step n (p.causal.finiteHistory n (fun i => u i), u n) |
| rw [h n] |
| rfl |
| |
| def pairedTape (uv : UniformTape × UniformTape) (n : ℕ) : I × I := (uv.1 n,uv.2 n) |
| |
| lemma measurable_pairedTape : Measurable pairedTape := by unfold pairedTape; fun_prop |
| |
| theorem replay_matches (n : ℕ) (uv : UniformTape × UniformTape) : |
| p.publicFrom n (p.causal.history n (pairedTape uv)) = p.tapeProgram.publicPrefix n uv ∧ |
| (∀ a, p.extractPrivate a n (p.causal.history n (pairedTape uv)) = |
| p.privatePrefix a n ((if a then uv.1 else uv.2),p.tapeProgram.publicPrefix n uv)) := by |
| induction n with |
| | zero => exact ⟨rfl,fun a => by cases a <;> rfl⟩ |
| | succ n ih => |
| have hs : p.causal.step n (p.causal.history n (pairedTape uv),pairedTape uv n) = |
| if p.alice n (p.tapeProgram.publicPrefix n uv) then |
| p.sampleA n ((p.privatePrefix true n (uv.1,p.tapeProgram.publicPrefix n uv), |
| p.tapeProgram.publicPrefix n uv),uv.1 n) else |
| p.sampleB n ((p.privatePrefix false n (uv.2,p.tapeProgram.publicPrefix n uv), |
| p.tapeProgram.publicPrefix n uv),uv.2 n) := by |
| change (if p.alice n (p.publicFrom n (p.causal.history n (pairedTape uv))) then |
| p.sampleA n ((p.extractPrivate true n (p.causal.history n (pairedTape uv)), |
| p.publicFrom n (p.causal.history n (pairedTape uv))),uv.1 n) |
| else p.sampleB n ((p.extractPrivate false n (p.causal.history n (pairedTape uv)), |
| p.publicFrom n (p.causal.history n (pairedTape uv))),uv.2 n)) = _ |
| rw [ih.1,ih.2 true,ih.2 false] |
| simp only [Bool.false_eq_true,↓reduceIte] |
| rw [p.causal.prefix_succ,p.publicFrom_snoc,hs,ih.1,ih.2 true,ih.2 false] |
| simp only [Bool.false_eq_true,↓reduceIte] |
| constructor |
| · rw [p.tapeProgram.prefix_succ] |
| congr 1 |
| unfold AdaptiveTapeProgram.message tapeProgram |
| split <;> simp_all only [] |
| · intro a |
| rw [p.extractPrivate_snoc,ih.2 a,ih.1,p.tapeProgram.prefix_succ,p.privatePrefix_snoc] |
| congr 1 |
| cases a <;> cases hrole : p.alice n (p.tapeProgram.publicPrefix n uv) <;> |
| simp only [Bool.false_eq_true,Bool.true_eq_false,↓reduceIte] |
| |
| end |
| |
| universe v6532_0 v6532_1 |
| |
| variable {O : Type v6532_0} {M : Type v6532_1} [inst6532_0 : MeasurableSpace O] [inst6532_1 : MeasurableSpace M] |
| (p : AdaptiveOutcomeSampler O M) |
| |
| def instrumentKernel |
| (κA κB : (n : ℕ) → Kernel ((Fin n → (O ⊕ Unit)) × (Fin n → M)) O) |
| (n : ℕ) : Kernel (Fin n → O) O := by |
| classical |
| exact Kernel.piecewise |
| ((measurableSet_singleton true).preimage ((p.alice_meas n).comp (p.measurable_publicFrom n))) |
| ((κA n).comap (fun x => (p.extractPrivate true n x,p.publicFrom n x)) |
| ((p.measurable_extractPrivate true n).prodMk (p.measurable_publicFrom n))) |
| ((κB n).comap (fun x => (p.extractPrivate false n x,p.publicFrom n x)) |
| ((p.measurable_extractPrivate false n).prodMk (p.measurable_publicFrom n))) |
| |
| lemma instrumentKernel_apply |
| (κA κB : (n : ℕ) → Kernel ((Fin n → (O ⊕ Unit)) × (Fin n → M)) O) |
| (n : ℕ) (s : Fin n → O) : |
| p.instrumentKernel κA κB n s = if p.alice n (p.publicFrom n s) then |
| κA n (p.extractPrivate true n s,p.publicFrom n s) else |
| κB n (p.extractPrivate false n s,p.publicFrom n s) := by |
| classical |
| simp only [instrumentKernel,Kernel.piecewise_apply,Set.mem_preimage,Set.mem_singleton_iff, |
| Function.comp_def,Kernel.comap_apply] |
| |
| instance instrumentKernel_markov |
| (κA κB : (n : ℕ) → Kernel ((Fin n → (O ⊕ Unit)) × (Fin n → M)) O) |
| [∀ n, IsMarkovKernel (κA n)] [∀ n, IsMarkovKernel (κB n)] (n : ℕ) : |
| IsMarkovKernel (p.instrumentKernel κA κB n) := by |
| unfold instrumentKernel |
| infer_instance |
| |
| lemma causal_step_law |
| (κA κB : (n : ℕ) → Kernel ((Fin n → (O ⊕ Unit)) × (Fin n → M)) O) |
| (ha : ∀ n s, volume.map (fun u => p.sampleA n (s,u)) = κA n s) |
| (hb : ∀ n s, volume.map (fun u => p.sampleB n (s,u)) = κB n s) : |
| ∀ n s, (volume.prod volume).map (fun u => p.causal.step n (s,u)) = |
| p.instrumentKernel κA κB n s := by |
| intro n s |
| rw [p.instrumentKernel_apply κA κB n s] |
| change (volume.prod volume).map (fun u => if p.alice n (p.publicFrom n s) then |
| p.sampleA n ((p.extractPrivate true n s,p.publicFrom n s),u.1) else |
| p.sampleB n ((p.extractPrivate false n s,p.publicFrom n s),u.2)) = _ |
| split |
| · have hm : Measurable (fun u : I => p.sampleA n ((p.extractPrivate true n s,p.publicFrom n s),u)) := |
| (p.sampleA_meas n).comp (measurable_const.prodMk measurable_id) |
| have hh := Measure.map_map (μ := (volume : Measure I).prod volume) hm |
| (measurable_fst : Measurable (Prod.fst : I × I → I)) |
| simp only [Measure.map_fst_prod, measure_univ, one_smul] at hh |
| exact hh.symm.trans (ha n _) |
| · have hm : Measurable (fun u : I => p.sampleB n ((p.extractPrivate false n s,p.publicFrom n s),u)) := |
| (p.sampleB_meas n).comp (measurable_const.prodMk measurable_id) |
| have hh := Measure.map_map (μ := (volume : Measure I).prod volume) hm |
| (measurable_snd : Measurable (Prod.snd : I × I → I)) |
| simp only [Measure.map_snd_prod, measure_univ, one_smul] at hh |
| exact hh.symm.trans (hb n _) |
| |
| end AdaptiveOutcomeSampler |
| |
| end |
| |
| namespace AdaptiveQuantum |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| open UnrestrictedQuantum |
| |
| universe v6604_0 v6604_1 v6604_2 v6604_3 v6604_4 v6604_5 |
| |
| variable {O : Type v6604_0} {M : Type v6604_1} {ι : Type v6604_2} {η : Type v6604_3} [inst6604_0 : MeasurableSpace O] [inst6604_1 : MeasurableSpace M] |
| [inst6604_2 : Fintype ι] [inst6604_3 : Fintype η] [inst6604_4 : DecidableEq ι] [inst6604_5 : DecidableEq η] |
| {A : ℕ → Type v6604_4} {B : ℕ → Type v6604_5} |
| [inst6604_6 : ∀ n, AddCommGroup (A n)] [inst6604_7 : ∀ n, Module ℂ (A n)] [inst6604_8 : ∀ n, One (A n)] [inst6604_9 : ∀ n, LE (A n)] |
| [inst6604_10 : ∀ n, AddCommGroup (B n)] [inst6604_11 : ∀ n, Module ℂ (B n)] [inst6604_12 : ∀ n, One (B n)] [inst6604_13 : ∀ n, LE (B n)] |
| (p : AdaptiveOutcomeSampler O M) |
| (κA κB : (n : ℕ) → Kernel (LocalHistory O M n) O) |
| [inst6604_14 : ∀ n, IsMarkovKernel (κA n)] [inst6604_15 : ∀ n, IsMarkovKernel (κB n)] |
| (eA : LocalObservableExecution (ι := ι) A κA p.sendA) |
| (eB : LocalObservableExecution (ι := η) B κB p.sendB) |
| |
| def globalLocalReferenceA (n : ℕ) (s : Fin n → O) : Matrix ι ι ℂ := |
| eA.reference n (p.extractPrivate true n s,p.publicFrom n s) |
| |
| def globalLocalReferenceB (n : ℕ) (s : Fin n → O) : Matrix η η ℂ := |
| eB.reference n (p.extractPrivate false n s,p.publicFrom n s) |
| |
| omit inst6604_14 in |
| lemma globalLocalReferenceA_measurable [∀ n, IsMarkovKernel (κA n)] (n : ℕ) : |
| Measurable (globalLocalReferenceA p κA eA n) := |
| (eA.reference_measurable n).comp |
| ((p.measurable_extractPrivate true n).prodMk (p.measurable_publicFrom n)) |
| |
| omit inst6604_15 in |
| lemma globalLocalReferenceB_measurable [∀ n, IsMarkovKernel (κB n)] (n : ℕ) : |
| Measurable (globalLocalReferenceB p κB eB n) := |
| (eB.reference_measurable n).comp |
| ((p.measurable_extractPrivate false n).prodMk (p.measurable_publicFrom n)) |
| |
| omit inst6604_14 in |
| lemma globalLocalReferenceA_mean [∀ n, IsMarkovKernel (κA n)] (n : ℕ) (s : Fin n → O) (i j : ι) : |
| (∫ o, globalLocalReferenceA p κA eA (n+1) (Fin.snoc s o) i j |
| ∂p.instrumentKernel κA κB n s) = globalLocalReferenceA p κA eA n s i j := by |
| unfold globalLocalReferenceA |
| simp_rw [p.extractPrivate_snoc, p.publicFrom_snoc] |
| rw [p.instrumentKernel_apply] |
| cases hrole : p.alice n (p.publicFrom n s) with |
| | true => |
| simp only [↓reduceIte] |
| exact eA.active_mean n _ i j |
| | false => |
| simp only [Bool.false_eq_true,↓reduceIte] |
| change (∫ o, eA.reference (n+1) (localPassive |
| (p.extractPrivate true n s,p.publicFrom n s) |
| (p.sendB n ((p.extractPrivate false n s,p.publicFrom n s),o))) i j |
| ∂κB n (p.extractPrivate false n s,p.publicFrom n s)) = _ |
| simp only [eA.passive_reference] |
| simp |
| |
| omit inst6604_15 in |
| lemma globalLocalReferenceB_mean [∀ n, IsMarkovKernel (κB n)] (n : ℕ) (s : Fin n → O) (i j : η) : |
| (∫ o, globalLocalReferenceB p κB eB (n+1) (Fin.snoc s o) i j |
| ∂p.instrumentKernel κA κB n s) = globalLocalReferenceB p κB eB n s i j := by |
| unfold globalLocalReferenceB |
| simp_rw [p.extractPrivate_snoc, p.publicFrom_snoc] |
| rw [p.instrumentKernel_apply] |
| cases hrole : p.alice n (p.publicFrom n s) with |
| | false => |
| simp only [↓reduceIte] |
| exact eB.active_mean n _ i j |
| | true => |
| simp only [Bool.true_eq_false,↓reduceIte] |
| change (∫ o, eB.reference (n+1) (localPassive |
| (p.extractPrivate false n s,p.publicFrom n s) |
| (p.sendA n ((p.extractPrivate true n s,p.publicFrom n s),o))) i j |
| ∂κA n (p.extractPrivate true n s,p.publicFrom n s)) = _ |
| simp only [eB.passive_reference] |
| simp |
| |
| def jointReference (n : ℕ) (s : Fin n → O) : Matrix (ι × η) (ι × η) ℂ := |
| globalLocalReferenceA p κA eA n s ⊗ₖ globalLocalReferenceB p κB eB n s |
| |
| omit inst6604_14 inst6604_15 in |
| lemma jointReference_density [∀ n, IsMarkovKernel (κA n)] [∀ n, IsMarkovKernel (κB n)] (n : ℕ) (s : Fin n → O) : |
| Density (jointReference p κA κB eA eB n s) := by |
| refine ⟨(eA.reference_density n _).1.kronecker (eB.reference_density n _).1,?_⟩ |
| simp only [jointReference, Matrix.trace_kronecker,globalLocalReferenceA, |
| globalLocalReferenceB,(eA.reference_density n _).2,(eB.reference_density n _).2,one_mul] |
| |
| lemma jointReference_measurable (n : ℕ) : |
| Measurable (jointReference p κA κB eA eB n) := by |
| have hm : Measurable (fun s i j => jointReference p κA κB eA eB n s i j) := by |
| apply Measurable.of_eval; intro i |
| apply Measurable.of_eval; intro j |
| exact (((Matrix.entryLinearMap ℂ ℂ i.1 j.1).toContinuousLinearMap).measurable.comp |
| (globalLocalReferenceA_measurable p κA eA n)).mul |
| (((Matrix.entryLinearMap ℂ ℂ i.2 j.2).toContinuousLinearMap).measurable.comp |
| (globalLocalReferenceB_measurable p κB eB n)) |
| have hM : Continuous (Matrix.of : ((ι × η) → (ι × η) → ℂ) → Matrix (ι × η) (ι × η) ℂ) := |
| continuous_matrix (fun i j => continuous_apply_apply i j) |
| exact hM.measurable.comp hm |
| |
| omit inst6604_14 inst6604_15 in |
| lemma jointReference_mean [∀ n, IsMarkovKernel (κA n)] [∀ n, IsMarkovKernel (κB n)] (n : ℕ) (s : Fin n → O) (i j : ι × η) : |
| (∫ o, jointReference p κA κB eA eB (n+1) (Fin.snoc s o) i j |
| ∂p.instrumentKernel κA κB n s) = jointReference p κA κB eA eB n s i j := by |
| change (∫ o, globalLocalReferenceA p κA eA (n+1) (Fin.snoc s o) i.1 j.1 * |
| globalLocalReferenceB p κB eB (n+1) (Fin.snoc s o) i.2 j.2 |
| ∂p.instrumentKernel κA κB n s) = |
| globalLocalReferenceA p κA eA n s i.1 j.1 * globalLocalReferenceB p κB eB n s i.2 j.2 |
| simp only [globalLocalReferenceA,globalLocalReferenceB] |
| simp_rw [p.extractPrivate_snoc,p.publicFrom_snoc] |
| rw [p.instrumentKernel_apply] |
| cases hrole : p.alice n (p.publicFrom n s) with |
| | true => |
| simp only [Bool.true_eq_false,↓reduceIte] |
| change (∫ o, eA.reference (n+1) (localActive |
| (p.extractPrivate true n s,p.publicFrom n s) o |
| (p.sendA n ((p.extractPrivate true n s,p.publicFrom n s),o))) i.1 j.1 * |
| eB.reference (n+1) (localPassive (p.extractPrivate false n s,p.publicFrom n s) |
| (p.sendA n ((p.extractPrivate true n s,p.publicFrom n s),o))) i.2 j.2 |
| ∂κA n (p.extractPrivate true n s,p.publicFrom n s)) = _ |
| simp_rw [eB.passive_reference] |
| rw [integral_mul_const,eA.active_mean] |
| | false => |
| simp only [Bool.false_eq_true,↓reduceIte] |
| change (∫ o, eA.reference (n+1) (localPassive |
| (p.extractPrivate true n s,p.publicFrom n s) |
| (p.sendB n ((p.extractPrivate false n s,p.publicFrom n s),o))) i.1 j.1 * |
| eB.reference (n+1) (localActive (p.extractPrivate false n s,p.publicFrom n s) o |
| (p.sendB n ((p.extractPrivate false n s,p.publicFrom n s),o))) i.2 j.2 |
| ∂κB n (p.extractPrivate false n s,p.publicFrom n s)) = _ |
| simp_rw [eA.passive_reference] |
| rw [integral_const_mul,eB.active_mean] |
| |
| end AdaptiveQuantum |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory Set Function unitInterval |
| |
| theorem paired_tapes_law : |
| (uniformTapeLaw.prod uniformTapeLaw).map |
| (fun uv : UniformTape × UniformTape => fun n => (uv.1 n,uv.2 n)) = |
| noiseTapeLaw ((volume : Measure I).prod volume) := by |
| let ν : Measure ((Fin 2 × ℕ) → I) := Measure.infinitePi (fun _ => (volume : Measure I)) |
| let split : ((Fin 2 × ℕ) → I) → UniformTape × UniformTape := |
| fun u => (fun n => u (0,n),fun n => u (1,n)) |
| have hs : Measurable split := by fun_prop |
| have hsplit : ν.map split = uniformTapeLaw.prod uniformTapeLaw := by |
| have hc := Measure.infinitePi_map_curry (fun (_ : Fin 2) (_ : ℕ) => (volume : Measure I)) |
| change ν.map (MeasurableEquiv.curry (Fin 2) ℕ I) = |
| Measure.infinitePi (fun _ : Fin 2 => uniformTapeLaw) at hc |
| rw [Measure.infinitePi_eq_pi (fun _ : Fin 2 => uniformTapeLaw)] at hc |
| have h := congrArg (fun P : Measure (Fin 2 → UniformTape) => P.map MeasurableEquiv.finTwoArrow) hc |
| rw [Measure.map_map (MeasurableEquiv.measurable _) (MeasurableEquiv.measurable _), |
| (measurePreserving_finTwoArrow uniformTapeLaw).map_eq] at h |
| exact h |
| have hswap := Measure.map_infinitePi_infinitePi_of_inj |
| (P := fun _ : Fin 2 × ℕ => (volume : Measure I)) |
| (f := fun p : ℕ × Fin 2 => (p.2,p.1)) (by intro a b h; cases a; cases b; simpa only [Prod.mk.injEq,and_comm] using h) |
| have hc := Measure.infinitePi_map_curry (fun (_ : ℕ) (_ : Fin 2) => (volume : Measure I)) |
| have hp := Measure.infinitePi_map_pi (fun _ : ℕ => Measure.infinitePi (fun _ : Fin 2 => (volume : Measure I))) |
| (f := fun _ => MeasurableEquiv.finTwoArrow) (fun _ => MeasurableEquiv.measurable _) |
| simp only [Measure.infinitePi_eq_pi, (measurePreserving_finTwoArrow (volume : Measure I)).map_eq] at hp |
| rw [← hsplit, Measure.map_map (by fun_prop) hs] |
| unfold noiseTapeLaw |
| rw [Measure.infinitePi_eq_pi (fun _ : Fin 2 => (volume : Measure I))] at hc |
| rw [← hp, ← hc, ← hswap] |
| rw [Measure.map_map (by fun_prop) (by fun_prop),Measure.map_map (by fun_prop) (by fun_prop)] |
| rfl |
| |
| end |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory |
| |
| universe v6786_0 v6786_1 v6786_2 v6786_3 v6786_4 |
| |
| theorem condIndepFun_of_joint_law {Ω : Type v6786_0} {Ω' : Type v6786_1} {T : Type v6786_2} {A : Type v6786_3} {B : Type v6786_4} |
| [MeasurableSpace Ω] [StandardBorelSpace Ω] |
| [MeasurableSpace Ω'] [StandardBorelSpace Ω'] |
| [MeasurableSpace T] [MeasurableSpace A] [StandardBorelSpace A] [Nonempty A] |
| [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B] |
| {P : Measure Ω} {Q : Measure Ω'} [IsFiniteMeasure P] [IsFiniteMeasure Q] |
| {t : Ω → T} {a : Ω → A} {b : Ω → B} |
| {t' : Ω' → T} {a' : Ω' → A} {b' : Ω' → B} |
| (ht : Measurable t) (ha : Measurable a) (hb : Measurable b) |
| (ht' : Measurable t') (ha' : Measurable a') (hb' : Measurable b') |
| (hlaw : P.map (fun x => (t x,a x,b x)) = Q.map (fun x => (t' x,a' x,b' x))) |
| (hind : CondIndepFun (MeasurableSpace.comap t' inferInstance) ht'.comap_le a' b' Q) : |
| CondIndepFun (MeasurableSpace.comap t inferInstance) ht.comap_le a b P := by |
| have hm : Measurable (fun x => (t x,a x,b x)) := ht.prodMk (ha.prodMk hb) |
| have hm' : Measurable (fun x => (t' x,a' x,b' x)) := ht'.prodMk (ha'.prodMk hb') |
| have hT : P.map t = Q.map t' := by |
| have h := congrArg (fun ν : Measure (T × A × B) => ν.map Prod.fst) hlaw |
| simpa only [Measure.map_map measurable_fst hm, |
| Measure.map_map measurable_fst hm', Function.comp_def] using h |
| have hA : P.map (fun x => (t x,a x)) = Q.map (fun x => (t' x,a' x)) := by |
| have hp : Measurable (fun x : T × A × B => (x.1,x.2.1)) := by fun_prop |
| have h := congrArg (fun ν : Measure (T × A × B) => ν.map (fun x => (x.1,x.2.1))) hlaw |
| simpa only [Measure.map_map hp hm, Measure.map_map hp hm', Function.comp_def] using h |
| have hB : P.map (fun x => (t x,b x)) = Q.map (fun x => (t' x,b' x)) := by |
| have hp : Measurable (fun x : T × A × B => (x.1,x.2.2)) := by fun_prop |
| have h := congrArg (fun ν : Measure (T × A × B) => ν.map (fun x => (x.1,x.2.2))) hlaw |
| simpa only [Measure.map_map hp hm, Measure.map_map hp hm', Function.comp_def] using h |
| rw [condIndepFun_iff_map_prod_eq_prod_condDistrib_prod_condDistrib ha hb ht] |
| rw [condIndepFun_iff_map_prod_eq_prod_condDistrib_prod_condDistrib ha' hb' ht'] at hind |
| have hca : condDistrib a t P = condDistrib a' t' Q := by |
| rw [condDistrib, condDistrib] |
| congr 1 |
| have hcb : condDistrib b t P = condDistrib b' t' Q := by |
| rw [condDistrib, condDistrib] |
| congr 1 |
| rw [hlaw,hca,hcb,hT] |
| exact hind |
| |
| end |
| |
| namespace AdaptiveOutcomeSampler |
| |
| open MeasureTheory ProbabilityTheory Set Function unitInterval |
| |
| universe v6835_0 v6835_1 |
| |
| variable {O : Type v6835_0} {M : Type v6835_1} [inst6835_0 : MeasurableSpace O] [inst6835_1 : MeasurableSpace M] |
| (p : AdaptiveOutcomeSampler O M) |
| |
| def privateRecord (a : Bool) (pair : UniformTape × (ℕ → M)) (n : ℕ) : O ⊕ Unit := |
| p.privatePrefix a (n+1) (pair.1,fun i => pair.2 i) (Fin.last n) |
| |
| lemma measurable_privateRecord (a : Bool) : Measurable (p.privateRecord a) := by |
| apply Measurable.of_eval |
| intro n |
| exact ((p.measurable_privatePrefix a (n+1)).comp (by fun_prop)).eval (a := Fin.last n) |
| |
| universe v6846_0 v6846_1 |
| |
| theorem final_records_independent [Nonempty M] {A : Type v6846_0} {B : Type v6846_1} [MeasurableSpace A] [MeasurableSpace B] |
| (readA : (ℕ → (O ⊕ Unit)) × (ℕ → M) → A) |
| (readB : (ℕ → (O ⊕ Unit)) × (ℕ → M) → B) |
| (ha : Measurable readA) (hb : Measurable readB) : |
| CondIndepFun (MeasurableSpace.comap p.tapeProgram.record inferInstance) |
| p.tapeProgram.measurable_record.comap_le |
| (fun uv => readA (p.privateRecord true (uv.1,p.tapeProgram.record uv),p.tapeProgram.record uv)) |
| (fun uv => readB (p.privateRecord false (uv.2,p.tapeProgram.record uv),p.tapeProgram.record uv)) |
| (uniformTapeLaw.prod uniformTapeLaw) := by |
| exact p.tapeProgram.final_records_conditionally_independent uniformTapeLaw uniformTapeLaw |
| (fun pair => readA (p.privateRecord true pair,pair.2)) |
| (fun pair => readB (p.privateRecord false pair,pair.2)) |
| (ha.comp ((p.measurable_privateRecord true).prodMk measurable_snd)) |
| (hb.comp ((p.measurable_privateRecord false).prodMk measurable_snd)) |
| |
| def outcomeRecord (uv : UniformTape × UniformTape) : ℕ → O := |
| p.causal.record (pairedTape uv) |
| |
| lemma measurable_outcomeRecord : Measurable p.outcomeRecord := |
| p.causal.measurable_record.comp measurable_pairedTape |
| |
| lemma outcomeRecord_law (κ : (n : ℕ) → Kernel (Fin n → O) O) |
| [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, (volume.prod volume).map (fun u => p.causal.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (fun x => fun i : Fin (n+1) => x i) = |
| ((P.map (fun x => fun i : Fin n => x i)) ⊗ₘ κ n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) : |
| (uniformTapeLaw.prod uniformTapeLaw).map p.outcomeRecord = P := by |
| rw [p.causal.record_law_unique κ hlaw P hP] |
| change (uniformTapeLaw.prod uniformTapeLaw).map (p.causal.record ∘ pairedTape) = _ |
| rw [← Measure.map_map p.causal.measurable_record measurable_pairedTape] |
| congr 1 |
| exact paired_tapes_law |
| |
| def publicRecord (x : ℕ → O) (n : ℕ) : M := |
| p.publicFrom (n+1) (fun i => x i) (Fin.last n) |
| |
| def localRecord (a : Bool) (x : ℕ → O) (n : ℕ) : O ⊕ Unit := |
| p.extractPrivate a (n+1) (fun i => x i) (Fin.last n) |
| |
| lemma measurable_publicRecord : Measurable p.publicRecord := by |
| apply Measurable.of_eval |
| intro n |
| exact ((p.measurable_publicFrom (n+1)).comp (by fun_prop)).eval (a := Fin.last n) |
| |
| lemma measurable_localRecord (a : Bool) : Measurable (p.localRecord a) := by |
| apply Measurable.of_eval |
| intro n |
| exact ((p.measurable_extractPrivate a (n+1)).comp (by fun_prop)).eval (a := Fin.last n) |
| |
| lemma publicRecord_replay (uv : UniformTape × UniformTape) : |
| p.publicRecord (p.outcomeRecord uv) = p.tapeProgram.record uv := by |
| funext n |
| have h := congrFun (p.replay_matches (n+1) uv).1 (Fin.last n) |
| have he : (fun i : Fin (n+1) => p.outcomeRecord uv i) = |
| p.causal.history (n+1) (pairedTape uv) := by |
| funext i |
| exact (p.causal.prefix_eq_record (n+1) (pairedTape uv) i).symm |
| change p.publicFrom (n+1) (fun i => p.outcomeRecord uv i) (Fin.last n) = _ |
| rw [he,h,p.tapeProgram.prefix_eq_record] |
| rfl |
| |
| lemma localRecord_replay (a : Bool) (uv : UniformTape × UniformTape) : |
| p.localRecord a (p.outcomeRecord uv) = |
| p.privateRecord a ((if a then uv.1 else uv.2),p.tapeProgram.record uv) := by |
| funext n |
| have h := congrFun ((p.replay_matches (n+1) uv).2 a) (Fin.last n) |
| have he : (fun i : Fin (n+1) => p.outcomeRecord uv i) = |
| p.causal.history (n+1) (pairedTape uv) := by |
| funext i |
| exact (p.causal.prefix_eq_record (n+1) (pairedTape uv) i).symm |
| change p.extractPrivate a (n+1) (fun i => p.outcomeRecord uv i) (Fin.last n) = _ |
| rw [he,h] |
| congr 2 |
| funext i |
| exact p.tapeProgram.prefix_eq_record (n+1) uv i |
| |
| universe v6928_0 v6928_1 |
| |
| theorem full_readout_law {A : Type v6928_0} {B : Type v6928_1} [MeasurableSpace A] [MeasurableSpace B] |
| (κ : (n : ℕ) → Kernel (Fin n → O) O) [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, (volume.prod volume).map (fun u => p.causal.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (fun x => fun i : Fin (n+1) => x i) = |
| ((P.map (fun x => fun i : Fin n => x i)) ⊗ₘ κ n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) |
| (readA : (ℕ → (O ⊕ Unit)) × (ℕ → M) → A) |
| (readB : (ℕ → (O ⊕ Unit)) × (ℕ → M) → B) |
| (ha : Measurable readA) (hb : Measurable readB) : |
| P.map (fun x => (p.publicRecord x, |
| readA (p.localRecord true x,p.publicRecord x), |
| readB (p.localRecord false x,p.publicRecord x))) = |
| (uniformTapeLaw.prod uniformTapeLaw).map (fun uv => (p.tapeProgram.record uv, |
| readA (p.privateRecord true (uv.1,p.tapeProgram.record uv),p.tapeProgram.record uv), |
| readB (p.privateRecord false (uv.2,p.tapeProgram.record uv),p.tapeProgram.record uv))) := by |
| rw [← p.outcomeRecord_law κ hlaw P hP] |
| have hm : Measurable (fun x => (p.publicRecord x, |
| readA (p.localRecord true x,p.publicRecord x), |
| readB (p.localRecord false x,p.publicRecord x))) := by |
| exact p.measurable_publicRecord.prodMk |
| ((ha.comp ((p.measurable_localRecord true).prodMk p.measurable_publicRecord)).prodMk |
| (hb.comp ((p.measurable_localRecord false).prodMk p.measurable_publicRecord))) |
| rw [Measure.map_map hm p.measurable_outcomeRecord] |
| congr 1 |
| funext uv |
| simp only [Function.comp_def,p.publicRecord_replay,p.localRecord_replay, |
| Bool.false_eq_true,↓reduceIte] |
| |
| universe v6957_0 v6957_1 |
| |
| theorem actual_records_independent [StandardBorelSpace O] [Nonempty M] {A : Type v6957_0} {B : Type v6957_1} |
| [MeasurableSpace A] [StandardBorelSpace A] [Nonempty A] |
| [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B] |
| (κ : (n : ℕ) → Kernel (Fin n → O) O) [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, (volume.prod volume).map (fun u => p.causal.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (fun x => fun i : Fin (n+1) => x i) = |
| ((P.map (fun x => fun i : Fin n => x i)) ⊗ₘ κ n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) |
| (readA : (ℕ → (O ⊕ Unit)) × (ℕ → M) → A) |
| (readB : (ℕ → (O ⊕ Unit)) × (ℕ → M) → B) |
| (ha : Measurable readA) (hb : Measurable readB) : |
| CondIndepFun (MeasurableSpace.comap p.publicRecord inferInstance) |
| p.measurable_publicRecord.comap_le |
| (fun x => readA (p.localRecord true x,p.publicRecord x)) |
| (fun x => readB (p.localRecord false x,p.publicRecord x)) P := by |
| apply condIndepFun_of_joint_law p.measurable_publicRecord |
| (ha.comp ((p.measurable_localRecord true).prodMk p.measurable_publicRecord)) |
| (hb.comp ((p.measurable_localRecord false).prodMk p.measurable_publicRecord)) |
| p.tapeProgram.measurable_record |
| (ha.comp (((p.measurable_privateRecord true).comp |
| (measurable_fst.prodMk p.tapeProgram.measurable_record)).prodMk |
| p.tapeProgram.measurable_record)) |
| (hb.comp (((p.measurable_privateRecord false).comp |
| (measurable_snd.prodMk p.tapeProgram.measurable_record)).prodMk |
| p.tapeProgram.measurable_record)) |
| (p.full_readout_law κ hlaw P hP readA readB ha hb) |
| (p.final_records_independent readA readB ha hb) |
| |
| end AdaptiveOutcomeSampler |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker Topology |
| |
| universe v7004_0 v7004_1 |
| |
| variable {ι : Type v7004_0} {η : Type v7004_1} [inst7004_0 : Fintype ι] [inst7004_1 : Fintype η] [inst7004_2 : DecidableEq ι] [inst7004_3 : DecidableEq η] |
| |
| omit inst7004_2 inst7004_3 in |
| lemma continuous_matrix_kronecker [DecidableEq ι] [DecidableEq η] : Continuous |
| (fun z : Matrix ι ι ℂ × Matrix η η ℂ => z.1 ⊗ₖ z.2) := by |
| apply continuous_matrix |
| intro i j |
| exact (((Matrix.entryLinearMap ℂ ℂ i.1 j.1).toContinuousLinearMap).continuous.comp |
| continuous_fst).mul |
| (((Matrix.entryLinearMap ℂ ℂ i.2 j.2).toContinuousLinearMap).continuous.comp |
| continuous_snd) |
| |
| universe v7015_0 |
| |
| lemma measurable_matrix_kronecker {Ω : Type v7015_0} [MeasurableSpace Ω] |
| {U : Ω → Matrix ι ι ℂ} {V : Ω → Matrix η η ℂ} |
| (hU : Measurable U) (hV : Measurable V) : |
| Measurable (fun x => U x ⊗ₖ V x) := |
| continuous_matrix_kronecker.measurable.comp (hU.prodMk hV) |
| |
| omit inst7004_2 inst7004_3 in |
| lemma density_kronecker [DecidableEq ι] [DecidableEq η] {U : Matrix ι ι ℂ} {V : Matrix η η ℂ} |
| (hU : Density U) (hV : Density V) : Density (U ⊗ₖ V) := by |
| refine ⟨hU.1.kronecker hV.1,?_⟩ |
| rw [Matrix.trace_kronecker,hU.2,hV.2,one_mul] |
| |
| universe v7027_0 |
| |
| variable {Ω : Type v7027_0} {LA LB : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| {μ : Measure Ω} [inst7027_0 : IsFiniteMeasure μ] {F : Filtration ℕ mΩ} |
| |
| theorem local_product_reference_extension |
| (U : ℕ → Ω → Matrix ι ι ℂ) (V : ℕ → Ω → Matrix η η ℂ) |
| (hU : ∀ n x, Density (U n x)) (hV : ∀ n x, Density (V n x)) |
| (hLA : LA ≤ mΩ) (hLB : LB ≤ mΩ) |
| (hmU : ∀ n, Measurable[LA] (U n)) (hmV : ∀ n, Measurable[LB] (V n)) |
| (hrU : ∀ i j, Martingale (fun n x => (U n x i j).re) F μ) |
| (hiU : ∀ i j, Martingale (fun n x => (U n x i j).im) F μ) |
| (hrV : ∀ i j, Martingale (fun n x => (V n x i j).re) F μ) |
| (hiV : ∀ i j, Martingale (fun n x => (V n x i j).im) F μ) |
| (hrUV : ∀ i j, Martingale (fun n x => ((U n x ⊗ₖ V n x) i j).re) F μ) |
| (hiUV : ∀ i j, Martingale (fun n x => ((U n x ⊗ₖ V n x) i j).im) F μ) : |
| ∃ G : Ω → Matrix ι ι ℂ, ∃ H : Ω → Matrix η η ℂ, |
| Measurable[LA] G ∧ Measurable[LB] H ∧ |
| (∀ x, Density (G x)) ∧ (∀ x, Density (H x)) ∧ |
| (∀ᵐ x ∂μ, Tendsto (fun n => U n x) atTop (𝓝 (G x))) ∧ |
| (∀ᵐ x ∂μ, Tendsto (fun n => V n x) atTop (𝓝 (H x))) ∧ |
| (∀ n S, MeasurableSet[F n] S → |
| (∫ x in S, G x ∂μ) = ∫ x in S, U n x ∂μ) ∧ |
| (∀ n S, MeasurableSet[F n] S → |
| (∫ x in S, H x ∂μ) = ∫ x in S, V n x ∂μ) ∧ |
| ∃ W : PositiveMatrixMeasure Ω (ι × η), |
| (∀ S, MeasurableSet S → W.value S = ∫ x in S, G x ⊗ₖ H x ∂μ) ∧ |
| (∀ n S, MeasurableSet[F n] S → |
| W.value S = ∫ x in S, U n x ⊗ₖ V n x ∂μ) := by |
| obtain ⟨G,hGm,hG,hGi,hGt,hGc⟩ := local_reference_limit U hU hmU hLA hrU hiU |
| obtain ⟨H,hHm,hH,hHi,hHt,hHc⟩ := local_reference_limit V hV hmV hLB hrV hiV |
| obtain ⟨J,hJm,hJ,hJi,hJt,hJc⟩ := local_reference_limit |
| (fun n x => U n x ⊗ₖ V n x) |
| (fun n x => density_kronecker (hU n x) (hV n x)) |
| (fun n => measurable_matrix_kronecker ((hmU n).mono hLA le_rfl) |
| ((hmV n).mono hLB le_rfl)) le_rfl hrUV hiUV |
| have hprod : (fun x => G x ⊗ₖ H x) =ᵐ[μ] J := by |
| filter_upwards [hGt,hHt,hJt] with x hx hy hz |
| have ht : Tendsto (fun n => U n x ⊗ₖ V n x) atTop (𝓝 (G x ⊗ₖ H x)) := |
| continuous_matrix_kronecker.continuousAt.tendsto.comp (hx.prodMk_nhds hy) |
| exact tendsto_nhds_unique ht hz |
| let W := positiveMatrixMeasureOfDensity hJi |
| (Eventually.of_forall (fun x => (hJ x).1)) |
| refine ⟨G,H,hGm,hHm,hG,hH,hGt,hHt,hGc,hHc,W,?_,?_⟩ |
| · intro S hS |
| rw [positiveMatrixMeasureOfDensity_value hJi _ S hS] |
| exact integral_congr_ae (ae_restrict_of_ae hprod.symm) |
| · intro n S hS |
| rw [positiveMatrixMeasureOfDensity_value hJi _ S (F.le n S hS)] |
| exact hJc n S hS |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter unitInterval |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker Topology |
| |
| namespace AdaptiveOutcomeSampler |
| |
| universe v7093_0 v7093_1 |
| |
| variable {O : Type v7093_0} {M : Type v7093_1} [inst7093_0 : MeasurableSpace O] [inst7093_1 : MeasurableSpace M] |
| (p : AdaptiveOutcomeSampler O M) |
| |
| lemma publicFrom_eq_record (n : ℕ) (x : ℕ → O) (i : Fin n) : |
| p.publicFrom n (historyPrefix n x) i = p.publicRecord x i := by |
| induction n with |
| | zero => exact Fin.elim0 i |
| | succ n ih => |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · rfl |
| · simp only [publicFrom,replay,Fin.snoc_castSucc] |
| exact ih j |
| |
| lemma extractPrivate_eq_record (a : Bool) (n : ℕ) (x : ℕ → O) (i : Fin n) : |
| p.extractPrivate a n (historyPrefix n x) i = p.localRecord a x i := by |
| induction n with |
| | zero => exact Fin.elim0 i |
| | succ n ih => |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · rfl |
| · cases a <;> simp only [extractPrivate,replay,Bool.false_eq_true,↓reduceIte, |
| Fin.snoc_castSucc] <;> exact ih j |
| |
| abbrev localField (a : Bool) : MeasurableSpace (ℕ → O) := |
| MeasurableSpace.comap (fun x => (p.localRecord a x,p.publicRecord x)) inferInstance |
| |
| lemma localField_le (a : Bool) : p.localField a ≤ (inferInstance : MeasurableSpace (ℕ → O)) := |
| ((p.measurable_localRecord a).prodMk p.measurable_publicRecord).comap_le |
| |
| lemma local_history_measurable (a : Bool) (n : ℕ) : |
| Measurable[p.localField a] (fun x => |
| (p.extractPrivate a n (historyPrefix n x),p.publicFrom n (historyPrefix n x))) := by |
| have he : (fun x => (p.extractPrivate a n (historyPrefix n x),p.publicFrom n (historyPrefix n x))) = |
| fun x => ((fun i : Fin n => p.localRecord a x i),fun i : Fin n => p.publicRecord x i) := by |
| funext x |
| congr 1 <;> funext i |
| · exact p.extractPrivate_eq_record a n x i |
| · exact p.publicFrom_eq_record n x i |
| rw [he] |
| let : MeasurableSpace (ℕ → O) := p.localField a |
| have hm : Measurable (fun x : ℕ → O => (p.localRecord a x,p.publicRecord x)) := |
| Measurable.of_comap_le le_rfl |
| exact (Measurable.of_eval (fun i => hm.fst.eval)).prodMk |
| (Measurable.of_eval (fun i => hm.snd.eval)) |
| |
| lemma localFields_independent [StandardBorelSpace O] [Nonempty O] |
| [StandardBorelSpace M] [Nonempty M] |
| (κ : (n : ℕ) → Kernel (Fin n → O) O) [∀ n, IsMarkovKernel (κ n)] |
| (hlaw : ∀ n s, ((volume : Measure I).prod volume).map |
| (fun u => p.causal.step n (s,u)) = κ n s) |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (historyPrefix (n+1)) = |
| ((P.map (historyPrefix n)) ⊗ₘ κ n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) : |
| CondIndep (MeasurableSpace.comap p.publicRecord inferInstance) |
| (p.localField true) (p.localField false) p.measurable_publicRecord.comap_le P := by |
| classical |
| rw [condIndep_iff _ _ _ _ (p.localField_le true) (p.localField_le false)] |
| intro SA SB hSA hSB |
| obtain ⟨EA,hEA,rfl⟩ := hSA |
| obtain ⟨EB,hEB,rfl⟩ := hSB |
| let fa : (ℕ → O ⊕ Unit) × (ℕ → M) → Bool := |
| fun x => if x ∈ EA then true else false |
| let fb : (ℕ → O ⊕ Unit) × (ℕ → M) → Bool := |
| fun x => if x ∈ EB then true else false |
| have hfa : Measurable fa := measurable_const.ite hEA measurable_const |
| have hfb : Measurable fb := measurable_const.ite hEB measurable_const |
| have hi := p.actual_records_independent κ hlaw P hP fa fb hfa hfb |
| apply (condIndepFun_iff _ _ _ _ |
| (hfa.comp ((p.measurable_localRecord true).prodMk p.measurable_publicRecord)) |
| (hfb.comp ((p.measurable_localRecord false).prodMk p.measurable_publicRecord)) P).mp hi |
| · refine ⟨{true},measurableSet_singleton true,?_⟩ |
| ext x |
| simp [fa] |
| · refine ⟨{true},measurableSet_singleton true,?_⟩ |
| ext x |
| simp [fb] |
| |
| end AdaptiveOutcomeSampler |
| |
| namespace AdaptiveQuantum |
| |
| open UnrestrictedQuantum |
| |
| universe v7175_0 v7175_1 v7175_2 v7175_3 v7175_4 v7175_5 |
| |
| variable {O : Type v7175_0} {M : Type v7175_1} {ι : Type v7175_2} {η : Type v7175_3} [inst7175_0 : MeasurableSpace O] [inst7175_1 : MeasurableSpace M] |
| [inst7175_2 : Fintype ι] [inst7175_3 : Fintype η] [inst7175_4 : DecidableEq ι] [inst7175_5 : DecidableEq η] |
| {A : ℕ → Type v7175_4} {B : ℕ → Type v7175_5} |
| [inst7175_6 : ∀ n, AddCommGroup (A n)] [inst7175_7 : ∀ n, Module ℂ (A n)] [inst7175_8 : ∀ n, One (A n)] [inst7175_9 : ∀ n, LE (A n)] |
| [inst7175_10 : ∀ n, AddCommGroup (B n)] [inst7175_11 : ∀ n, Module ℂ (B n)] [inst7175_12 : ∀ n, One (B n)] [inst7175_13 : ∀ n, LE (B n)] |
| (p : AdaptiveOutcomeSampler O M) |
| (κA κB : (n : ℕ) → Kernel (LocalHistory O M n) O) |
| [inst7175_14 : ∀ n, IsMarkovKernel (κA n)] [inst7175_15 : ∀ n, IsMarkovKernel (κB n)] |
| (eA : LocalObservableExecution (ι := ι) A κA p.sendA) |
| (eB : LocalObservableExecution (ι := η) B κB p.sendB) |
| |
| theorem full_reference_extension |
| (P : Measure (ℕ → O)) [IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (historyPrefix (n+1)) = |
| ((P.map (historyPrefix n)) ⊗ₘ p.instrumentKernel κA κB n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) : |
| ∃ G : (ℕ → O) → Matrix ι ι ℂ, ∃ H : (ℕ → O) → Matrix η η ℂ, |
| Measurable[p.localField true] G ∧ Measurable[p.localField false] H ∧ |
| (∀ x, Density (G x)) ∧ (∀ x, Density (H x)) ∧ |
| (∀ n S, MeasurableSet[historyFiltration n] S → |
| (∫ x in S, G x ∂P) = ∫ x in S, globalLocalReferenceA p κA eA n (historyPrefix n x) ∂P) ∧ |
| (∀ n S, MeasurableSet[historyFiltration n] S → |
| (∫ x in S, H x ∂P) = ∫ x in S, globalLocalReferenceB p κB eB n (historyPrefix n x) ∂P) ∧ |
| ∃ W : PositiveMatrixMeasure (ℕ → O) (ι × η), |
| (∀ S, MeasurableSet S → W.value S = ∫ x in S, G x ⊗ₖ H x ∂P) ∧ |
| (∀ n S, MeasurableSet[historyFiltration n] S → |
| W.value S = ∫ x in S, jointReference p κA κB eA eB n (historyPrefix n x) ∂P) := by |
| let U := globalLocalReferenceA p κA eA |
| let V := globalLocalReferenceB p κB eB |
| have hU (n : ℕ) (s : Fin n → O) : Density (U n s) := eA.reference_density n _ |
| have hV (n : ℕ) (s : Fin n → O) : Density (V n s) := eB.reference_density n _ |
| have hmU := globalLocalReferenceA_measurable p κA eA |
| have hmV := globalLocalReferenceB_measurable p κB eB |
| have hmeanU := globalLocalReferenceA_mean p κA κB eA |
| have hmeanV := globalLocalReferenceB_mean p κA κB eB |
| have hrU := reference_history_martingale_re P (p.instrumentKernel κA κB) hP U hU hmU hmeanU |
| have hiU := reference_history_martingale_im P (p.instrumentKernel κA κB) hP U hU hmU hmeanU |
| have hrV := reference_history_martingale_re P (p.instrumentKernel κA κB) hP V hV hmV hmeanV |
| have hiV := reference_history_martingale_im P (p.instrumentKernel κA κB) hP V hV hmV hmeanV |
| have hrUV := reference_history_martingale_re P (p.instrumentKernel κA κB) hP |
| (jointReference p κA κB eA eB) (jointReference_density p κA κB eA eB) |
| (jointReference_measurable p κA κB eA eB) (jointReference_mean p κA κB eA eB) |
| have hiUV := reference_history_martingale_im P (p.instrumentKernel κA κB) hP |
| (jointReference p κA κB eA eB) (jointReference_density p κA κB eA eB) |
| (jointReference_measurable p κA κB eA eB) (jointReference_mean p κA κB eA eB) |
| obtain ⟨G,H,hGm,hHm,hG,hH,_,_,hGc,hHc,W,hW,hWc⟩ := |
| local_product_reference_extension |
| (fun n x => U n (historyPrefix n x)) (fun n x => V n (historyPrefix n x)) |
| (fun n x => hU n _) (fun n x => hV n _) (p.localField_le true) (p.localField_le false) |
| (fun n => (eA.reference_measurable n).comp (p.local_history_measurable true n)) |
| (fun n => (eB.reference_measurable n).comp (p.local_history_measurable false n)) |
| hrU hiU hrV hiV hrUV hiUV |
| exact ⟨G,H,hGm,hHm,hG,hH,hGc,hHc,W,hW,hWc⟩ |
| |
| end AdaptiveQuantum |
| |
| end |
| |
| section |
| |
| open MeasureTheory ProbabilityTheory Matrix |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| universe v7253_0 |
| |
| lemma condIndepFun_ae_indep_complex {Ω : Type v7253_0} {C : MeasurableSpace Ω} |
| {mΩ : MeasurableSpace Ω} [inst7253_0 : StandardBorelSpace Ω] {μ : Measure Ω} |
| [inst7253_1 : IsFiniteMeasure μ] (hC : C ≤ mΩ) |
| {f g : Ω → ℂ} |
| (hf : Measurable f) (hg : Measurable g) |
| (h : CondIndepFun C hC f g μ) : |
| ∀ᵐ x ∂μ.trim hC, IndepFun f g (condExpKernel μ C x) := by |
| have he := (condIndepFun_iff_map_prod_eq_prod_map_map hf hg).mp h |
| filter_upwards [he] with x hx |
| apply (indepFun_iff_map_prod_eq_prod_map_map hf.aemeasurable hg.aemeasurable).mpr |
| simpa only [Kernel.prod_apply, Kernel.map_apply _ (hf.prodMk hg), |
| Kernel.map_apply _ hf, Kernel.map_apply _ hg] using hx |
| |
| lemma condIndepFun_kernel_integral_mul {Ω : Type v7253_0} {C : MeasurableSpace Ω} |
| {mΩ : MeasurableSpace Ω} [inst7253_0 : StandardBorelSpace Ω] {μ : Measure Ω} |
| [inst7253_1 : IsFiniteMeasure μ] (hC : C ≤ mΩ) |
| {f g : Ω → ℂ} |
| (hf : Measurable f) (hg : Measurable g) |
| (h : CondIndepFun C hC f g μ) : |
| ∀ᵐ x ∂μ.trim hC, |
| (∫ y, f y * g y ∂condExpKernel μ C x) = |
| (∫ y, f y ∂condExpKernel μ C x) * |
| (∫ y, g y ∂condExpKernel μ C x) := by |
| filter_upwards [condIndepFun_ae_indep_complex hC hf hg h] with x hx |
| exact hx.integral_fun_mul_eq_mul_integral hf.stronglyMeasurable.aestronglyMeasurable |
| hg.stronglyMeasurable.aestronglyMeasurable |
| |
| universe v7283_0 v7283_1 v7283_2 |
| |
| variable {Ω : Type v7283_0} {ι : Type v7283_1} {κ : Type v7283_2} {C A B : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| [inst7283_0 : StandardBorelSpace Ω] [inst7283_1 : Fintype ι] [inst7283_2 : Fintype κ] [inst7283_3 : DecidableEq ι] [inst7283_4 : DecidableEq κ] |
| {μ : Measure Ω} [inst7283_5 : IsFiniteMeasure μ] |
| |
| def publicMatrix (C : MeasurableSpace Ω) {mΩ : MeasurableSpace Ω} |
| [StandardBorelSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ] |
| (W : Ω → Matrix ι ι ℂ) (x : Ω) : Matrix ι ι ℂ := |
| ∫ y, W y ∂condExpKernel μ C x |
| |
| lemma publicMatrix_measurable (_hC : C ≤ mΩ) {W : Ω → Matrix ι ι ℂ} |
| (hW : Measurable W) : Measurable[C] (publicMatrix C μ W) := by |
| exact hW.stronglyMeasurable.integral_condExpKernel.measurable |
| |
| lemma publicMatrix_entry (W : Ω → Matrix ι ι ℂ) |
| (hWi : ∀ x, Integrable W (condExpKernel μ C x)) (x : Ω) (i j : ι) : |
| publicMatrix C μ W x i j = ∫ y, W y i j ∂condExpKernel μ C x := |
| integral_matrix_entry (hWi x) i j |
| |
| theorem condIndep_publicMatrix_kronecker |
| (hC : C ≤ mΩ) (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (h : CondIndep C A B hC μ) |
| (U : Ω → Matrix ι ι ℂ) (V : Ω → Matrix κ κ ℂ) |
| (hUm : Measurable[A] U) (hVm : Measurable[B] V) |
| (hUi : ∀ x, Integrable U (condExpKernel μ C x)) |
| (hVi : ∀ x, Integrable V (condExpKernel μ C x)) |
| (hUVi : ∀ x, Integrable (fun y => U y ⊗ₖ V y) (condExpKernel μ C x)) : |
| publicMatrix C μ (fun y => U y ⊗ₖ V y) =ᵐ[μ.trim hC] |
| fun x => publicMatrix C μ U x ⊗ₖ publicMatrix C μ V x := by |
| have he (i j : ι) (k l : κ) : |
| ∀ᵐ x ∂μ.trim hC, |
| (∫ y, U y i j * V y k l ∂condExpKernel μ C x) = |
| (∫ y, U y i j ∂condExpKernel μ C x) * |
| (∫ y, V y k l ∂condExpKernel μ C x) := by |
| have huf : Measurable[A] (fun y => U y i j) := |
| ((Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap).measurable.comp hUm |
| have hvf : Measurable[B] (fun y => V y k l) := |
| ((Matrix.entryLinearMap ℂ ℂ k l).toContinuousLinearMap).measurable.comp hVm |
| have hfg : CondIndepFun C hC (fun y => U y i j) (fun y => V y k l) μ := by |
| exact condIndep_of_condIndep_of_le_right |
| (condIndep_of_condIndep_of_le_left h huf.comap_le) hvf.comap_le |
| exact condIndepFun_kernel_integral_mul hC (huf.mono hA le_rfl) |
| (hvf.mono hB le_rfl) hfg |
| have he' := ae_all_iff.mpr (fun i => ae_all_iff.mpr (fun j => |
| ae_all_iff.mpr (fun k => ae_all_iff.mpr (he i j k)))) |
| filter_upwards [he'] with x hx |
| ext ⟨i,k⟩ ⟨j,l⟩ |
| rw [publicMatrix_entry _ hUVi, Matrix.kronecker_apply, |
| publicMatrix_entry _ hUi, publicMatrix_entry _ hVi] |
| exact hx i j k l |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| universe v7361_0 v7361_1 |
| |
| variable {ι : Type v7361_0} {η : Type v7361_1} [inst7361_0 : Fintype ι] [inst7361_1 : Fintype η] [inst7361_2 : DecidableEq ι] [inst7361_3 : DecidableEq η] |
| |
| def Subdensity (U : Matrix ι ι ℂ) : Prop := U.PosSemidef ∧ (trace U).re ≤ 1 |
| |
| omit inst7361_2 in |
| lemma subdensity_zero [DecidableEq ι] : Subdensity (0 : Matrix ι ι ℂ) := by |
| exact ⟨Matrix.PosSemidef.zero, by simp⟩ |
| |
| omit inst7361_2 inst7361_3 in |
| lemma subdensity_kronecker [DecidableEq ι] [DecidableEq η] {U : Matrix ι ι ℂ} {V : Matrix η η ℂ} |
| (hU : Subdensity U) (hV : Subdensity V) : Subdensity (U ⊗ₖ V) := by |
| refine ⟨hU.1.kronecker hV.1,?_⟩ |
| have hUi : (trace U).im = 0 := (RCLike.nonneg_iff.mp hU.1.trace_nonneg).2 |
| have hVi : (trace V).im = 0 := (RCLike.nonneg_iff.mp hV.1.trace_nonneg).2 |
| rw [Matrix.trace_kronecker, Complex.mul_re,hUi,hVi,mul_zero,sub_zero] |
| exact (mul_le_of_le_one_left ((RCLike.nonneg_iff.mp hV.1.trace_nonneg).1) hU.2).trans hV.2 |
| |
| universe v7376_0 |
| |
| lemma integrable_subdensity {Ω : Type v7376_0} [MeasurableSpace Ω] |
| (U : Ω → Matrix ι ι ℂ) (hU : ∀ x, Subdensity (U x)) (hm : Measurable U) |
| (μ : Measure Ω) [IsFiniteMeasure μ] : Integrable U μ := by |
| apply integrable_matrix_of_entries |
| intro i j |
| apply Integrable.of_bound |
| (((Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap).measurable.comp hm).aestronglyMeasurable 1 |
| exact Filter.Eventually.of_forall (fun x => |
| (psd_entry_norm_le_trace (hU x).1 i j).trans (hU x).2) |
| |
| universe v7386_0 |
| |
| lemma integral_subdensity {Ω : Type v7386_0} [MeasurableSpace Ω] |
| (U : Ω → Matrix ι ι ℂ) (hU : ∀ x, Subdensity (U x)) (hm : Measurable U) |
| (μ : Measure Ω) [IsProbabilityMeasure μ] : Subdensity (∫ x, U x ∂μ) := by |
| have hi := integrable_subdensity U hU hm μ |
| refine ⟨(integral_nonneg_of_ae (Filter.Eventually.of_forall |
| (fun x => (hU x).1.nonneg))).posSemidef,?_⟩ |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.traceLinearMap ι ℂ ℂ).toContinuousLinearMap |
| have htrace : trace (∫ x, U x ∂μ) = ∫ x, trace (U x) ∂μ := (L.integral_comp_comm hi).symm |
| rw [htrace] |
| change RCLike.re (∫ x, L (U x) ∂μ) ≤ 1 |
| rw [← integral_re (L.integrable_comp hi)] |
| calc |
| _ ≤ ∫ _ : Ω, (1 : ℝ) ∂μ := integral_mono ((L.integrable_comp hi).re) |
| (integrable_const 1) (fun x => (hU x).2) |
| _ = 1 := by simp |
| |
| universe v7402_0 v7402_1 |
| |
| lemma measurable_positive_factor {Ω : Type v7402_0} {T : Type v7402_1} [MeasurableSpace Ω] |
| [MeasurableSpace T] (r : Ω → T) |
| (U : Ω → Matrix ι ι ℂ) (hU : ∀ x, Subdensity (U x)) |
| (hm : Measurable[MeasurableSpace.comap r inferInstance] U) : |
| ∃ V : T → Matrix ι ι ℂ, Measurable V ∧ (∀ t, Subdensity (V t)) ∧ U = V ∘ r := by |
| classical |
| obtain ⟨V,hVm,hV⟩ := hm.exists_eq_measurable_comp |
| let good : Set T := {t | 0 ≤ V t ∧ (trace (V t)).re ≤ 1} |
| have hg : MeasurableSet good := |
| (measurableSet_le measurable_const hVm).inter |
| (measurableSet_le (((Matrix.traceLinearMap ι ℂ ℂ).toContinuousLinearMap).measurable.comp hVm).re measurable_const) |
| let W : T → Matrix ι ι ℂ := good.piecewise V (fun _ => 0) |
| refine ⟨W,hVm.piecewise hg measurable_const,?_,?_⟩ |
| · intro t |
| by_cases ht : t ∈ good |
| · simpa only [W,Set.piecewise_eq_of_mem good V _ ht] using |
| (show Subdensity (V t) from ⟨ht.1.posSemidef,ht.2⟩) |
| · simpa only [W,Set.piecewise_eq_of_notMem good V _ ht] using subdensity_zero (ι := ι) |
| · funext x |
| have he : U x = V (r x) := congrFun hV x |
| have hgx : r x ∈ good := by |
| change 0 ≤ V (r x) ∧ (trace (V (r x))).re ≤ 1 |
| rw [← he] |
| exact ⟨(hU x).1.nonneg,(hU x).2⟩ |
| simpa only [Function.comp_apply,W,Set.piecewise_eq_of_mem good V _ hgx] using he |
| |
| universe v7429_0 v7429_1 |
| |
| variable {Ω : Type v7429_0} {T : Type v7429_1} {A B : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| [inst7429_0 : StandardBorelSpace Ω] [inst7429_1 : MeasurableSpace T] |
| {μ : Measure Ω} [inst7429_2 : IsFiniteMeasure μ] |
| (r : Ω → T) (hr : Measurable r) |
| |
| theorem terminal_public_factors |
| (hA : A ≤ mΩ) (hB : B ≤ mΩ) |
| (h : CondIndep (MeasurableSpace.comap r inferInstance) A B hr.comap_le μ) |
| (U : Bool → Ω → Matrix ι ι ℂ) (V : Bool → Ω → Matrix η η ℂ) |
| (hU : ∀ i x, Subdensity (U i x)) (hV : ∀ j x, Subdensity (V j x)) |
| (hmU : ∀ i, Measurable[A] (U i)) (hmV : ∀ j, Measurable[B] (V j)) : |
| ∃ X : Bool → T → Matrix ι ι ℂ, ∃ Y : Bool → T → Matrix η η ℂ, |
| (∀ i, Measurable (X i)) ∧ (∀ j, Measurable (Y j)) ∧ |
| (∀ i t, Subdensity (X i t)) ∧ (∀ j t, Subdensity (Y j t)) ∧ |
| (∀ i j, publicMatrix (MeasurableSpace.comap r inferInstance) μ |
| (fun x => U i x ⊗ₖ V j x) =ᵐ[μ] |
| fun x => X i (r x) ⊗ₖ Y j (r x)) := by |
| have hUm (i : Bool) := (hmU i).mono hA le_rfl |
| have hVm (j : Bool) := (hmV j).mono hB le_rfl |
| have hpU (i : Bool) : ∀ x, Subdensity (publicMatrix (MeasurableSpace.comap r inferInstance) μ (U i) x) := |
| fun x => integral_subdensity (U i) (hU i) (hUm i) (condExpKernel μ (MeasurableSpace.comap r inferInstance) x) |
| have hpV (j : Bool) : ∀ x, Subdensity (publicMatrix (MeasurableSpace.comap r inferInstance) μ (V j) x) := |
| fun x => integral_subdensity (V j) (hV j) (hVm j) (condExpKernel μ (MeasurableSpace.comap r inferInstance) x) |
| choose X hXm hXp hX using fun i => measurable_positive_factor r |
| (publicMatrix (MeasurableSpace.comap r inferInstance) μ (U i)) (hpU i) (publicMatrix_measurable hr.comap_le (hUm i)) |
| choose Y hYm hYp hY using fun j => measurable_positive_factor r |
| (publicMatrix (MeasurableSpace.comap r inferInstance) μ (V j)) (hpV j) (publicMatrix_measurable hr.comap_le (hVm j)) |
| refine ⟨X,Y,hXm,hYm,hXp,hYp,?_⟩ |
| intro i j |
| have he := condIndep_publicMatrix_kronecker hr.comap_le hA hB h |
| (U i) (V j) (hmU i) (hmV j) |
| (fun x => integrable_subdensity (U i) (hU i) (hUm i) (condExpKernel μ (MeasurableSpace.comap r inferInstance) x)) |
| (fun x => integrable_subdensity (V j) (hV j) (hVm j) (condExpKernel μ (MeasurableSpace.comap r inferInstance) x)) |
| (fun x => integrable_subdensity (fun y => U i y ⊗ₖ V j y) |
| (fun y => subdensity_kronecker (hU i y) (hV j y)) |
| (measurable_matrix_kronecker (hUm i) (hVm j)) (condExpKernel μ (MeasurableSpace.comap r inferInstance) x)) |
| have he' := ae_of_ae_trim hr.comap_le he |
| filter_upwards [he'] with x hx |
| exact hx.trans (by rw [congrFun (hX i) x,congrFun (hY j) x]; rfl) |
| |
| end |
| |
| open MeasureTheory Matrix Filter |
| |
| open scoped ComplexOrder MatrixOrder |
| |
| namespace PositiveMatrixMeasure |
| |
| universe v7485_0 v7485_1 |
| |
| variable {Ω : Type v7485_0} {ι : Type v7485_1} {mΩ : MeasurableSpace Ω} [inst7485_0 : Fintype ι] [inst7485_1 : DecidableEq ι] |
| |
| omit inst7485_1 in |
| lemma ext_on_generating_piSystem [DecidableEq ι] (W V : PositiveMatrixMeasure Ω ι) (C : Set (Set Ω)) |
| (hC : IsPiSystem C) (hm : mΩ = MeasurableSpace.generateFrom C) |
| (h : ∀ S ∈ C, W.value S = V.value S) (hu : W.value Set.univ = V.value Set.univ) : W = V := by |
| have he : W.entry = V.entry := by |
| funext i j |
| refine VectorMeasure.ext_of_generateFrom C ?_ hm hC ?_ |
| · intro S hS |
| exact congrArg (fun M : Matrix ι ι ℂ => M i j) (h S hS) |
| · exact congrArg (fun M : Matrix ι ι ℂ => M i j) hu |
| cases W |
| cases V |
| cases he |
| rfl |
| |
| lemma ext_on_filtration (W V : PositiveMatrixMeasure Ω ι) (F : Filtration ℕ mΩ) |
| (hm : mΩ = ⨆ n, F n) |
| (h : ∀ n S, MeasurableSet[F n] S → W.value S = V.value S) : W = V := by |
| let C : Set (Set Ω) := {S | ∃ n, MeasurableSet[F n] S} |
| have hc : IsPiSystem C := by |
| intro S hS T hT _ |
| obtain ⟨n,hn⟩ := hS |
| obtain ⟨k,hk⟩ := hT |
| exact ⟨max n k, ((F.mono (le_max_left n k)) S hn).inter ((F.mono (le_max_right n k)) T hk)⟩ |
| have hgen : mΩ = MeasurableSpace.generateFrom C := by |
| rw [hm] |
| apply le_antisymm |
| · apply iSup_le; intro n S hS |
| exact MeasurableSpace.measurableSet_generateFrom ⟨n,hS⟩ |
| · apply MeasurableSpace.generateFrom_le |
| rintro S ⟨n,hn⟩ |
| exact (le_iSup (fun n => F n) n) S hn |
| exact W.ext_on_generating_piSystem V C hc hgen (fun S ⟨n,hn⟩ => h n S hn) |
| (h 0 Set.univ MeasurableSet.univ) |
| |
| end PositiveMatrixMeasure |
| |
| end ZeroKey |
| |
| namespace UnrestrictedQuantum |
| |
| open Matrix MeasureTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe v7551_0 v7551_1 v7551_2 |
| |
| variable {A : Type v7551_0} {B : Type v7551_1} {ι : Type v7551_2} [inst7551_0 : AddCommGroup A] [inst7551_1 : Module ℂ A] [inst7551_2 : One A] [inst7551_3 : LE A] |
| [inst7551_4 : AddCommGroup B] [inst7551_5 : Module ℂ B] [inst7551_6 : One B] [inst7551_7 : LE B] |
| [inst7551_8 : Fintype ι] [inst7551_9 : DecidableEq ι] |
| (J : ObservableInstrument Bool A B) (S : ReferenceFunctional A ι) |
| (r : InstrumentRun J S) |
| |
| def bitReference (i : Bool) : Matrix ι ι ℂ := S (J.operation {i} 1) |
| |
| omit inst7551_8 inst7551_9 in |
| lemma bitReference_positive [Fintype ι] [DecidableEq ι] (hS : PositiveFunctional S) (h1 : (0 : B) ≤ 1) |
| (i : Bool) : (bitReference J S i).PosSemidef := |
| hS _ (J.positive {i} (measurableSet_singleton i) 1 h1) |
| |
| omit inst7551_9 in |
| lemma bitReference_entry [DecidableEq ι] (i : Bool) (k l : ι) : |
| bitReference J S i k l = ∫ b in {i}, r.posterior b 1 k l ∂r.law := |
| (r.update {i} (measurableSet_singleton i) 1 k l).symm |
| |
| include r in |
| theorem bitReference_sum : bitReference J S false + bitReference J S true = S 1 := by |
| ext k l |
| rw [Matrix.add_apply, bitReference_entry J S r false, |
| bitReference_entry J S r true] |
| have hd : Disjoint ({false} : Set Bool) {true} := by simp |
| have hu : ({false} : Set Bool) ∪ {true} = Set.univ := by |
| ext b; cases b <;> simp |
| rw [← setIntegral_union hd (measurableSet_singleton true) |
| (r.integrable 1 k l).integrableOn (r.integrable 1 k l).integrableOn, hu, |
| Measure.restrict_univ] |
| exact InstrumentRun.reference_mean J S r k l |
| |
| end UnrestrictedQuantum |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| namespace ZeroKey |
| |
| universe v7614_0 v7614_1 |
| |
| variable {Ω : Type v7614_0} {ι : Type v7614_1} [inst7614_0 : Fintype ι] [inst7614_1 : DecidableEq ι] |
| {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| {μ : Measure Ω} [inst7614_2 : IsFiniteMeasure μ] |
| |
| omit inst7614_1 in |
| lemma density_subdensity [DecidableEq ι] {U : Matrix ι ι ℂ} (hU : Density U) : Subdensity U := |
| ⟨hU.1,by rw [hU.2]; norm_num⟩ |
| |
| theorem reference_density_unique_on_filtration (F : Filtration ℕ mΩ) |
| (hgen : mΩ = ⨆ n, F n) |
| (U V : Ω → Matrix ι ι ℂ) |
| (hU : ∀ x, Subdensity (U x)) (hV : ∀ x, Subdensity (V x)) |
| (hmU : Measurable U) (hmV : Measurable V) |
| (hEq : ∀ n S, MeasurableSet[F n] S → |
| (∫ x in S, U x ∂μ) = ∫ x in S, V x ∂μ) : U =ᵐ[μ] V := by |
| have hUi := integrable_subdensity U hU hmU μ |
| have hVi := integrable_subdensity V hV hmV μ |
| have hUe (i j : ι) : Integrable (fun x => U x i j) μ := |
| ((Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap).integrable_comp hUi |
| have hVe (i j : ι) : Integrable (fun x => V x i j) μ := |
| ((Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap).integrable_comp hVi |
| let P := positiveMatrixMeasureOfDensity hUe |
| (Filter.Eventually.of_forall (fun x => (hU x).1)) |
| let Q := positiveMatrixMeasureOfDensity hVe |
| (Filter.Eventually.of_forall (fun x => (hV x).1)) |
| have hpq : P = Q := by |
| apply PositiveMatrixMeasure.ext_on_filtration P Q F hgen |
| intro n S hS |
| dsimp only [P,Q] |
| rw [positiveMatrixMeasureOfDensity_value hUe _ S (F.le n S hS), |
| positiveMatrixMeasureOfDensity_value hVe _ S (F.le n S hS)] |
| exact hEq n S hS |
| apply Integrable.ae_eq_of_forall_setIntegral_eq U V hUi hVi |
| intro S hS _ |
| have he := congrArg (fun P : PositiveMatrixMeasure Ω ι => P.value S) hpq |
| dsimp only [P,Q] at he |
| simpa only [positiveMatrixMeasureOfDensity_value hUe _ S hS, |
| positiveMatrixMeasureOfDensity_value hVe _ S hS] using he |
| |
| end ZeroKey |
| |
| namespace UnrestrictedQuantum |
| |
| universe v7657_0 v7657_1 v7657_2 v7657_3 |
| |
| variable {Ω : Type v7657_0} {ι : Type v7657_1} {A : Type v7657_2} {B : Type v7657_3} [inst7657_0 : Fintype ι] [inst7657_1 : DecidableEq ι] |
| {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| [inst7657_2 : AddCommGroup A] [inst7657_3 : Module ℂ A] [inst7657_4 : One A] [inst7657_5 : LE A] |
| [inst7657_6 : AddCommGroup B] [inst7657_7 : Module ℂ B] [inst7657_8 : One B] [inst7657_9 : LE B] |
| (μ : Measure Ω) (F : Filtration ℕ mΩ) |
| (U : ℕ → Ω → Matrix ι ι ℂ) |
| |
| structure IncomingObservableProcess where |
| state : Ω → ReferenceFunctional A ι |
| positive : ∀ x, PositiveFunctional (state x) |
| positive_unit : (0 : A) ≤ 1 |
| normalized : ∀ x, trace (state x 1) = 1 |
| local_measurable : Measurable[L] (fun x => state x 1) |
| causality : ∀ n S, MeasurableSet[F n] S → |
| (∫ x in S, state x 1 ∂μ) = ∫ x in S, U n x ∂μ |
| |
| namespace IncomingObservableProcess |
| |
| variable {μ F U} (e : IncomingObservableProcess (L := L) (A := A) μ F U) |
| |
| lemma reference_density (x : Ω) : ZeroKey.Density (e.state x 1) := |
| ⟨e.positive x 1 e.positive_unit,e.normalized x⟩ |
| |
| structure BitReadout where |
| instrument : Ω → ObservableInstrument Bool A B |
| run : ∀ x, InstrumentRun (instrument x) (e.state x) |
| positive_unit : (0 : B) ≤ 1 |
| local_measurable : ∀ i, Measurable[L] (fun x => bitReference (instrument x) (e.state x) i) |
| |
| namespace BitReadout |
| |
| variable {e} |
| |
| variable (b : e.BitReadout (B := B)) |
| |
| def value (i : Bool) (x : Ω) : Matrix ι ι ℂ := bitReference (b.instrument x) (e.state x) i |
| |
| lemma positive (i : Bool) (x : Ω) : (b.value i x).PosSemidef := |
| bitReference_positive (b.instrument x) (e.state x) (e.positive x) b.positive_unit i |
| |
| lemma sum (x : Ω) : b.value false x + b.value true x = e.state x 1 := |
| bitReference_sum (b.instrument x) (e.state x) (b.run x) |
| |
| lemma subdensity (i : Bool) (x : Ω) : ZeroKey.Subdensity (b.value i x) := by |
| refine ⟨b.positive i x,?_⟩ |
| have hsum := congrArg (fun M : Matrix ι ι ℂ => (trace M).re) (b.sum x) |
| rw [Matrix.trace_add,Complex.add_re,e.normalized x,Complex.one_re] at hsum |
| have h0 := (RCLike.nonneg_iff.mp (b.positive false x).trace_nonneg).1 |
| have h1 := (RCLike.nonneg_iff.mp (b.positive true x).trace_nonneg).1 |
| change 0 ≤ (trace (b.value false x)).re at h0 |
| change 0 ≤ (trace (b.value true x)).re at h1 |
| cases i <;> linarith |
| |
| lemma measurable (i : Bool) : Measurable[L] (b.value i) := b.local_measurable i |
| |
| end BitReadout |
| |
| end IncomingObservableProcess |
| |
| end UnrestrictedQuantum |
| |
| end |
| |
| namespace ZeroKey |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| universe v7730_0 v7730_1 v7730_2 v7730_3 |
| |
| variable {Ω : Type v7730_0} {T : Type v7730_1} {ι : Type v7730_2} {η : Type v7730_3} {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| [inst7730_0 : StandardBorelSpace Ω] [inst7730_1 : MeasurableSpace T] |
| [inst7730_2 : Fintype ι] [inst7730_3 : Fintype η] [inst7730_4 : DecidableEq ι] [inst7730_5 : DecidableEq η] |
| {P : Measure Ω} [inst7730_6 : IsFiniteMeasure P] |
| |
| lemma setIntegral_publicMatrix (hL : L ≤ mΩ) (U : Ω → Matrix ι ι ℂ) |
| (hU : Integrable U P) (S : Set Ω) (hS : MeasurableSet[L] S) : |
| (∫ x in S, publicMatrix L P U x ∂P) = ∫ x in S, U x ∂P := by |
| calc |
| _ = ∫ x in S, P[U | L] x ∂P := integral_congr_ae |
| (ae_restrict_of_ae (condExp_ae_eq_integral_condExpKernel hL hU).symm) |
| _ = _ := setIntegral_condExp hL hU hS |
| |
| lemma public_factor_event (r : Ω → T) (hr : Measurable r) |
| (U : Ω → Matrix ι ι ℂ) (V : T → Matrix ι ι ℂ) |
| (hU : Integrable U P) (hV : Measurable V) |
| (he : publicMatrix (MeasurableSpace.comap r inferInstance) P U =ᵐ[P] V ∘ r) |
| (S : Set T) (hS : MeasurableSet S) : |
| (∫ t in S, V t ∂P.map r) = ∫ x in r ⁻¹' S, U x ∂P := by |
| rw [setIntegral_map hS hV.aestronglyMeasurable hr.aemeasurable] |
| calc |
| _ = ∫ x in r ⁻¹' S, publicMatrix (MeasurableSpace.comap r inferInstance) P U x ∂P := |
| integral_congr_ae (ae_restrict_of_ae he.symm) |
| _ = _ := setIntegral_publicMatrix hr.comap_le U hU _ ⟨S,hS,rfl⟩ |
| |
| end |
| |
| namespace AdaptiveQuantum |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter unitInterval |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker Topology |
| |
| section |
| |
| open UnrestrictedQuantum |
| |
| universe v7771_0 v7771_1 v7771_2 v7771_3 v7771_4 v7771_5 v7771_6 v7771_7 v7771_8 v7771_9 |
| |
| variable {O : Type v7771_0} {M : Type v7771_1} {ι : Type v7771_2} {η : Type v7771_3} [inst7771_0 : MeasurableSpace O] [inst7771_1 : MeasurableSpace M] |
| [inst7771_2 : StandardBorelSpace O] [inst7771_3 : Nonempty O] [inst7771_4 : StandardBorelSpace M] [inst7771_5 : Nonempty M] |
| [inst7771_6 : Fintype ι] [inst7771_7 : Fintype η] [inst7771_8 : DecidableEq ι] [inst7771_9 : DecidableEq η] |
| {A : ℕ → Type v7771_4} {B : ℕ → Type v7771_5} |
| [inst7771_10 : ∀ n, AddCommGroup (A n)] [inst7771_11 : ∀ n, Module ℂ (A n)] [inst7771_12 : ∀ n, One (A n)] [inst7771_13 : ∀ n, LE (A n)] |
| [inst7771_14 : ∀ n, AddCommGroup (B n)] [inst7771_15 : ∀ n, Module ℂ (B n)] [inst7771_16 : ∀ n, One (B n)] [inst7771_17 : ∀ n, LE (B n)] |
| (p : AdaptiveOutcomeSampler O M) |
| (κA κB : (n : ℕ) → Kernel (LocalHistory O M n) O) |
| [inst7771_18 : ∀ n, IsMarkovKernel (κA n)] [inst7771_19 : ∀ n, IsMarkovKernel (κB n)] |
| (eA : LocalObservableExecution (ι := ι) A κA p.sendA) |
| (eB : LocalObservableExecution (ι := η) B κB p.sendB) |
| {TA : Type v7771_6} {TB : Type v7771_7} {CA : Type v7771_8} {CB : Type v7771_9} |
| [inst7771_20 : AddCommGroup TA] [inst7771_21 : Module ℂ TA] [inst7771_22 : One TA] [inst7771_23 : LE TA] |
| [inst7771_24 : AddCommGroup TB] [inst7771_25 : Module ℂ TB] [inst7771_26 : One TB] [inst7771_27 : LE TB] |
| [inst7771_28 : AddCommGroup CA] [inst7771_29 : Module ℂ CA] [inst7771_30 : One CA] [inst7771_31 : LE CA] |
| [inst7771_32 : AddCommGroup CB] [inst7771_33 : Module ℂ CB] [inst7771_34 : One CB] [inst7771_35 : LE CB] |
| (P : Measure (ℕ → O)) [inst7771_36 : IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (historyPrefix (n+1)) = |
| ((P.map (historyPrefix n)) ⊗ₘ p.instrumentKernel κA κB n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) |
| (eTA : IncomingObservableProcess (L := p.localField true) (A := TA) P historyFiltration |
| (fun n x => globalLocalReferenceA p κA eA n (historyPrefix n x))) |
| (eTB : IncomingObservableProcess (L := p.localField false) (A := TB) P historyFiltration |
| (fun n x => globalLocalReferenceB p κB eB n (historyPrefix n x))) |
| (bA : eTA.BitReadout (B := CA)) (bB : eTB.BitReadout (B := CB)) |
| |
| include hP |
| |
| omit inst7771_2 inst7771_3 inst7771_4 inst7771_5 in |
| theorem incoming_joint_reference_consistency [StandardBorelSpace O] [Nonempty O] [StandardBorelSpace M] [Nonempty M] : |
| ∀ n S, MeasurableSet[historyFiltration n] S → |
| (∫ x in S, (eTA.state x 1) ⊗ₖ (eTB.state x 1) ∂P) = |
| ∫ x in S, jointReference p κA κB eA eB n (historyPrefix n x) ∂P := by |
| obtain ⟨G,H,hGm,hHm,hG,hH,hGc,hHc,W,hW,hWc⟩ := |
| full_reference_extension p κA κB eA eB P hP |
| have hGa : (fun x => eTA.state x 1) =ᵐ[P] G := |
| reference_density_unique_on_filtration historyFiltration historyFiltration_generates |
| (fun x => eTA.state x 1) G |
| (fun x => density_subdensity (eTA.reference_density x)) |
| (fun x => density_subdensity (hG x)) |
| (eTA.local_measurable.mono (p.localField_le true) le_rfl) |
| (hGm.mono (p.localField_le true) le_rfl) |
| (fun n S hS => (eTA.causality n S hS).trans (hGc n S hS).symm) |
| have hHa : (fun x => eTB.state x 1) =ᵐ[P] H := |
| reference_density_unique_on_filtration historyFiltration historyFiltration_generates |
| (fun x => eTB.state x 1) H |
| (fun x => density_subdensity (eTB.reference_density x)) |
| (fun x => density_subdensity (hH x)) |
| (eTB.local_measurable.mono (p.localField_le false) le_rfl) |
| (hHm.mono (p.localField_le false) le_rfl) |
| (fun n S hS => (eTB.causality n S hS).trans (hHc n S hS).symm) |
| intro n S hS |
| rw [← hWc n S hS,hW S (historyFiltration.le n S hS)] |
| apply integral_congr_ae |
| filter_upwards [ae_restrict_of_ae hGa,ae_restrict_of_ae hHa] with x hx hy |
| rw [hx,hy] |
| |
| theorem genuine_terminal_public_factors |
| (hlaw : ∀ n s, ((volume : Measure I).prod volume).map |
| (fun u => p.causal.step n (s,u)) = p.instrumentKernel κA κB n s) : |
| ∃ X : Bool → (ℕ → M) → Matrix ι ι ℂ, |
| ∃ Y : Bool → (ℕ → M) → Matrix η η ℂ, |
| (∀ i, Measurable (X i)) ∧ (∀ j, Measurable (Y j)) ∧ |
| (∀ i t, Subdensity (X i t)) ∧ (∀ j t, Subdensity (Y j t)) ∧ |
| ∀ i j S, MeasurableSet S → |
| (∫ t in S, X i t ⊗ₖ Y j t ∂P.map p.publicRecord) = |
| ∫ x in p.publicRecord ⁻¹' S, bA.value i x ⊗ₖ bB.value j x ∂P := by |
| obtain ⟨X,Y,hXm,hYm,hXp,hYp,hXY⟩ := terminal_public_factors p.publicRecord |
| p.measurable_publicRecord (p.localField_le true) (p.localField_le false) |
| (p.localFields_independent (p.instrumentKernel κA κB) hlaw P hP) |
| bA.value bB.value bA.subdensity bB.subdensity bA.measurable bB.measurable |
| refine ⟨X,Y,hXm,hYm,hXp,hYp,?_⟩ |
| intro i j S hS |
| exact public_factor_event p.publicRecord p.measurable_publicRecord |
| (fun x => bA.value i x ⊗ₖ bB.value j x) (fun t => X i t ⊗ₖ Y j t) |
| (integrable_subdensity _ (fun x => subdensity_kronecker (bA.subdensity i x) (bB.subdensity j x)) |
| (measurable_matrix_kronecker ((bA.measurable i).mono (p.localField_le true) le_rfl) |
| ((bB.measurable j).mono (p.localField_le false) le_rfl)) P) |
| (measurable_matrix_kronecker (hXm i) (hYm j)) (hXY i j) S hS |
|
|
| end |
|
|
| open UnrestrictedQuantum |
|
|
| universe v7869_0 v7869_1 v7869_2 v7869_3 v7869_4 v7869_5 v7869_6 v7869_7 v7869_8 v7869_9 |
|
|
| variable {O : Type v7869_0} {M : Type v7869_1} {ι : Type v7869_2} {η : Type v7869_3} [inst7869_0 : MeasurableSpace O] [inst7869_1 : MeasurableSpace M] |
| [inst7869_2 : StandardBorelSpace O] [inst7869_3 : Nonempty O] [inst7869_4 : StandardBorelSpace M] [inst7869_5 : Nonempty M] |
| [inst7869_6 : Fintype ι] [inst7869_7 : Fintype η] [inst7869_8 : DecidableEq ι] [inst7869_9 : DecidableEq η] |
| {A : ℕ → Type v7869_4} {B : ℕ → Type v7869_5} |
| [inst7869_10 : ∀ n, AddCommGroup (A n)] [inst7869_11 : ∀ n, Module ℂ (A n)] [inst7869_12 : ∀ n, One (A n)] [inst7869_13 : ∀ n, LE (A n)] |
| [inst7869_14 : ∀ n, AddCommGroup (B n)] [inst7869_15 : ∀ n, Module ℂ (B n)] [inst7869_16 : ∀ n, One (B n)] [inst7869_17 : ∀ n, LE (B n)] |
| (p : AdaptiveOutcomeSampler O M) |
| (κA κB : (n : ℕ) → Kernel (LocalHistory O M n) O) |
| [inst7869_18 : ∀ n, IsMarkovKernel (κA n)] [inst7869_19 : ∀ n, IsMarkovKernel (κB n)] |
| (eA : LocalObservableExecution (ι := ι) A κA p.sendA) |
| (eB : LocalObservableExecution (ι := η) B κB p.sendB) |
| {TA : Type v7869_6} {TB : Type v7869_7} {CA : Type v7869_8} {CB : Type v7869_9} |
| [inst7869_20 : AddCommGroup TA] [inst7869_21 : Module ℂ TA] [inst7869_22 : One TA] [inst7869_23 : LE TA] |
| [inst7869_24 : AddCommGroup TB] [inst7869_25 : Module ℂ TB] [inst7869_26 : One TB] [inst7869_27 : LE TB] |
| [inst7869_28 : AddCommGroup CA] [inst7869_29 : Module ℂ CA] [inst7869_30 : One CA] [inst7869_31 : LE CA] |
| [inst7869_32 : AddCommGroup CB] [inst7869_33 : Module ℂ CB] [inst7869_34 : One CB] [inst7869_35 : LE CB] |
| (P : Measure (ℕ → O)) [inst7869_36 : IsProbabilityMeasure P] |
| (hP : ∀ n, P.map (historyPrefix (n+1)) = |
| ((P.map (historyPrefix n)) ⊗ₘ p.instrumentKernel κA κB n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2)) |
| (eTA : IncomingObservableProcess (L := p.localField true) (A := TA) P historyFiltration |
| (fun n x => globalLocalReferenceA p κA eA n (historyPrefix n x))) |
| (eTB : IncomingObservableProcess (L := p.localField false) (A := TB) P historyFiltration |
| (fun n x => globalLocalReferenceB p κB eB n (historyPrefix n x))) |
| (bA : eTA.BitReadout (B := CA)) (bB : eTB.BitReadout (B := CB)) |
|
|
| include hP |
|
|
| theorem terminal_reference_total : |
| (∫ x, bA.value false x ⊗ₖ bB.value false x ∂P) + |
| (∫ x, bA.value false x ⊗ₖ bB.value true x ∂P) + |
| (∫ x, bA.value true x ⊗ₖ bB.value false x ∂P) + |
| (∫ x, bA.value true x ⊗ₖ bB.value true x ∂P) = |
| jointReference p κA κB eA eB 0 Fin.elim0 := by |
| have hi (i j : Bool) : Integrable (fun x => bA.value i x ⊗ₖ bB.value j x) P := |
| integrable_subdensity _ (fun x => subdensity_kronecker (bA.subdensity i x) (bB.subdensity j x)) |
| (measurable_matrix_kronecker ((bA.measurable i).mono (p.localField_le true) le_rfl) |
| ((bB.measurable j).mono (p.localField_le false) le_rfl)) P |
| have h2 := (integral_add ((hi false false).add (hi false true)) (hi true false)).symm |
| have h3 := (integral_add (((hi false false).add (hi false true)).add (hi true false)) (hi true true)).symm |
| simp only [Pi.add_apply] at h2 h3 |
| rw [← integral_add (hi false false) (hi false true),h2,h3] |
| have hs (x : ℕ → O) : bA.value false x ⊗ₖ bB.value false x + |
| bA.value false x ⊗ₖ bB.value true x + bA.value true x ⊗ₖ bB.value false x + |
| bA.value true x ⊗ₖ bB.value true x = eTA.state x 1 ⊗ₖ eTB.state x 1 := by |
| rw [← bA.sum x,← bB.sum x,Matrix.add_kronecker,Matrix.kronecker_add,Matrix.kronecker_add] |
| abel |
| simp_rw [hs] |
| have hc := incoming_joint_reference_consistency p κA κB eA eB P hP eTA eTB |
| 0 Set.univ MeasurableSet.univ |
| simp only [Measure.restrict_univ] at hc |
| rw [hc] |
| have he (x : ℕ → O) : historyPrefix 0 x = Fin.elim0 := Subsingleton.elim _ _ |
| simp_rw [he] |
| simp |
|
|
| theorem terminal_public_normalization |
| (hlaw : ∀ n s, ((volume : Measure I).prod volume).map |
| (fun u => p.causal.step n (s,u)) = p.instrumentKernel κA κB n s) : |
| ∃ X : Bool → (ℕ → M) → Matrix ι ι ℂ, |
| ∃ Y : Bool → (ℕ → M) → Matrix η η ℂ, |
| (∀ i, Measurable (X i)) ∧ (∀ j, Measurable (Y j)) ∧ |
| (∀ i t, Subdensity (X i t)) ∧ (∀ j t, Subdensity (Y j t)) ∧ |
| (∀ i j S, MeasurableSet S → |
| (∫ t in S, X i t ⊗ₖ Y j t ∂P.map p.publicRecord) = |
| ∫ x in p.publicRecord ⁻¹' S, bA.value i x ⊗ₖ bB.value j x ∂P) ∧ |
| (∫ t, X false t ⊗ₖ Y false t ∂P.map p.publicRecord) + |
| (∫ t, X false t ⊗ₖ Y true t ∂P.map p.publicRecord) + |
| (∫ t, X true t ⊗ₖ Y false t ∂P.map p.publicRecord) + |
| (∫ t, X true t ⊗ₖ Y true t ∂P.map p.publicRecord) = |
| jointReference p κA κB eA eB 0 Fin.elim0 := by |
| obtain ⟨X,Y,hXm,hYm,hX,hY,hXY⟩ := genuine_terminal_public_factors |
| p κA κB eA eB P hP eTA eTB bA bB hlaw |
| refine ⟨X,Y,hXm,hYm,hX,hY,hXY,?_⟩ |
| have ht (i j : Bool) := hXY i j Set.univ MeasurableSet.univ |
| simp only [Measure.restrict_univ,Set.preimage_univ] at ht |
| simp_rw [ht] |
| exact terminal_reference_total p κA κB eA eB P hP eTA eTB bA bB |
| |
| end AdaptiveQuantum |
| |
| section |
| |
| open Matrix |
| |
| open scoped ComplexOrder MatrixOrder Kronecker |
| |
| universe v7966_0 v7966_1 |
| |
| variable {ι : Type v7966_0} {η : Type v7966_1} [inst7966_0 : Fintype ι] [inst7966_1 : Fintype η] [inst7966_2 : DecidableEq ι] [inst7966_3 : DecidableEq η] |
| |
| lemma localProbe_reference : |
| keepReference (outer (localProbe (ι := ι)) localProbe) = |
| (Fintype.card ι : ℂ)⁻¹ • (1 : Matrix ι ι ℂ) := by |
| rw [localProbe,keepReference_vectorize] |
| simp only [Matrix.conjTranspose_smul,Matrix.conjTranspose_one, |
| Matrix.smul_mul,Matrix.mul_smul,one_mul,Matrix.transpose_smul,Matrix.transpose_one] |
| have hc : star (((Real.sqrt (Fintype.card ι : ℝ))⁻¹ : ℂ)) * |
| ((Real.sqrt (Fintype.card ι : ℝ))⁻¹ : ℂ) = (Fintype.card ι : ℂ)⁻¹ := by |
| simp only [map_inv₀,Complex.star_def,Complex.conj_ofReal] |
| rw [← mul_inv,← Complex.ofReal_mul,Real.mul_self_sqrt (Nat.cast_nonneg _)] |
| simp |
| rw [smul_smul,mul_comm,hc] |
| |
| lemma localProbe_reference_product : |
| keepReference (outer (localProbe (ι := ι)) localProbe) ⊗ₖ |
| keepReference (outer (localProbe (ι := η)) localProbe) = |
| keepReference (outer (localProbe (ι := ι × η)) localProbe) := by |
| simp only [localProbe_reference,Matrix.smul_kronecker,Matrix.kronecker_smul, |
| Matrix.one_kronecker_one,smul_smul,Fintype.card_prod,Nat.cast_mul,mul_inv] |
| rw [mul_comm] |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Function unitInterval |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| open UnrestrictedQuantum |
| |
| universe v8064_0 v8064_1 |
| |
| structure Discussion (O : Type v8064_0) (M : Type v8064_1) [MeasurableSpace O] [MeasurableSpace M] where |
| alice : (n : ℕ) → (Fin n → M) → Bool |
| alice_measurable : ∀ n, Measurable (alice n) |
| kernelA : (n : ℕ) → Kernel (LocalHistory O M n) O |
| kernelB : (n : ℕ) → Kernel (LocalHistory O M n) O |
| markovA : ∀ n, IsMarkovKernel (kernelA n) |
| markovB : ∀ n, IsMarkovKernel (kernelB n) |
| sendA : (n : ℕ) → LocalHistory O M n × O → M |
| sendB : (n : ℕ) → LocalHistory O M n × O → M |
| sendA_measurable : ∀ n, Measurable (sendA n) |
| sendB_measurable : ∀ n, Measurable (sendB n) |
| |
| namespace Discussion |
| |
| universe v8077_0 v8077_1 |
| |
| variable {O : Type v8077_0} {M : Type v8077_1} [inst8077_0 : MeasurableSpace O] [inst8077_1 : MeasurableSpace M] |
| [inst8077_2 : StandardBorelSpace O] [inst8077_3 : Nonempty O] (d : Discussion O M) |
| |
| attribute [instance] markovA markovB |
| |
| def sampler : AdaptiveOutcomeSampler O M := by |
| have sample (n : ℕ) (κ : Kernel (LocalHistory O M n) O) [IsMarkovKernel κ] : |
| ∃ f : LocalHistory O M n → I → O, Measurable (uncurry f) ∧ |
| (∀ h, volume.map (f h) = κ h) ∧ |
| ∀ (μ : Measure (LocalHistory O M n)) [IsFiniteMeasure μ], |
| (μ.prod (volume : Measure I)).map (fun p => (p.1, f p.1 p.2)) = μ ⊗ₘ κ := by |
| obtain ⟨f, hf, hfLaw⟩ := κ.exists_measurable_map_eq_unitInterval |
| change Measurable (fun pair : LocalHistory O M n × I => f pair.1 pair.2) at hf |
| refine ⟨f, hf, hfLaw, ?_⟩ |
| intro μ hμ |
| ext B hB |
| rw [Measure.map_apply (measurable_fst.prodMk hf) hB, |
| Measure.prod_apply (hB.preimage (measurable_fst.prodMk hf)), |
| Measure.compProd_apply hB] |
| congr 1 |
| funext h |
| rw [← hfLaw h, Measure.map_apply hf.of_uncurry_left (measurable_prodMk_left hB)] |
| rfl |
| exact { |
| alice := d.alice |
| alice_meas := d.alice_measurable |
| sampleA n := uncurry (Classical.choose (sample n (d.kernelA n))) |
| sampleB n := uncurry (Classical.choose (sample n (d.kernelB n))) |
| sendA := d.sendA |
| sendB := d.sendB |
| sampleA_meas n := (Classical.choose_spec (sample n (d.kernelA n))).1 |
| sampleB_meas n := (Classical.choose_spec (sample n (d.kernelB n))).1 |
| sendA_meas := d.sendA_measurable |
| sendB_meas := d.sendB_measurable } |
| |
| lemma sampler_law : ∀ n s, ((volume : Measure I).prod volume).map |
| (fun u => d.sampler.causal.step n (s,u)) = |
| d.sampler.instrumentKernel d.kernelA d.kernelB n s := by |
| apply d.sampler.causal_step_law |
| · intro n s |
| exact (Classical.choose_spec (sample_instrument_kernel (d.kernelA n))).2.1 s |
| · intro n s |
| exact (Classical.choose_spec (sample_instrument_kernel (d.kernelB n))).2.1 s |
| |
| def probeLaw : Measure (ℕ → O) := |
| (noiseTapeLaw ((volume : Measure I).prod volume)).map d.sampler.causalRecord |
| |
| instance probeLaw_probability : IsProbabilityMeasure d.probeLaw := |
| inferInstanceAs (IsProbabilityMeasure ((noiseTapeLaw ((volume : Measure I).prod volume)).map d.sampler.causal.record)) |
| |
| lemma probeLaw_prefix (n : ℕ) : d.probeLaw.map (historyPrefix (n+1)) = |
| ((d.probeLaw.map (historyPrefix n)) ⊗ₘ |
| d.sampler.instrumentKernel d.kernelA d.kernelB n).map |
| (fun pair : (Fin n → O) × O => Fin.snoc (α := fun _ : Fin (n+1) => O) pair.1 pair.2) := by |
| have he (k : ℕ) : historyPrefix k ∘ d.sampler.causal.record = |
| d.sampler.causal.history k := by |
| funext u i |
| exact (d.sampler.causal.prefix_eq_record k u i).symm |
| simp only [probeLaw, AdaptiveOutcomeSampler.causalRecord_eq, Measure.map_map (measurable_historyPrefix _) d.sampler.causal.measurable_record,he] |
| exact d.sampler.causal.prefix_law_succ _ d.sampler_law n |
| |
| def transcriptLaw : Measure (ℕ → M) := d.probeLaw.map d.sampler.publicRecord |
| |
| instance transcriptLaw_probability : IsProbabilityMeasure d.transcriptLaw := |
| inferInstanceAs (IsProbabilityMeasure (d.probeLaw.map d.sampler.publicRecord)) |
| |
| end Discussion |
| |
| end |
| |
| section |
| |
| open scoped ComplexOrder MatrixOrder Kronecker |
| |
| open Matrix |
| |
| universe v8144_0 v8144_1 |
| |
| variable {ι : Type v8144_0} {κ : Type v8144_1} [inst8144_0 : Fintype ι] [inst8144_1 : Fintype κ] [inst8144_2 : DecidableEq ι] [inst8144_3 : DecidableEq κ] |
| |
| lemma preparationFilter_product (R : Matrix (ι × κ) (ι × κ) ℂ) |
| (U : Matrix ι ι ℂ) (V : Matrix κ κ ℂ) : |
| preparationFilter R * (U ⊗ₖ V) * (preparationFilter R)ᴴ = |
| (CFC.sqrt R * (((Fintype.card ι : ℂ) • Uᵀ) ⊗ₖ ((Fintype.card κ : ℂ) • Vᵀ)) * CFC.sqrt R)ᵀ := by |
| have hs : (CFC.sqrt R)ᴴ = CFC.sqrt R := (CFC.sqrt_nonneg R).posSemidef.isHermitian.eq |
| have ht : ((CFC.sqrt R)ᵀ)ᴴ = (CFC.sqrt R)ᵀ := by |
| rw [Matrix.conjTranspose_transpose_eq_transpose_conjTranspose,hs] |
| have hc : (Real.sqrt (Fintype.card (ι × κ) : ℝ) : ℂ) * |
| (Real.sqrt (Fintype.card (ι × κ) : ℝ) : ℂ) = |
| (Fintype.card ι : ℂ)*(Fintype.card κ : ℂ) := by |
| rw [← Complex.ofReal_mul,Real.mul_self_sqrt (Nat.cast_nonneg _), |
| Fintype.card_prod,Nat.cast_mul] |
| simp |
| unfold preparationFilter |
| simp only [Matrix.conjTranspose_smul,Complex.star_def,Complex.conj_ofReal,ht, |
| smul_mul_assoc,mul_smul_comm,smul_smul,Matrix.transpose_mul, |
| ← Matrix.kroneckerMap_transpose,Matrix.transpose_smul,Matrix.transpose_transpose, |
| Matrix.smul_kronecker,Matrix.kronecker_smul] |
| rw [hc] |
| congr 1 |
| · ring |
| · exact Matrix.mul_assoc _ _ _ |
| |
| end |
| |
| section |
| |
| open scoped MatrixOrder ComplexOrder Kronecker |
| |
| open Matrix |
| |
| universe v8360_0 |
| |
| def eveBlock {ι : Type v8360_0} [inst8360_0 : Fintype ι] [inst8360_1 : DecidableEq ι] |
| (R D : Matrix ι ι ℂ) : Matrix ι ι ℂ := (CFC.sqrt R * D * CFC.sqrt R)ᵀ |
| |
| open MeasureTheory |
| |
| open scoped Matrix.Norms.L2Operator |
| |
| universe v8632_0 v8632_1 |
| |
| variable {ι : Type v8632_0} {Ω : Type v8632_1} [inst8632_0 : Fintype ι] [inst8632_1 : DecidableEq ι] [inst8632_2 : MeasurableSpace Ω] |
| |
| universe v8637_0 |
| |
| structure BitDensity (μ : Measure Ω) (ι : Type v8637_0) [Fintype ι] where |
| block : Bool → Bool → Ω → Matrix ι ι ℂ |
| positive : ∀ i j t, (block i j t).PosSemidef |
| measurable : ∀ i j, Measurable (block i j) |
| integrable : ∀ i j, Integrable (fun t => (trace (block i j t)).re) μ |
| normalized : (∫ t, (trace (block false false t)).re ∂μ) + |
| (∫ t, (trace (block false true t)).re ∂μ) + |
| (∫ t, (trace (block true false t)).re ∂μ) + |
| (∫ t, (trace (block true true t)).re ∂μ) = 1 |
| |
| def BitDensity.mass {μ : Measure Ω} (τ : BitDensity μ ι) (i j : Bool) : ℝ := |
| ∫ t, (trace (τ.block i j t)).re ∂μ |
| |
| def BitDensity.idealBitError {μ : Measure Ω} (τ : BitDensity μ ι) |
| (σ : Ω → Matrix ι ι ℂ) : ℝ := |
| τ.mass false true + τ.mass true false + |
| (∫ t, traceNorm (τ.block false false t - (1/2 : ℝ) • σ t) ∂μ) + |
| (∫ t, traceNorm (τ.block true true t - (1/2 : ℝ) • σ t) ∂μ) |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| section MatrixFiltering |
| |
| universe v8879_0 v8879_1 v8879_2 |
| |
| variable {ι : Type v8879_0} {η : Type v8879_1} {Ω : Type v8879_2} [inst8879_0 : Fintype ι] [inst8879_1 : Fintype η] [inst8879_2 : DecidableEq ι] [inst8879_3 : DecidableEq η] |
| [inst8879_4 : MeasurableSpace Ω] {μ : Measure Ω} |
| |
| def matrixFilterLinear (K : Matrix η ι ℂ) : Matrix ι ι ℂ →ₗ[ℂ] Matrix η η ℂ where |
| toFun U := K * U * Kᴴ |
| map_add' U V := by rw [Matrix.mul_add,Matrix.add_mul] |
| map_smul' c U := by simp only [Matrix.mul_smul,Matrix.smul_mul,RingHom.id_apply] |
| |
| lemma integral_filter (K : Matrix η ι ℂ) {U : Ω → Matrix ι ι ℂ} |
| (hi : Integrable U μ) : |
| (∫ x, K * U x * Kᴴ ∂μ) = K * (∫ x, U x ∂μ) * Kᴴ := |
| (matrixFilterLinear K).toContinuousLinearMap.integral_comp_comm hi |
| |
| lemma integrable_filter (K : Matrix η ι ℂ) {U : Ω → Matrix ι ι ℂ} |
| (hi : Integrable U μ) : Integrable (fun x => K * U x * Kᴴ) μ := |
| (matrixFilterLinear K).toContinuousLinearMap.integrable_comp hi |
| |
| lemma integral_realTrace {U : Ω → Matrix ι ι ℂ} (hi : Integrable U μ) : |
| (∫ x, (trace (U x)).re ∂μ) = (trace (∫ x, U x ∂μ)).re := by |
| let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.traceLinearMap ι ℂ ℂ).toContinuousLinearMap |
| change (∫ x, RCLike.re (L (U x)) ∂μ) = (L (∫ x,U x ∂μ)).re |
| rw [integral_re (L.integrable_comp hi)] |
| exact congrArg Complex.re (L.integral_comp_comm hi) |
| |
| lemma preparationFilter_probe_reference [Nonempty ι] |
| (R : Matrix ι ι ℂ) (hR : R.PosSemidef) : |
| preparationFilter R * keepReference (outer (localProbe (ι := ι)) localProbe) * |
| (preparationFilter R)ᴴ = Rᵀ := by |
| rw [← keepReference_filter,preparation_filter_identity,canonical_reference R hR] |
| |
| end MatrixFiltering |
| |
| universe v8912_0 v8912_1 v8912_2 |
| |
| variable {ι : Type v8912_0} {η : Type v8912_1} {T : Type v8912_2} [inst8912_0 : Fintype ι] [inst8912_1 : Fintype η] [inst8912_2 : DecidableEq ι] [inst8912_3 : DecidableEq η] |
| [inst8912_4 : Nonempty ι] [inst8912_5 : Nonempty η] [inst8912_6 : MeasurableSpace T] |
| (μ : Measure T) [inst8912_7 : IsFiniteMeasure μ] |
| (X : Bool → T → Matrix ι ι ℂ) (Y : Bool → T → Matrix η η ℂ) |
| (hXm : ∀ i, Measurable (X i)) (hYm : ∀ j, Measurable (Y j)) |
| (hX : ∀ i t, Subdensity (X i t)) (hY : ∀ j t, Subdensity (Y j t)) |
| (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| |
| omit inst8912_4 inst8912_5 in |
| include hXm hYm hX hY in |
| lemma public_product_integrable [Nonempty ι] [Nonempty η] (i j : Bool) : Integrable (fun t => X i t ⊗ₖ Y j t) μ := |
| integrable_subdensity _ (fun t => subdensity_kronecker (hX i t) (hY j t)) |
| (measurable_matrix_kronecker (hXm i) (hYm j)) μ |
| |
| def filteredPublicDensity |
| (hInit : (∫ t, X false t ⊗ₖ Y false t ∂μ) + |
| (∫ t, X false t ⊗ₖ Y true t ∂μ) + |
| (∫ t, X true t ⊗ₖ Y false t ∂μ) + |
| (∫ t, X true t ⊗ₖ Y true t ∂μ) = |
| keepReference (outer (localProbe (ι := ι × η)) localProbe)) : BitDensity μ (ι × η) where |
| block i j t := preparationFilter R * (X i t ⊗ₖ Y j t) * (preparationFilter R)ᴴ |
| positive i j t := ((hX i t).1.kronecker (hY j t).1).mul_mul_conjTranspose_same _ |
| measurable i j := (matrixFilterLinear (preparationFilter R)).toContinuousLinearMap.measurable.comp |
| (measurable_matrix_kronecker (hXm i) (hYm j)) |
| integrable i j := by |
| let L : Matrix (ι × η) (ι × η) ℂ →L[ℂ] ℂ := |
| (Matrix.traceLinearMap (ι × η) ℂ ℂ).toContinuousLinearMap |
| exact (L.integrable_comp (integrable_filter _ (public_product_integrable μ X Y hXm hYm hX hY i j))).re |
| normalized := by |
| have hi (i j : Bool) := integrable_filter (preparationFilter R) |
| (public_product_integrable μ X Y hXm hYm hX hY i j) |
| rw [integral_realTrace (hi false false),integral_realTrace (hi false true), |
| integral_realTrace (hi true false),integral_realTrace (hi true true)] |
| simp_rw [integral_filter _ (public_product_integrable μ X Y hXm hYm hX hY _ _)] |
| rw [← Complex.add_re,← Matrix.trace_add,← Complex.add_re,← Matrix.trace_add, |
| ← Complex.add_re,← Matrix.trace_add] |
| rw [← Matrix.add_mul,← Matrix.mul_add,← Matrix.add_mul,← Matrix.mul_add, |
| ← Matrix.add_mul,← Matrix.mul_add,hInit,preparationFilter_probe_reference R hR.1, |
| Matrix.trace_transpose,hR.2] |
| rfl |
| |
| lemma filteredPublicDensity_common_factors |
| (hInit : (∫ t, X false t ⊗ₖ Y false t ∂μ) + |
| (∫ t, X false t ⊗ₖ Y true t ∂μ) + |
| (∫ t, X true t ⊗ₖ Y false t ∂μ) + |
| (∫ t, X true t ⊗ₖ Y true t ∂μ) = |
| keepReference (outer (localProbe (ι := ι × η)) localProbe)) (i j : Bool) (t : T) : |
| (filteredPublicDensity μ X Y hXm hYm hX hY R hR hInit).block i j t = |
| eveBlock R (((Fintype.card ι : ℂ) • (X i t)ᵀ) ⊗ₖ ((Fintype.card η : ℂ) • (Y j t)ᵀ)) := |
| preparationFilter_product R (X i t) (Y j t) |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Function unitInterval Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| open UnrestrictedQuantum |
| |
| universe v8979_0 v8979_1 v8979_2 v8979_3 v8979_4 v8979_5 v8979_6 v8979_7 v8979_8 v8979_9 |
| |
| variable {O : Type v8979_0} {M : Type v8979_1} {ι : Type v8979_2} {η : Type v8979_3} [inst8979_0 : MeasurableSpace O] [inst8979_1 : MeasurableSpace M] |
| [inst8979_2 : StandardBorelSpace O] [inst8979_3 : Nonempty O] [inst8979_4 : StandardBorelSpace M] [inst8979_5 : Nonempty M] |
| [inst8979_6 : Fintype ι] [inst8979_7 : Fintype η] [inst8979_8 : DecidableEq ι] [inst8979_9 : DecidableEq η] |
| (d : Discussion O M) |
| (A : ℕ → Type v8979_4) (B : ℕ → Type v8979_5) |
| [inst8979_10 : ∀ n, AddCommGroup (A n)] [inst8979_11 : ∀ n, Module ℂ (A n)] [inst8979_12 : ∀ n, One (A n)] [inst8979_13 : ∀ n, LE (A n)] |
| [inst8979_14 : ∀ n, AddCommGroup (B n)] [inst8979_15 : ∀ n, Module ℂ (B n)] [inst8979_16 : ∀ n, One (B n)] [inst8979_17 : ∀ n, LE (B n)] |
| (TA : Type v8979_6) (TB : Type v8979_7) (CA : Type v8979_8) (CB : Type v8979_9) |
| [inst8979_18 : AddCommGroup TA] [inst8979_19 : Module ℂ TA] [inst8979_20 : One TA] [inst8979_21 : LE TA] |
| [inst8979_22 : AddCommGroup TB] [inst8979_23 : Module ℂ TB] [inst8979_24 : One TB] [inst8979_25 : LE TB] |
| [inst8979_26 : AddCommGroup CA] [inst8979_27 : Module ℂ CA] [inst8979_28 : One CA] [inst8979_29 : LE CA] |
| [inst8979_30 : AddCommGroup CB] [inst8979_31 : Module ℂ CB] [inst8979_32 : One CB] [inst8979_33 : LE CB] |
| |
| structure BitProtocol where |
| executionA : LocalObservableExecution (ι := ι) A d.kernelA d.sendA |
| executionB : LocalObservableExecution (ι := η) B d.kernelB d.sendB |
| initialA : executionA.reference 0 (Fin.elim0,Fin.elim0) = |
| keepReference (outer (localProbe (ι := ι)) localProbe) |
| initialB : executionB.reference 0 (Fin.elim0,Fin.elim0) = |
| keepReference (outer (localProbe (ι := η)) localProbe) |
| incomingA : IncomingObservableProcess (L := d.sampler.localField true) (A := TA) |
| d.probeLaw historyFiltration |
| (fun n x => AdaptiveQuantum.globalLocalReferenceA d.sampler d.kernelA executionA n (historyPrefix n x)) |
| incomingB : IncomingObservableProcess (L := d.sampler.localField false) (A := TB) |
| d.probeLaw historyFiltration |
| (fun n x => AdaptiveQuantum.globalLocalReferenceB d.sampler d.kernelB executionB n (historyPrefix n x)) |
| readoutA : incomingA.BitReadout (B := CA) |
| readoutB : incomingB.BitReadout (B := CB) |
| |
| variable {d A B TA TB CA CB} |
| |
| namespace BitProtocol |
| |
| variable (p : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB) |
| |
| def completeReference (i j : Bool) (x : ℕ → O) : Matrix (ι × η) (ι × η) ℂ := |
| p.readoutA.value i x ⊗ₖ p.readoutB.value j x |
| |
| omit inst8979_4 inst8979_5 in |
| lemma completeReference_positive [StandardBorelSpace M] [Nonempty M] (i j : Bool) (x : ℕ → O) : |
| (p.completeReference i j x).PosSemidef := |
| (p.readoutA.positive i x).kronecker (p.readoutB.positive j x) |
| |
| omit inst8979_4 inst8979_5 in |
| lemma completeReference_measurable [StandardBorelSpace M] [Nonempty M] (i j : Bool) : Measurable (p.completeReference i j) := |
| measurable_matrix_kronecker |
| ((p.readoutA.measurable i).mono (d.sampler.localField_le true) le_rfl) |
| ((p.readoutB.measurable j).mono (d.sampler.localField_le false) le_rfl) |
| |
| lemma completeReference_integrable (i j : Bool) : Integrable (p.completeReference i j) d.probeLaw := |
| integrable_subdensity _ |
| (fun x => subdensity_kronecker (p.readoutA.subdensity i x) (p.readoutB.subdensity j x)) |
| (p.completeReference_measurable i j) d.probeLaw |
| |
| lemma completeReference_entry_integrable (i j : Bool) (k l : ι × η) : |
| Integrable (fun x => p.completeReference i j x k l) d.probeLaw := |
| ((Matrix.entryLinearMap ℂ ℂ k l).toContinuousLinearMap).integrable_comp |
| (p.completeReference_integrable i j) |
| |
| def probeOutput (i j : Bool) : PositiveMatrixMeasure (ℕ → M) (ι × η) := |
| (positiveMatrixMeasureOfDensity (p.completeReference_entry_integrable i j) |
| (Eventually.of_forall (p.completeReference_positive i j))).pushforward |
| d.sampler.publicRecord d.sampler.measurable_publicRecord |
| |
| lemma probeOutput_event (i j : Bool) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.probeOutput i j).value S = |
| ∫ x in d.sampler.publicRecord ⁻¹' S, p.completeReference i j x ∂d.probeLaw := by |
| rw [probeOutput,PositiveMatrixMeasure.pushforward_value _ _ _ S hS, |
| positiveMatrixMeasureOfDensity_value _ _ _ (d.sampler.measurable_publicRecord hS)] |
|
|
| omit inst8979_4 inst8979_5 in |
| lemma initial_joint_reference [StandardBorelSpace M] [Nonempty M] : |
| AdaptiveQuantum.jointReference d.sampler d.kernelA d.kernelB p.executionA p.executionB |
| 0 Fin.elim0 = keepReference (outer (localProbe (ι := ι × η)) localProbe) := by |
| unfold AdaptiveQuantum.jointReference AdaptiveQuantum.globalLocalReferenceA |
| AdaptiveQuantum.globalLocalReferenceB |
| have ha : (d.sampler.extractPrivate true 0 Fin.elim0,d.sampler.publicFrom 0 Fin.elim0) = |
| (Fin.elim0,Fin.elim0) := Subsingleton.elim _ _ |
| have hb : (d.sampler.extractPrivate false 0 Fin.elim0,d.sampler.publicFrom 0 Fin.elim0) = |
| (Fin.elim0,Fin.elim0) := Subsingleton.elim _ _ |
| rw [ha,hb] |
| change p.executionA.reference 0 (Fin.elim0,Fin.elim0) ⊗ₖ |
| p.executionB.reference 0 (Fin.elim0,Fin.elim0) = _ |
| rw [p.initialA,p.initialB,localProbe_reference_product] |
|
|
| theorem public_factors : |
| ∃ X : Bool → (ℕ → M) → Matrix ι ι ℂ, |
| ∃ Y : Bool → (ℕ → M) → Matrix η η ℂ, |
| (∀ i, Measurable (X i)) ∧ (∀ j, Measurable (Y j)) ∧ |
| (∀ i t, Subdensity (X i t)) ∧ (∀ j t, Subdensity (Y j t)) ∧ |
| (∀ i j S, MeasurableSet S → (p.probeOutput i j).value S = |
| ∫ t in S, X i t ⊗ₖ Y j t ∂d.transcriptLaw) ∧ |
| (∫ t, X false t ⊗ₖ Y false t ∂d.transcriptLaw) + |
| (∫ t, X false t ⊗ₖ Y true t ∂d.transcriptLaw) + |
| (∫ t, X true t ⊗ₖ Y false t ∂d.transcriptLaw) + |
| (∫ t, X true t ⊗ₖ Y true t ∂d.transcriptLaw) = |
| keepReference (outer (localProbe (ι := ι × η)) localProbe) := by |
| obtain ⟨X,Y,hXm,hYm,hX,hY,hXY,hn⟩ := AdaptiveQuantum.terminal_public_normalization |
| d.sampler d.kernelA d.kernelB p.executionA p.executionB d.probeLaw d.probeLaw_prefix |
| p.incomingA p.incomingB p.readoutA p.readoutB d.sampler_law |
| refine ⟨X,Y,hXm,hYm,hX,hY,?_,hn.trans p.initial_joint_reference⟩ |
| intro i j S hS |
| exact (p.probeOutput_event i j S hS).trans (hXY i j S hS).symm |
|
|
| def canonicalOutput (R : Matrix (ι × η) (ι × η) ℂ) (i j : Bool) : |
| PositiveMatrixMeasure (ℕ → M) (ι × η) := |
| (p.probeOutput i j).filter (preparationFilter R) |
|
|
| end BitProtocol |
| |
| end |
|
|
| namespace PositiveMatrixMeasure |
|
|
| open MeasureTheory Matrix Filter |
|
|
| open scoped Matrix.Norms.L2Operator ComplexOrder MatrixOrder |
|
|
| universe v9237_0 v9237_1 |
|
|
| variable {Ω : Type v9237_0} {ι : Type v9237_1} [inst9237_0 : MeasurableSpace Ω] [inst9237_1 : Fintype ι] [inst9237_2 : DecidableEq ι] |
|
|
| def positiveDensity (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) (t : Ω) : Matrix ι ι ℂ := |
| by classical exact if (W.density μ t).PosSemidef then W.density μ t else 0 |
|
|
| omit inst9237_2 in |
| lemma positiveDensity_pos [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) (t : Ω) : |
| (W.positiveDensity μ t).PosSemidef := by |
| unfold positiveDensity |
| split |
| · assumption |
| · exact Matrix.PosSemidef.zero |
|
|
| lemma measurable_positiveDensity (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) : |
| Measurable (W.positiveDensity μ) := by |
| have hm : MeasurableSet {t | (W.density μ t).PosSemidef} := by |
| have he : {t | (W.density μ t).PosSemidef} = (W.density μ) ⁻¹' Set.Ici 0 := by |
| ext t |
| exact Matrix.nonneg_iff_posSemidef.symm |
| rw [he] |
| exact (W.measurable_density μ) measurableSet_Ici |
| exact (W.measurable_density μ).ite hm measurable_const |
| |
| lemma positiveDensity_ae (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ S, MeasurableSet S → μ S=0 → W.value S=0) : |
| W.positiveDensity μ =ᵐ[μ] W.density μ := by |
| filter_upwards [density_posSemidef_ae W μ hAC] with t ht |
| exact ite_eq_left ht |
| |
| lemma integrable_positiveDensity_trace (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) |
| [SigmaFinite μ] (hAC : ∀ S, MeasurableSet S → μ S=0 → W.value S=0) : |
| Integrable (fun t => (trace (W.positiveDensity μ t)).re) μ := by |
| apply (W.integrable_trace_density μ).re.congr |
| filter_upwards [W.positiveDensity_ae μ hAC] with t ht |
| rw [ht] |
| rfl |
| |
| lemma integral_positiveDensity_trace (W : PositiveMatrixMeasure Ω ι) (μ : Measure Ω) |
| [SigmaFinite μ] (hAC : ∀ S, MeasurableSet S → μ S=0 → W.value S=0) : |
| (∫ t, (trace (W.positiveDensity μ t)).re ∂μ) = (trace (W.value Set.univ)).re := by |
| calc |
| _ = ∫ t, (trace (W.density μ t)).re ∂μ := by |
| apply integral_congr_ae |
| filter_upwards [W.positiveDensity_ae μ hAC] with t ht |
| rw [ht] |
| _ = (trace (W.value Set.univ)).re := by |
| change (∫ t, RCLike.re (trace (W.density μ t)) ∂μ) = _ |
| rw [integral_re (W.integrable_trace_density μ)] |
| have he := W.integral_trace_density μ hAC Set.univ MeasurableSet.univ |
| change (∫ t, trace (W.density μ t) ∂μ).re = _ |
| simpa only [Measure.restrict_univ] using congrArg Complex.re he |
| |
| def toBitDensity (W : Bool → Bool → PositiveMatrixMeasure Ω ι) |
| (μ : Measure Ω) [SigmaFinite μ] |
| (hAC : ∀ i j S, MeasurableSet S → μ S=0 → (W i j).value S=0) |
| (hn : (trace ((W false false).value Set.univ)).re + |
| (trace ((W false true).value Set.univ)).re + |
| (trace ((W true false).value Set.univ)).re + |
| (trace ((W true true).value Set.univ)).re = 1) : BitDensity μ ι where |
| block i j := (W i j).positiveDensity μ |
| positive i j := (W i j).positiveDensity_pos μ |
| measurable i j := (W i j).measurable_positiveDensity μ |
| integrable i j := (W i j).integrable_positiveDensity_trace μ (hAC i j) |
| normalized := by |
| simp only [integral_positiveDensity_trace _ μ (hAC _ _)] |
| exact hn |
| |
| end PositiveMatrixMeasure |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Function unitInterval Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker |
| |
| open UnrestrictedQuantum |
| |
| universe v9409_0 v9409_1 v9409_2 v9409_3 v9409_4 v9409_5 v9409_6 v9409_7 v9409_8 v9409_9 |
| |
| variable {O : Type v9409_0} {M : Type v9409_1} {ι : Type v9409_2} {η : Type v9409_3} [inst9409_0 : MeasurableSpace O] [inst9409_1 : MeasurableSpace M] |
| [inst9409_2 : StandardBorelSpace O] [inst9409_3 : Nonempty O] [inst9409_4 : StandardBorelSpace M] [inst9409_5 : Nonempty M] |
| [inst9409_6 : Fintype ι] [inst9409_7 : Fintype η] [inst9409_8 : DecidableEq ι] [inst9409_9 : DecidableEq η] |
| [inst9409_10 : Nonempty ι] [inst9409_11 : Nonempty η] |
| {d : Discussion O M} {A : ℕ → Type v9409_4} {B : ℕ → Type v9409_5} |
| [inst9409_12 : ∀ n, AddCommGroup (A n)] [inst9409_13 : ∀ n, Module ℂ (A n)] [inst9409_14 : ∀ n, One (A n)] [inst9409_15 : ∀ n, LE (A n)] |
| [inst9409_16 : ∀ n, AddCommGroup (B n)] [inst9409_17 : ∀ n, Module ℂ (B n)] [inst9409_18 : ∀ n, One (B n)] [inst9409_19 : ∀ n, LE (B n)] |
| {TA : Type v9409_6} {TB : Type v9409_7} {CA : Type v9409_8} {CB : Type v9409_9} |
| [inst9409_20 : AddCommGroup TA] [inst9409_21 : Module ℂ TA] [inst9409_22 : One TA] [inst9409_23 : LE TA] |
| [inst9409_24 : AddCommGroup TB] [inst9409_25 : Module ℂ TB] [inst9409_26 : One TB] [inst9409_27 : LE TB] |
| [inst9409_28 : AddCommGroup CA] [inst9409_29 : Module ℂ CA] [inst9409_30 : One CA] [inst9409_31 : LE CA] |
| [inst9409_32 : AddCommGroup CB] [inst9409_33 : Module ℂ CB] [inst9409_34 : One CB] [inst9409_35 : LE CB] |
| |
| namespace BitProtocol |
| |
| variable (p : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB) |
| (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| |
| include hR |
| |
| theorem canonical_density_representation : |
| ∃ τ : BitDensity d.transcriptLaw (ι × η), |
| ∃ X : Bool → (ℕ → M) → Matrix ι ι ℂ, |
| ∃ Y : Bool → (ℕ → M) → Matrix η η ℂ, |
| (∀ i t, (X i t).PosSemidef) ∧ (∀ j t, (Y j t).PosSemidef) ∧ |
| (∀ i j t, τ.block i j t = eveBlock R (X i t ⊗ₖ Y j t)) ∧ |
| (∀ i j, Integrable (τ.block i j) d.transcriptLaw) ∧ |
| (∀ i j S, MeasurableSet S → (p.canonicalOutput R i j).value S = |
| ∫ t in S, τ.block i j t ∂d.transcriptLaw) := by |
| obtain ⟨X,Y,hXm,hYm,hX,hY,hXY,hn⟩ := p.public_factors |
| let τ := filteredPublicDensity d.transcriptLaw X Y hXm hYm hX hY R hR hn |
| refine ⟨τ,fun i t => (Fintype.card ι : ℂ) • (X i t)ᵀ, |
| fun j t => (Fintype.card η : ℂ) • (Y j t)ᵀ,?_,?_,?_,?_,?_⟩ |
| · intro i t |
| exact (hX i t).1.transpose.smul (by exact_mod_cast Nat.zero_le (Fintype.card ι)) |
| · intro j t |
| exact (hY j t).1.transpose.smul (by exact_mod_cast Nat.zero_le (Fintype.card η)) |
| · exact filteredPublicDensity_common_factors d.transcriptLaw X Y hXm hYm hX hY R hR hn |
| · intro i j |
| exact integrable_filter _ (public_product_integrable d.transcriptLaw X Y hXm hYm hX hY i j) |
| · intro i j S hS |
| rw [canonicalOutput,PositiveMatrixMeasure.filter_value,hXY i j S hS] |
| exact (integral_filter _ |
| ((public_product_integrable d.transcriptLaw X Y hXm hYm hX hY i j).integrableOn)).symm |
| |
| lemma canonicalOutput_normalized : |
| (trace ((p.canonicalOutput R false false).value Set.univ)).re + |
| (trace ((p.canonicalOutput R false true).value Set.univ)).re + |
| (trace ((p.canonicalOutput R true false).value Set.univ)).re + |
| (trace ((p.canonicalOutput R true true).value Set.univ)).re = 1 := by |
| obtain ⟨τ,X,Y,hX,hY,hτ,hi,he⟩ := p.canonical_density_representation R hR |
| simp_rw [he _ _ Set.univ MeasurableSet.univ,Measure.restrict_univ,← integral_realTrace (hi _ _)] |
| exact τ.normalized |
| |
| end BitProtocol |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe v9682_0 v9682_1 v9682_2 v9682_3 |
| |
| variable {Ω : Type v9682_0} {ι : Type v9682_1} {K : Type v9682_2} {Λ : Type v9682_3} [inst9682_0 : MeasurableSpace Ω] [inst9682_1 : Fintype ι] [inst9682_2 : DecidableEq ι] |
| [inst9682_3 : Fintype K] [inst9682_4 : DecidableEq K] [inst9682_5 : Fintype Λ] [inst9682_6 : DecidableEq Λ] {μ : Measure Ω} |
| |
| def cqDistance (W V : K → K → Ω → Matrix ι ι ℂ) (μ : Measure Ω) : ℝ := |
| ∑ a, ∑ b, ∫ t, traceNorm (W a b t - V a b t) ∂μ |
| |
| def idealFiniteBlocks (sigma : Matrix ι ι ℂ) (a b : K) : Matrix ι ι ℂ := |
| if a = b then (1/(Fintype.card K : ℝ)) • sigma else 0 |
| |
| end |
| |
| section |
| |
| open Matrix |
| |
| open scoped ComplexOrder MatrixOrder Kronecker Matrix.Norms.L2Operator |
| |
| universe v9922_0 v9922_1 |
| |
| variable {ι : Type v9922_0} {κ : Type v9922_1} [inst9922_0 : Fintype ι] [inst9922_1 : Fintype κ] [inst9922_2 : DecidableEq ι] [inst9922_3 : DecidableEq κ] |
| |
| def compressReference (D : Matrix ι ι ℂ) : |
| Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ →ₗ[ℂ] Matrix ι ι ℂ where |
| toFun Z := Z.submatrix Sum.inr Sum.inr + trace (Z.submatrix Sum.inl Sum.inl) • D |
| map_add' Z W := by simp [Matrix.submatrix_add,Matrix.trace_add,add_smul]; abel |
| map_smul' c Z := by simp [Matrix.submatrix_smul,Matrix.trace_smul,smul_smul,smul_add] |
| |
| omit inst9922_0 inst9922_2 inst9922_3 in |
| lemma compressReference_pos [Fintype ι] [DecidableEq ι] [DecidableEq κ] (D : Matrix ι ι ℂ) (hD : D.PosSemidef) |
| {Z : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ} (hZ : Z.PosSemidef) : |
| (compressReference D Z).PosSemidef := |
| (hZ.submatrix Sum.inr).add (hD.smul (hZ.submatrix Sum.inl).trace_nonneg) |
| |
| omit inst9922_2 inst9922_3 in |
| lemma compressReference_trace [DecidableEq ι] [DecidableEq κ] (D : Matrix ι ι ℂ) (hD : trace D = 1) |
| (Z : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ) : trace (compressReference D Z) = trace Z := by |
| change trace (Z.submatrix Sum.inr Sum.inr + trace (Z.submatrix Sum.inl Sum.inl) • D) = _ |
| rw [Matrix.trace_add,Matrix.trace_smul,hD,smul_eq_mul,mul_one] |
| simp only [trace,diag,Matrix.submatrix_apply,Fintype.sum_sum_type] |
| exact add_comm _ _ |
| |
| omit inst9922_0 inst9922_2 inst9922_3 in |
| lemma compressReference_right [Fintype ι] [DecidableEq ι] [DecidableEq κ] (D Z : Matrix ι ι ℂ) : |
| compressReference (κ := κ) D (fromBlocks 0 0 0 Z) = Z := by |
| ext i j |
| simp [compressReference,Matrix.submatrix,Matrix.trace,Matrix.diag] |
| |
| lemma padded_purification_unitary (M : Matrix ι κ ℂ) (S : Matrix ι ι ℂ) |
| (hS : S.IsHermitian) (hgram : M * Mᴴ = S * S) : |
| ∃ U : Matrix.unitaryGroup (κ ⊕ ι) ℂ, |
| fromBlocks (0 : Matrix κ κ ℂ) Mᴴ 0 0 = |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ) * fromBlocks 0 0 0 S := by |
| apply exists_unitary_mul_of_gram_eq |
| simp [Matrix.fromBlocks_conjTranspose,Matrix.fromBlocks_multiply,hS.eq,hgram] |
| |
| def embedReference : Matrix κ κ ℂ →ₗ[ℂ] Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ where |
| toFun Z := fromBlocks Z 0 0 0 |
| map_add' _ _ := by ext i j; cases i < |
| map_smul' _ _ := by ext i j; cases i <;> cases j <;> simp |
| |
| omit inst9922_2 in |
| lemma embedReference_pos [DecidableEq ι] {Z : Matrix κ κ ℂ} (hZ : Z.PosSemidef) : |
| (embedReference (ι := ι) Z).PosSemidef := by |
| have hh := hZ.mul_mul_conjTranspose_same (Matrix.fromRows (1 : Matrix κ κ ℂ) (0 : Matrix ι κ ℂ)) |
| rw [Matrix.conjTranspose_fromRows_eq_fromCols_conjTranspose,Matrix.fromRows_mul, |
| Matrix.fromRows_mul_fromCols] at hh |
| simpa [embedReference] using hh |
| |
| omit inst9922_2 inst9922_3 in |
| lemma embedReference_trace [DecidableEq ι] [DecidableEq κ] (Z : Matrix κ κ ℂ) : |
| trace (embedReference (ι := ι) Z) = trace Z := by |
| simp [embedReference,trace,diag,Fintype.sum_sum_type] |
| |
| def refSandwich (K : Matrix ι κ ℂ) : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ where |
| toFun Z := K * Z * Kᴴ |
| map_add' _ _ := by simp [Matrix.mul_add,Matrix.add_mul] |
| map_smul' _ _ := by simp [Matrix.mul_smul,Matrix.smul_mul] |
| |
| lemma padded_purification_blocks (M : Matrix ι κ ℂ) (S : Matrix ι ι ℂ) |
| (hS : S.IsHermitian) (U : Matrix.unitaryGroup (κ ⊕ ι) ℂ) |
| (hU : fromBlocks (0 : Matrix κ κ ℂ) Mᴴ 0 0 = |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ) * fromBlocks 0 0 0 S) |
| (X : Matrix ι ι ℂ) : |
| embedReference (ι := ι) (Mᴴ * X * M) = |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ) * fromBlocks 0 0 0 (S * X * S) * |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)ᴴ := by |
| let A : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ := fromBlocks 0 Mᴴ 0 0 |
| let B : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ := fromBlocks 0 0 0 S |
| let Y : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ := fromBlocks 0 0 0 X |
| have he : embedReference (ι := ι) (Mᴴ * X * M) = A * Y * Aᴴ := by |
| simp [embedReference,A,Y,Matrix.fromBlocks_conjTranspose,Matrix.fromBlocks_multiply] |
| have hb : B * Y * Bᴴ = fromBlocks 0 0 0 (S*X*S) := by |
| simp [B,Y,Matrix.fromBlocks_conjTranspose,Matrix.fromBlocks_multiply,hS.eq] |
| change A = (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)*B at hU |
| rw [he,hU,Matrix.conjTranspose_mul] |
| calc |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)*B*Y*(Bᴴ*(U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)ᴴ) = |
| (U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)*(B*Y*Bᴴ)*(U : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ)ᴴ := by noncomm_ring |
| _ = _ := by rw [hb] |
| |
| theorem purification_recovery (R : Matrix ι ι ℂ) (hR : Density R) |
| (M : Matrix ι κ ℂ) (hM : M * Mᴴ = R) : |
| ∃ L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ, |
| (∀ Z, Z.PosSemidef → (L Z).PosSemidef) ∧ |
| (∀ Z, trace (L Z) = trace Z) ∧ |
| ∀ X, L (Mᴴ * X * M) = CFC.sqrt R * X * CFC.sqrt R := by |
| let S := CFC.sqrt R |
| have hS : S.IsHermitian := (CFC.sqrt_nonneg R).posSemidef.isHermitian |
| have hgram : M*Mᴴ = S*S := by rw [hM]; exact (CFC.sqrt_mul_sqrt_self R hR.1.nonneg).symm |
| obtain ⟨U,hU⟩ := padded_purification_unitary M S hS hgram |
| let V : Matrix (κ ⊕ ι) (κ ⊕ ι) ℂ := U |
| let L := (compressReference (κ := κ) R).comp ((refSandwich Vᴴ).comp embedReference) |
| refine ⟨L,?_,?_,?_⟩ |
| · intro Z hZ |
| exact compressReference_pos R hR.1 ((embedReference_pos hZ).mul_mul_conjTranspose_same Vᴴ) |
| · intro Z |
| change trace (compressReference R (Vᴴ * embedReference Z * Vᴴᴴ)) = _ |
| rw [compressReference_trace R hR.2,Matrix.conjTranspose_conjTranspose, |
| Matrix.trace_mul_cycle,show V*Vᴴ = 1 from U.prop.2,one_mul,embedReference_trace] |
| · intro X |
| change compressReference R (Vᴴ * embedReference (Mᴴ*X*M) * Vᴴᴴ) = _ |
| rw [padded_purification_blocks M S hS U hU X,Matrix.conjTranspose_conjTranspose] |
| have hv : Vᴴ * (V * fromBlocks 0 0 0 (S*X*S) * Vᴴ) * V = |
| fromBlocks 0 0 0 (S*X*S) := by |
| rw [mul_assoc V _ _,← mul_assoc Vᴴ V _,show Vᴴ*V=1 from U.prop.1,one_mul, |
| mul_assoc,show Vᴴ*V=1 from U.prop.1,mul_one] |
| change compressReference R (Vᴴ*(V*fromBlocks 0 0 0 (S*X*S)*Vᴴ)*V) = _ |
| rw [hv,compressReference_right] |
| |
| end |
| |
| section |
| |
| open Matrix |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe v10053_0 v10053_1 |
| |
| theorem purification_recovery_transpose {ι : Type v10053_0} {κ : Type v10053_1} |
| [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] |
| (R : Matrix ι ι ℂ) (hR : Density R) |
| (M : Matrix ι κ ℂ) (hM : M * Mᴴ = R) : |
| ∃ L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ, |
| (∀ Z, Z.PosSemidef → (L Z).PosSemidef) ∧ |
| (∀ Z, trace (L Z) = trace Z) ∧ |
| ∀ X, L ((Mᴴ * X * M)ᵀ) = (CFC.sqrt R * X * CFC.sqrt R)ᵀ := by |
| obtain ⟨L,hpos,htr,hrec⟩ := purification_recovery R hR M hM |
| let J : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ := |
| { toFun Z := (L Zᵀ)ᵀ |
| map_add' Z W := by simp only [Matrix.transpose_add,map_add] |
| map_smul' c Z := by simp only [Matrix.transpose_smul,map_smul,RingHom.id_apply] } |
| refine ⟨J,?_,?_,?_⟩ |
| · intro Z hZ |
| exact (hpos Zᵀ hZ.transpose).transpose |
| · intro Z |
| change trace (L Zᵀ)ᵀ = trace Z |
| rw [Matrix.trace_transpose,htr,Matrix.trace_transpose] |
| · intro X |
| change (L ((Mᴴ*X*M)ᵀ)ᵀ)ᵀ = _ |
| rw [Matrix.transpose_transpose,hrec] |
| |
| end |
| |
| 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 κ] |
| |
| def purificationFilter (P : Matrix ι κ ℂ) : Matrix κ ι ℂ := |
| (Real.sqrt (Fintype.card ι : ℝ) : ℂ) • Pᵀ |
| |
| open MeasureTheory |
| |
| /-- Matrix-valued output entries after purification and publication of the transcript. -/ |
| def publicPurifiedEntries {Ω T K : Type*} [MeasurableSpace Ω] [MeasurableSpace T] |
| (μ : Measure Ω) (record : Ω → T) (W : K → K → Ω → Matrix ι ι ℂ) |
| (P : Matrix ι κ ℂ) (a b : K) (x y : κ) : ComplexMeasure T := |
| ∑ i, ∑ j, (purificationFilter P x i * star (purificationFilter P y j)) • |
| (μ.withDensityᵥ (fun ω => W a b ω i j)).map record |
| |
| /-- The positive representative of the entrywise Radon–Nikodym derivative. -/ |
| def positiveEntryDensity {Ω : Type*} [MeasurableSpace Ω] |
| (W : ι → ι → ComplexMeasure Ω) (μ : Measure Ω) (t : Ω) : Matrix ι ι ℂ := by |
| classical |
| let D : Matrix ι ι ℂ := fun i j => (W i j).rnDeriv μ t |
| exact if D.PosSemidef then D else 0 |
| |
| omit inst10089_1 inst10089_2 inst10089_3 in |
| lemma purificationFilter_block [Fintype κ] [DecidableEq ι] [DecidableEq κ] (P : Matrix ι κ ℂ) (U : Matrix ι ι ℂ) : |
| purificationFilter P * U * (purificationFilter P)ᴴ = |
| (Pᴴ * ((Fintype.card ι : ℂ) • Uᵀ) * P)ᵀ := by |
| have hc : (Real.sqrt (Fintype.card ι : ℝ) : ℂ) * |
| (Real.sqrt (Fintype.card ι : ℝ) : ℂ) = (Fintype.card ι : ℂ) := by |
| rw [← Complex.ofReal_mul,Real.mul_self_sqrt (Nat.cast_nonneg _)] |
| norm_cast |
| simp only [purificationFilter,Matrix.conjTranspose_smul,Complex.star_def, |
| Complex.conj_ofReal,Matrix.smul_mul,Matrix.mul_smul,smul_smul, |
| Matrix.transpose_mul,Matrix.transpose_smul,Matrix.transpose_transpose, |
| Matrix.conjTranspose_transpose_eq_transpose_conjTranspose] |
| rw [hc,Matrix.mul_assoc] |
| |
| lemma preparationFilter_eq_purificationFilter (R : Matrix ι ι ℂ) : |
| preparationFilter R = purificationFilter (CFC.sqrt R) := rfl |
| |
| theorem purification_filter_recovery (R : Matrix ι ι ℂ) (hR : Density R) |
| (P : Matrix ι κ ℂ) (hP : P * Pᴴ = R) : |
| ∃ L : Matrix κ κ ℂ →ₗ[ℂ] Matrix ι ι ℂ, |
| (∀ Z, Z.PosSemidef → (L Z).PosSemidef) ∧ |
| (∀ Z, trace (L Z) = trace Z) ∧ |
| ∀ U, L (purificationFilter P * U * (purificationFilter P)ᴴ) = |
| preparationFilter R * U * (preparationFilter R)ᴴ := by |
| obtain ⟨L,hpos,htr,he⟩ := purification_recovery_transpose R hR P hP |
| refine ⟨L,hpos,htr,?_⟩ |
| intro U |
| rw [purificationFilter_block,he,preparationFilter_eq_purificationFilter, |
| purificationFilter_block,(CFC.sqrt_nonneg R).posSemidef.isHermitian.eq] |
| |
| 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) |
| |
| def purifiedOutput (i j : Bool) : PositiveMatrixMeasure (ℕ → M) κ := |
| (p.probeOutput i j).filter (purificationFilter P) |
| |
| omit inst10227_10 inst10227_11 inst10227_37 in |
| lemma purifiedOutput_ac [Nonempty ι] [Nonempty η] [DecidableEq κ] (i j : Bool) (S : Set (ℕ → M)) (hS : MeasurableSet S) |
| (hnull : d.transcriptLaw S = 0) : (p.purifiedOutput P i j).value S = 0 := by |
| obtain ⟨X,Y,hXm,hYm,hX,hY,he,hn⟩ := p.public_factors |
| rw [purifiedOutput,PositiveMatrixMeasure.filter_value,he i j S hS, |
| Measure.restrict_eq_zero.mpr hnull,integral_zero_measure,Matrix.mul_zero,Matrix.zero_mul] |
| |
| include hR hP |
| |
| omit inst10227_10 inst10227_11 in |
| lemma purifiedOutput_recovery [Nonempty ι] [Nonempty η] : |
| ∃ L : Matrix κ κ ℂ →ₗ[ℂ] Matrix (ι × η) (ι × η) ℂ, |
| (∀ Z, Z.PosSemidef → (L Z).PosSemidef) ∧ |
| (∀ Z, trace (L Z) = trace Z) ∧ |
| ∀ i j S, L ((p.purifiedOutput P i j).value S) = (p.canonicalOutput R i j).value S := by |
| obtain ⟨L,hpos,htr,he⟩ := purification_filter_recovery R hR P hP |
| refine ⟨L,hpos,htr,?_⟩ |
| intro i j S |
| simpa only [purifiedOutput,canonicalOutput,PositiveMatrixMeasure.filter_value] using |
| he ((p.probeOutput i j).value S) |
| |
| lemma purifiedOutput_normalized : |
| (trace ((p.purifiedOutput P false false).value Set.univ)).re + |
| (trace ((p.purifiedOutput P false true).value Set.univ)).re + |
| (trace ((p.purifiedOutput P true false).value Set.univ)).re + |
| (trace ((p.purifiedOutput P true true).value Set.univ)).re = 1 := by |
| obtain ⟨L,hpos,htr,he⟩ := p.purifiedOutput_recovery R hR P hP |
| have hh i j : trace ((p.purifiedOutput P i j).value Set.univ) = |
| trace ((p.canonicalOutput R i j).value Set.univ) := by rw [← he,htr] |
| simp_rw [hh] |
| exact p.canonicalOutput_normalized R hR |
| |
| def purifiedDensity (ν : Measure (ℕ → M)) [SigmaFinite ν] |
| (hμν : d.transcriptLaw ≪ ν) : BitDensity ν κ := |
| PositiveMatrixMeasure.toBitDensity (p.purifiedOutput P) ν |
| (fun i j S hS hz => p.purifiedOutput_ac P i j S hS (hμν hz)) |
| (p.purifiedOutput_normalized R hR P hP) |
| |
| /-- The operational bit error written directly in terms of the output entries. -/ |
| def rawPurifiedSecretBitError (P : Matrix (ι × η) κ ℂ) |
| (sigma : PositiveMatrixMeasure (ℕ → M) κ) : ℝ := |
| let ν := d.transcriptLaw + sigma.traceMeasure |
| let τ := fun i j => positiveEntryDensity |
| (publicPurifiedEntries d.probeLaw d.sampler.publicRecord p.completeReference P i j) ν |
| let σ := sigma.positiveDensity ν |
| (∫ t, (trace (τ false true t)).re ∂ν) + |
| (∫ t, (trace (τ true false t)).re ∂ν) + |
| (∫ t, traceNorm (τ false false t - (1 / ((2 : ℕ) : ℝ)) • σ t) ∂ν) + |
| (∫ t, traceNorm (τ true true t - (1 / ((2 : ℕ) : ℝ)) • σ t) ∂ν) |
| |
| def purifiedSecretBitError (sigma : PositiveMatrixMeasure (ℕ → M) κ) : ℝ := |
| (p.purifiedDensity R hR P hP (d.transcriptLaw + sigma.traceMeasure) |
| (Measure.AbsolutelyContinuous.rfl.add_right _)).idealBitError |
| (sigma.positiveDensity (d.transcriptLaw + sigma.traceMeasure)) |
| |
| lemma rawPurifiedSecretBitError_eq (sigma : PositiveMatrixMeasure (ℕ → M) κ) : |
| p.rawPurifiedSecretBitError P sigma = p.purifiedSecretBitError R hR P hP sigma := rfl |
| |
| end BitProtocol |
| |
| end ZeroKey |
| |
| namespace UnrestrictedQuantum |
| |
| open Matrix MeasureTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| section |
| |
| universe v10363_0 v10363_1 v10363_2 v10363_3 |
| |
| variable {A : Type v10363_0} {B : Type v10363_1} {O : Type v10363_2} {ι : Type v10363_3} [inst10363_0 : AddCommGroup A] [inst10363_1 : Module ℂ A] [inst10363_2 : One A] [inst10363_3 : LE A] |
| [inst10363_4 : AddCommGroup B] [inst10363_5 : Module ℂ B] [inst10363_6 : One B] [inst10363_7 : LE B] |
| [inst10363_8 : MeasurableSpace O] [inst10363_9 : Nonempty O] [inst10363_10 : Fintype ι] [inst10363_11 : DecidableEq ι] |
| |
| namespace ObservableInstrument |
| |
| def postprocess (J : ObservableInstrument O A B) (f : O → Bool) (hf : Measurable f) : |
| ObservableInstrument Bool A B where |
| operation E := J.operation (f ⁻¹' E) |
| positive E hE x hx := J.positive _ (hf hE) x hx |
| total_unit := by simpa only [Set.preimage_univ] using J.total_unit |
| |
| end ObservableInstrument |
|
|
| namespace InstrumentRun |
| |
| variable {J : ObservableInstrument O A B} {S : ReferenceFunctional A ι} |
| (r : InstrumentRun J S) |
|
|
| omit inst10363_9 inst10363_11 in |
| lemma event_trace [Nonempty O] [DecidableEq ι] (E : Set O) (hE : MeasurableSet E) : |
| trace (S (J.operation E 1)) = (r.law.real E : ℂ) := by |
| calc |
| _ = ∫ o in E, trace (r.posterior o 1) ∂r.law := by |
| simp only [trace,diag] |
| rw [integral_finsetSum _ (fun i _ => (r.integrable 1 i i).integrableOn)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact (r.update E hE 1 i i).symm |
| _ = _ := by simp [r.posterior_trace,integral_const,Complex.real_smul,Measure.real] |
|
|
| omit inst10363_9 inst10363_11 in |
| lemma event_zero [Nonempty O] [DecidableEq ι] (E : Set O) (hE : MeasurableSet E) (hz : r.law E = 0) (x : B) : |
| S (J.operation E x) = 0 := by |
| ext i j |
| rw [← r.update E hE x i j,Measure.restrict_eq_zero.mpr hz,integral_zero_measure] |
| rfl |
|
|
| variable (f : O → Bool) (hf : Measurable f) |
|
|
| def coarseMass (i : Bool) : ℝ := r.law.real (f ⁻¹' {i}) |
| |
| def coarsePosterior (i : Bool) : ReferenceFunctional B ι := |
| if r.coarseMass f i = 0 then r.posterior (Classical.choice ‹Nonempty O›) |
| else ((r.coarseMass f i)⁻¹ : ℝ) • (S.comp (J.operation (f ⁻¹' {i}))) |
|
|
| include hf |
|
|
| omit inst10363_11 in |
| lemma coarsePosterior_positive [DecidableEq ι] (hS : PositiveFunctional S) (i : Bool) : |
| PositiveFunctional (r.coarsePosterior f i) := by |
| unfold coarsePosterior |
| split |
| · exact r.posterior_positive _ |
| · intro x hx |
| exact (hS _ (J.positive _ (hf (measurableSet_singleton i)) x hx)).smul |
| (inv_nonneg.mpr (ENNReal.toReal_nonneg)) |
|
|
| lemma coarsePosterior_trace (_hS : PositiveFunctional S) (i : Bool) : |
| trace (r.coarsePosterior f i 1) = 1 := by |
| unfold coarsePosterior |
| split |
| · exact r.posterior_trace _ |
| · rename_i hn |
| simp only [LinearMap.smul_apply,LinearMap.comp_apply,Matrix.trace_smul] |
| rw [r.event_trace _ (hf (measurableSet_singleton i))] |
| change ((r.coarseMass f i)⁻¹ : ℝ) • ((r.coarseMass f i : ℝ) : ℂ) = 1 |
| simp only [Complex.real_smul,Complex.ofReal_inv,inv_mul_cancel₀ (Complex.ofReal_ne_zero.mpr hn)] |
|
|
| lemma coarsePosterior_weighted (i : Bool) (x : B) : |
| r.coarseMass f i • r.coarsePosterior f i x = S (J.operation (f ⁻¹' {i}) x) := by |
| let : IsProbabilityMeasure r.law := r.probability |
| unfold coarsePosterior |
| split |
| · rename_i hz |
| rw [hz,zero_smul] |
| symm |
| apply r.event_zero _ (hf (measurableSet_singleton i)) |
| exact (ENNReal.toReal_eq_zero_iff _).mp hz |>.resolve_right (measure_ne_top _ _) |
| · rename_i hn |
| simp only [LinearMap.smul_apply,LinearMap.comp_apply,smul_smul,mul_inv_cancel₀ hn,one_smul] |
| |
| lemma coarsePosterior_singleton (i : Bool) (x : B) (k l : ι) : |
| (∫ b in {i}, r.coarsePosterior f b x k l ∂(r.law.map f)) = |
| S (J.operation (f ⁻¹' {i}) x) k l := by |
| rw [integral_singleton] |
| have hm : (r.law.map f).real {i} = r.coarseMass f i := by |
| rw [Measure.real,Measure.map_apply hf (measurableSet_singleton i)] |
| rfl |
| rw [hm] |
| exact congrArg (fun U : Matrix ι ι ℂ => U k l) (r.coarsePosterior_weighted f hf i x) |
|
|
| lemma coarsePosterior_integral (E : Set Bool) (x : B) (k l : ι) : |
| (∫ b in E, r.coarsePosterior f b x k l ∂(r.law.map f)) = |
| S (J.operation (f ⁻¹' E) x) k l := by |
| let : IsProbabilityMeasure r.law := r.probability |
| let : IsProbabilityMeasure (r.law.map f) := inferInstance |
| have hpart : E = ∅ ∨ E = {false} ∨ E = {true} ∨ E = Set.univ := by |
| by_cases h0 : false ∈ E <;> by_cases h1 : true ∈ E |
| · right; right; right; ext b; cases b <;> simp_all |
| · right; left; ext b; cases b <;> simp_all |
| · right; right; left; ext b; cases b <;> simp_all |
| · left; ext b; cases b <;> simp_all |
| rcases hpart with rfl | rfl | rfl | rfl |
| · simp only [setIntegral_empty,Set.preimage_empty] |
| exact (congrArg (fun U : Matrix ι ι ℂ => U k l) |
| (r.event_zero ∅ MeasurableSet.empty (measure_empty) x)).symm |
| · exact r.coarsePosterior_singleton f hf false x k l |
| · exact r.coarsePosterior_singleton f hf true x k l |
| · have hd : Disjoint (f ⁻¹' {false}) (f ⁻¹' {true}) := by |
| apply Set.disjoint_left.mpr |
| intro o h0 h1 |
| simp only [Set.mem_preimage,Set.mem_singleton_iff] at h0 h1 |
| rw [h0] at h1 |
| contradiction |
| have hu : (f ⁻¹' {false}) ∪ (f ⁻¹' {true}) = Set.univ := by |
| ext o; cases f o <;> simp |
| have hb : ({false} : Set Bool) ∪ {true} = Set.univ := by ext b; cases b <;> simp |
| rw [← hb,setIntegral_union (by simp) (measurableSet_singleton true) |
| Integrable.of_finite.integrableOn Integrable.of_finite.integrableOn, |
| r.coarsePosterior_singleton f hf false x k l, |
| r.coarsePosterior_singleton f hf true x k l] |
| rw [← r.update _ (hf (measurableSet_singleton false)) x k l, |
| ← r.update _ (hf (measurableSet_singleton true)) x k l] |
| rw [← setIntegral_union hd (hf (measurableSet_singleton true)) |
| (r.integrable x k l).integrableOn (r.integrable x k l).integrableOn,hu] |
| simpa only [Set.preimage_union,Set.preimage_univ,hu] using |
| r.update Set.univ MeasurableSet.univ x k l |
| |
| def postprocess (hS : PositiveFunctional S) : |
| InstrumentRun (J.postprocess f hf) S where |
| law := r.law.map f |
| probability := by |
| let : IsProbabilityMeasure r.law := r.probability |
| exact inferInstance |
| posterior := r.coarsePosterior f |
| posterior_positive := r.coarsePosterior_positive f hf hS |
| posterior_trace := r.coarsePosterior_trace f hf hS |
| integrable x k l := by |
| let : IsProbabilityMeasure r.law := r.probability |
| let : IsProbabilityMeasure (r.law.map f) := inferInstance |
| exact Integrable.of_finite |
| update E hE x k l := r.coarsePosterior_integral f hf E x k l |
| |
| end InstrumentRun |
| |
| end |
| |
| 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 ι] |
| |
| omit inst10518_10 inst10518_11 inst10518_12 inst10518_14 in |
| lemma InstrumentRun.event_finset [Fintype K] [DecidableEq K] [Nonempty K] [DecidableEq ι] {J : ObservableInstrument K A B} |
| {S : ReferenceFunctional A ι} (r : InstrumentRun J S) (s : Finset K) (x : B) : |
| S (J.operation s x) = ∑ k ∈ s, S (J.operation {k} x) := by |
| ext i j |
| simp only [Matrix.sum_apply] |
| rw [← r.update s (s.finite_toSet.measurableSet) x i j, |
| setIntegral_finset s (r.integrable x i j).integrableOn] |
| apply Finset.sum_congr rfl |
| intro k hk |
| rw [← r.update {k} (measurableSet_singleton k) x i j,integral_singleton] |
| |
| lemma InstrumentRun.event_total {J : ObservableInstrument K A B} |
| {S : ReferenceFunctional A ι} (r : InstrumentRun J S) : |
| (∑ k, S (J.operation {k} 1)) = S 1 := by |
| simpa only [Finset.coe_univ,J.total_unit] using (r.event_finset Finset.univ 1).symm |
| |
| variable {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω} |
| {μ : Measure Ω} {F : Filtration ℕ mΩ} {U : ℕ → Ω → Matrix ι ι ℂ} |
| (e : IncomingObservableProcess (L := L) (A := A) μ F U) |
| |
| namespace IncomingObservableProcess |
| |
| structure FiniteReadout where |
| instrument : Ω → ObservableInstrument K A B |
| run : ∀ x, InstrumentRun (instrument x) (e.state x) |
| positive_unit : (0 : B) ≤ 1 |
| local_measurable : ∀ k, Measurable[L] (fun x => e.state x ((instrument x).operation {k} 1)) |
| |
| namespace FiniteReadout |
| |
| variable {e} (b : e.FiniteReadout (B := B) (K := K)) |
| |
| def value (k : K) (x : Ω) : Matrix ι ι ℂ := e.state x ((b.instrument x).operation {k} 1) |
| |
| omit inst10518_9 inst10518_10 inst10518_11 inst10518_12 in |
| lemma measurable [MeasurableSingletonClass K] [Fintype K] [DecidableEq K] [Nonempty K] (k : K) : Measurable[L] (b.value k) := b.local_measurable k |
| |
| omit inst10518_10 inst10518_11 inst10518_12 in |
| lemma positive [Fintype K] [DecidableEq K] [Nonempty K] (k : K) (x : Ω) : (b.value k x).PosSemidef := |
| e.positive x _ ((b.instrument x).positive {k} (measurableSet_singleton k) 1 b.positive_unit) |
| |
| lemma sum (x : Ω) : (∑ k, b.value k x) = e.state x 1 := (b.run x).event_total |
| |
| lemma subdensity (k : K) (x : Ω) : ZeroKey.Subdensity (b.value k x) := by |
| refine ⟨b.positive k x,?_⟩ |
| have hsum := congrArg (fun M : Matrix ι ι ℂ => (trace M).re) (b.sum x) |
| simp only [Matrix.trace_sum,Complex.re_sum,e.normalized x,Complex.one_re] at hsum |
| rw [← hsum] |
| exact Finset.single_le_sum (fun l _ => (RCLike.nonneg_iff.mp (b.positive l x).trace_nonneg).1) |
| (Finset.mem_univ k) |
| |
| lemma event_finset (s : Finset K) (x : Ω) : |
| e.state x ((b.instrument x).operation s 1) = ∑ k ∈ s, b.value k x := |
| (b.run x).event_finset s 1 |
| |
| lemma eventMeasurable (s : Finset K) : |
| Measurable[L] (fun x => e.state x ((b.instrument x).operation s 1)) := by |
| simp_rw [b.event_finset s] |
| exact Finset.measurable_sum s (fun k _ => b.local_measurable k) |
| |
| def postprocess (f : K → Bool) : e.BitReadout (B := B) where |
| instrument x := (b.instrument x).postprocess f (measurable_of_finite f) |
| run x := (b.run x).postprocess f (measurable_of_finite f) (e.positive x) |
| positive_unit := b.positive_unit |
| local_measurable i := by |
| let s := Finset.univ.filter (fun k => f k = i) |
| have hs : (s : Set K) = f ⁻¹' {i} := by ext k |
| change Measurable[L] (fun x => e.state x ((b.instrument x).operation (f ⁻¹' {i}) 1)) |
| rw [← hs] |
| exact b.eventMeasurable s |
| |
| 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] |
| |
| structure FiniteProtocol where |
| executionA : LocalObservableExecution (ι := ι) A d.kernelA d.sendA |
| executionB : LocalObservableExecution (ι := η) B d.kernelB d.sendB |
| initialA : executionA.reference 0 (Fin.elim0,Fin.elim0) = |
| keepReference (outer (localProbe (ι := ι)) localProbe) |
| initialB : executionB.reference 0 (Fin.elim0,Fin.elim0) = |
| keepReference (outer (localProbe (ι := η)) localProbe) |
| incomingA : IncomingObservableProcess (L := d.sampler.localField true) (A := TA) |
| d.probeLaw historyFiltration |
| (fun n x => AdaptiveQuantum.globalLocalReferenceA d.sampler d.kernelA executionA n (historyPrefix n x)) |
| incomingB : IncomingObservableProcess (L := d.sampler.localField false) (A := TB) |
| d.probeLaw historyFiltration |
| (fun n x => AdaptiveQuantum.globalLocalReferenceB d.sampler d.kernelB executionB n (historyPrefix n x)) |
| readoutA : incomingA.FiniteReadout (B := CA) (K := K) |
| readoutB : incomingB.FiniteReadout (B := CB) (K := K) |
| |
| variable {d A B TA TB CA CB} |
| |
| namespace FiniteProtocol |
| |
| variable (p : FiniteProtocol (ι := ι) (η := η) (K := K) d A B TA TB CA CB) |
| |
| def toBit (f : K → Bool) : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB where |
| executionA := p.executionA |
| executionB := p.executionB |
| initialA := p.initialA |
| initialB := p.initialB |
| incomingA := p.incomingA |
| incomingB := p.incomingB |
| readoutA := p.readoutA.postprocess f |
| readoutB := p.readoutB.postprocess f |
| |
| def completeReference (i j : K) (x : ℕ → O) : Matrix (ι × η) (ι × η) ℂ := |
| p.readoutA.value i x ⊗ₖ p.readoutB.value j x |
| |
| omit inst10619_4 inst10619_5 in |
| lemma completeReference_positive [StandardBorelSpace M] [Nonempty M] (i j : K) (x : ℕ → O) : |
| (p.completeReference i j x).PosSemidef := |
| (p.readoutA.positive i x).kronecker (p.readoutB.positive j x) |
| |
| omit inst10619_4 inst10619_5 in |
| lemma completeReference_measurable [StandardBorelSpace M] [Nonempty M] (i j : K) : Measurable (p.completeReference i j) := |
| measurable_matrix_kronecker |
| ((p.readoutA.measurable i).mono (d.sampler.localField_le true) le_rfl) |
| ((p.readoutB.measurable j).mono (d.sampler.localField_le false) le_rfl) |
| |
| lemma completeReference_integrable (i j : K) : Integrable (p.completeReference i j) d.probeLaw := |
| integrable_subdensity _ |
| (fun x => subdensity_kronecker (p.readoutA.subdensity i x) (p.readoutB.subdensity j x)) |
| (p.completeReference_measurable i j) d.probeLaw |
| |
| lemma completeReference_entry_integrable (i j : K) (k l : ι × η) : |
| Integrable (fun x => p.completeReference i j x k l) d.probeLaw := |
| ((Matrix.entryLinearMap ℂ ℂ k l).toContinuousLinearMap).integrable_comp |
| (p.completeReference_integrable i j) |
| |
| def probeOutput (i j : K) : PositiveMatrixMeasure (ℕ → M) (ι × η) := |
| (positiveMatrixMeasureOfDensity (p.completeReference_entry_integrable i j) |
| (Eventually.of_forall (p.completeReference_positive i j))).pushforward |
| d.sampler.publicRecord d.sampler.measurable_publicRecord |
| |
| lemma probeOutput_event (i j : K) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.probeOutput i j).value S = |
| ∫ x in d.sampler.publicRecord ⁻¹' S, p.completeReference i j x ∂d.probeLaw := by |
| rw [probeOutput,PositiveMatrixMeasure.pushforward_value _ _ _ S hS, |
| positiveMatrixMeasureOfDensity_value _ _ _ (d.sampler.measurable_publicRecord hS)] |
|
|
| def canonicalOutput (R : Matrix (ι × η) (ι × η) ℂ) (i j : K) : |
| PositiveMatrixMeasure (ℕ → M) (ι × η) := |
| (p.probeOutput i j).filter (preparationFilter R) |
|
|
| lemma canonicalOutput_event (R : Matrix (ι × η) (ι × η) ℂ) |
| (i j : K) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.canonicalOutput R i j).value S = |
| ∫ x in d.sampler.publicRecord ⁻¹' S, |
| preparationFilter R * p.completeReference i j x * (preparationFilter R)ᴴ ∂d.probeLaw := by |
| rw [canonicalOutput,PositiveMatrixMeasure.filter_value,p.probeOutput_event i j S hS, |
| integral_filter _ (p.completeReference_integrable i j).integrableOn] |
| |
| end FiniteProtocol |
| |
| end |
| |
| open UnrestrictedQuantum |
| |
| universe v10926_0 v10926_1 v10926_2 v10926_3 v10926_4 v10926_5 v10926_6 v10926_7 v10926_8 v10926_9 v10926_10 |
| |
| variable {O : Type v10926_0} {M : Type v10926_1} {ι : Type v10926_2} {η : Type v10926_3} [inst10926_0 : MeasurableSpace O] [inst10926_1 : MeasurableSpace M] |
| [inst10926_2 : StandardBorelSpace O] [inst10926_3 : Nonempty O] [inst10926_4 : StandardBorelSpace M] [inst10926_5 : Nonempty M] |
| [inst10926_6 : Fintype ι] [inst10926_7 : Fintype η] [inst10926_8 : DecidableEq ι] [inst10926_9 : DecidableEq η] |
| {K : Type v10926_4} [inst10926_10 : MeasurableSpace K] [inst10926_11 : MeasurableSingletonClass K] |
| [inst10926_12 : Fintype K] [inst10926_13 : DecidableEq K] [inst10926_14 : Nonempty K] |
| [inst10926_15 : Nonempty ι] [inst10926_16 : Nonempty η] |
| (d : Discussion O M) |
| (A : ℕ → Type v10926_5) (B : ℕ → Type v10926_6) |
| [inst10926_17 : ∀ n, AddCommGroup (A n)] [inst10926_18 : ∀ n, Module ℂ (A n)] [inst10926_19 : ∀ n, One (A n)] [inst10926_20 : ∀ n, LE (A n)] |
| [inst10926_21 : ∀ n, AddCommGroup (B n)] [inst10926_22 : ∀ n, Module ℂ (B n)] [inst10926_23 : ∀ n, One (B n)] [inst10926_24 : ∀ n, LE (B n)] |
| (TA : Type v10926_7) (TB : Type v10926_8) (CA : Type v10926_9) (CB : Type v10926_10) |
| [inst10926_25 : AddCommGroup TA] [inst10926_26 : Module ℂ TA] [inst10926_27 : One TA] [inst10926_28 : LE TA] |
| [inst10926_29 : AddCommGroup TB] [inst10926_30 : Module ℂ TB] [inst10926_31 : One TB] [inst10926_32 : LE TB] |
| [inst10926_33 : AddCommGroup CA] [inst10926_34 : Module ℂ CA] [inst10926_35 : One CA] [inst10926_36 : LE CA] |
| [inst10926_37 : AddCommGroup CB] [inst10926_38 : Module ℂ CB] [inst10926_39 : One CB] [inst10926_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) |
| |
| omit inst10926_4 inst10926_5 inst10926_15 inst10926_16 in |
| lemma completeReference_sum [StandardBorelSpace M] [Nonempty M] [Nonempty ι] [Nonempty η] (x : ℕ → O) : |
| (∑ i, ∑ j, p.completeReference i j x) = |
| p.incomingA.state x 1 ⊗ₖ p.incomingB.state x 1 := by |
| rw [← p.readoutA.sum x,← p.readoutB.sum x] |
| ext a b |
| simp only [completeReference,Matrix.sum_apply,Matrix.kroneckerMap_apply, |
| Finset.sum_mul,Finset.mul_sum] |
| rw [Finset.sum_comm] |
| |
| lemma completeReference_total : |
| (∑ i, ∑ j, ∫ x, p.completeReference i j x ∂d.probeLaw) = |
| keepReference (outer (localProbe (ι := ι × η)) localProbe) := by |
| |
| simp_rw [← integral_finsetSum _ (fun j _ => p.completeReference_integrable _ j)] |
| rw [← integral_finsetSum _ (fun i _ => integrable_finsetSum _ |
| (fun j _ => p.completeReference_integrable i j))] |
| simp_rw [p.completeReference_sum] |
| have hc := AdaptiveQuantum.incoming_joint_reference_consistency |
| d.sampler d.kernelA d.kernelB p.executionA p.executionB d.probeLaw d.probeLaw_prefix |
| p.incomingA p.incomingB 0 Set.univ MeasurableSet.univ |
| simp only [Measure.restrict_univ] at hc |
| rw [hc] |
| have hpre (x : ℕ → O) : historyPrefix 0 x = Fin.elim0 := Subsingleton.elim _ _ |
| simp_rw [hpre] |
| have hi := (p.toBit (fun _ => false)).initial_joint_reference |
| change AdaptiveQuantum.jointReference d.sampler d.kernelA d.kernelB p.executionA p.executionB |
| 0 Fin.elim0 = _ at hi |
| simp [hi] |
| |
| lemma canonicalOutput_sum (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) : |
| (∑ i, ∑ j, (p.canonicalOutput R i j).value Set.univ) = Rᵀ := by |
| simp_rw [p.canonicalOutput_event R _ _ Set.univ MeasurableSet.univ, |
| Set.preimage_univ,Measure.restrict_univ] |
| simp_rw [integral_filter _ (p.completeReference_integrable _ _)] |
| simp only [← Matrix.sum_mul,← Matrix.mul_sum] |
| rw [p.completeReference_total,← keepReference_filter,preparation_filter_identity, |
| canonical_reference R hR.1] |
| |
| lemma canonicalOutput_normalized (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) : |
| (∑ i, ∑ j, (trace ((p.canonicalOutput R i j).value Set.univ)).re) = 1 := by |
| have h := congrArg (fun X : Matrix (ι × η) (ι × η) ℂ => (trace X).re) |
| (p.canonicalOutput_sum R hR) |
| simpa only [Matrix.trace_sum,Complex.re_sum,Matrix.trace_transpose,hR.2,Complex.one_re] using h |
| |
| 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 purifiedOutput (P : Matrix (ι × η) κ ℂ) (i j : K) : PositiveMatrixMeasure (ℕ → M) κ := |
| (p.probeOutput i j).filter (purificationFilter P) |
| |
| omit inst11008_10 inst11008_11 in |
| lemma purifiedOutput_event [Nonempty ι] [Nonempty η] (P : Matrix (ι × η) κ ℂ) |
| (i j : K) (S : Set (ℕ → M)) (hS : MeasurableSet S) : |
| (p.purifiedOutput P i j).value S = |
| ∫ x in d.sampler.publicRecord ⁻¹' S, |
| purificationFilter P * p.completeReference i j x * (purificationFilter P)ᴴ ∂d.probeLaw := by |
| rw [purifiedOutput,PositiveMatrixMeasure.filter_value,p.probeOutput_event i j S hS, |
| integral_filter _ (p.completeReference_integrable i j).integrableOn] |
| |
| lemma purifiedOutput_ac (P : Matrix (ι × η) κ ℂ) (i j : K) |
| (S : Set (ℕ → M)) (hS : MeasurableSet S) (hz : d.transcriptLaw S = 0) : |
| (p.purifiedOutput P 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.purifiedOutput_event P i j S hS,Measure.restrict_eq_zero.mpr hp,integral_zero_measure] |
| |
| lemma purifiedOutput_normalized (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (P : Matrix (ι × η) κ ℂ) (hP : P * Pᴴ = R) : |
| (trace (∑ i, ∑ j, (p.purifiedOutput P i j).value Set.univ)).re = 1 := by |
| obtain ⟨L,hpos,htr,he⟩ := purification_filter_recovery R hR P hP |
| have hh i j : trace ((p.purifiedOutput P i j).value Set.univ) = |
| trace ((p.canonicalOutput R i j).value Set.univ) := by |
| rw [← htr] |
| simpa only [purifiedOutput, canonicalOutput, PositiveMatrixMeasure.filter_value] using |
| congrArg trace (he ((p.probeOutput i j).value Set.univ)) |
| simp_rw [Matrix.trace_sum,Complex.re_sum,hh] |
| simpa only [Matrix.trace_sum,Complex.re_sum] using p.canonicalOutput_normalized R hR |
| |
| def purifiedOutputDensity (P : Matrix (ι × η) κ ℂ) (ν : Measure (ℕ → M)) (i j : K) : |
| (ℕ → M) → Matrix κ κ ℂ := (p.purifiedOutput P i j).positiveDensity ν |
| |
| end FiniteProtocol |
| |
| end |
| |
| section |
| |
| 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 Ω} |
| |
| universe v11171_0 v11171_1 |
| |
| structure KeyDensity (μ : Measure Ω) (K : Type v11171_0) (ι : Type v11171_1) [Fintype K] [Fintype ι] [DecidableEq ι] where |
| block : K → K → Ω → Matrix ι ι ℂ |
| measurable : ∀ a b, Measurable (block a b) |
| positive : ∀ a b t, (block a b t).PosSemidef |
| integrable : ∀ a b, Integrable (fun t => (trace (block a b t)).re) μ |
| normalized : (∑ a, ∑ b, ∫ t, (trace (block a b t)).re ∂μ) = 1 |
| |
| universe v11179_0 |
| |
| structure EveDensity (μ : Measure Ω) (ι : Type v11179_0) [Fintype ι] [DecidableEq ι] where |
| block : Ω → Matrix ι ι ℂ |
| measurable : Measurable block |
| positive : ∀ t, (block t).PosSemidef |
| integrable : Integrable (fun t => (trace (block t)).re) μ |
| normalized : (∫ t, (trace (block t)).re ∂μ) = 1 |
| |
| namespace KeyDensity |
| |
| variable (τ υ : KeyDensity μ K ι) (sigma : EveDensity μ ι) |
| |
| def idealError : ℝ := cqDistance τ.block (fun a b t => idealFiniteBlocks (sigma.block t) a b) μ |
| |
| def distance : ℝ := cqDistance τ.block υ.block μ |
| |
| end KeyDensity |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| 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 κ] |
| |
| def FiniteProtocol.purifiedKeyDensity |
| (p : FiniteProtocol (ι := ι) (η := η) (K := K) d A B TA TB CA CB) |
| (R : Matrix (ι × η) (ι × η) ℂ) (hR : Density R) |
| (P : Matrix (ι × η) κ ℂ) (hP : P * Pᴴ = R) |
| (ν : Measure (ℕ → M)) [SigmaFinite ν] (hμν : d.transcriptLaw ≪ ν) : KeyDensity ν K κ where |
| block := p.purifiedOutputDensity P ν |
| measurable := fun i j => (p.purifiedOutput P i j).measurable_positiveDensity ν |
| positive := fun i j => (p.purifiedOutput P i j).positiveDensity_pos ν |
| integrable := fun i j => (p.purifiedOutput P i j).integrable_positiveDensity_trace ν |
| (fun S hS hz => p.purifiedOutput_ac P i j S hS (hμν hz)) |
| normalized := by |
| have he i j := (p.purifiedOutput P i j).integral_positiveDensity_trace ν |
| (fun S hS hz => p.purifiedOutput_ac P i j S hS (hμν hz)) |
| change (∑ i, ∑ j, ∫ t, (trace ((p.purifiedOutput P i j).positiveDensity ν t)).re ∂ν) = 1 |
| simp_rw [he] |
| simpa only [Matrix.trace_sum,Complex.re_sum] using p.purifiedOutput_normalized R hR P hP |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| section |
| |
| universe u |
| |
| def KeyWord : ℕ → Type |
| | 0 => Unit |
| | n+1 => Bool × KeyWord n |
| |
| instance keyWordFintype (n : ℕ) : Fintype (KeyWord n) := by |
| induction n with |
| | zero => exact inferInstanceAs (Fintype Unit) |
| | succ n ih => letI := ih; exact inferInstanceAs (Fintype (Bool × KeyWord n)) |
| |
| instance keyWordDecidableEq (n : ℕ) : DecidableEq (KeyWord n) := by |
| induction n with |
| | zero => exact inferInstanceAs (DecidableEq Unit) |
| | succ n ih => letI := ih; exact inferInstanceAs (DecidableEq (Bool × KeyWord n)) |
| |
| instance keyWordNonempty (n : ℕ) : Nonempty (KeyWord n) := by |
| induction n with |
| | zero => exact inferInstanceAs (Nonempty Unit) |
| | succ n ih => let := ih; exact inferInstanceAs (Nonempty (Bool × KeyWord n)) |
| |
| instance keyWordMeasurableSpace (n : ℕ) : MeasurableSpace (KeyWord n) := by |
| induction n with |
| | zero => exact inferInstanceAs (MeasurableSpace Unit) |
| | succ n ih => letI := ih; exact inferInstanceAs (MeasurableSpace (Bool × KeyWord n)) |
| |
| instance keyWordMeasurableSingletonClass (n : ℕ) : MeasurableSingletonClass (KeyWord n) := by |
| induction n with |
| | zero => exact inferInstanceAs (MeasurableSingletonClass Unit) |
| | succ n ih => let := ih; exact inferInstanceAs (MeasurableSingletonClass (Bool × KeyWord n)) |
| |
| structure QuantumMemory where |
| Carrier : Type u |
| additive : AddCommGroup Carrier |
| complexModule : Module ℂ Carrier |
| unit : One Carrier |
| order : LE Carrier |
| |
| attribute [instance] QuantumMemory.additive QuantumMemory.complexModule QuantumMemory.unit QuantumMemory.order |
| |
| instance : CoeSort QuantumMemory (Type u) := ⟨QuantumMemory.Carrier⟩ |
| |
| structure ClassicalRecordSpace where |
| Carrier : Type u |
| measurableSpace : MeasurableSpace Carrier |
| standardBorel : StandardBorelSpace Carrier |
| nonempty : Nonempty Carrier |
| |
| attribute [instance] ClassicalRecordSpace.measurableSpace ClassicalRecordSpace.standardBorel ClassicalRecordSpace.nonempty |
| |
| instance : CoeSort ClassicalRecordSpace (Type u) := ⟨ClassicalRecordSpace.Carrier⟩ |
| |
| end |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator |
| |
| universe u |
| |
| structure KeyImplementation (a b ell : ℕ) (messages : ClassicalRecordSpace.{u}) where |
| outcomes : ClassicalRecordSpace.{u} |
| discussion : Discussion outcomes messages |
| memoryA : ℕ → QuantumMemory.{u} |
| memoryB : ℕ → QuantumMemory.{u} |
| incomingMemoryA : QuantumMemory.{u} |
| incomingMemoryB : QuantumMemory.{u} |
| outgoingMemoryA : QuantumMemory.{u} |
| outgoingMemoryB : QuantumMemory.{u} |
| protocol : FiniteProtocol (ι := Fin a) (η := Fin b) (K := KeyWord ell) discussion |
| (fun n => memoryA n) (fun n => memoryB n) |
| incomingMemoryA incomingMemoryB outgoingMemoryA outgoingMemoryB |
| |
| 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 ≪ ν) |
| |
| def output : KeyDensity ν (KeyWord ell) (Fin e) := |
| p.protocol.purifiedKeyDensity R hR P hP ν hμν |
| |
| end KeyImplementation |
| |
| def IsCompletedKeyOutput {a b ell e : ℕ} [Nonempty (Fin a)] [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)) [SigmaFinite ν] |
| (τ : KeyDensity ν (KeyWord ell) (Fin e)) : Prop := |
| ∃ p : ℕ → KeyImplementation a b ell messages, |
| ∃ _hAC : ∀ j, (p j).discussion.transcriptLaw ≪ ν, |
| Tendsto (fun j => cqDistance |
| (fun a b => positiveEntryDensity |
| (publicPurifiedEntries (p j).discussion.probeLaw |
| (p j).discussion.sampler.publicRecord (p j).protocol.completeReference P a b) ν) |
| τ.block ν) atTop (nhds 0) |
| |
| theorem isCompletedKeyOutput_iff_original {a b ell e : ℕ} |
| [Nonempty (Fin a)] [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)) [SigmaFinite ν] |
| (τ : KeyDensity ν (KeyWord ell) (Fin e)) : |
| IsCompletedKeyOutput R hR P hP messages ν τ ↔ |
| ∃ p : ℕ → KeyImplementation a b ell messages, |
| ∃ hAC : ∀ j, (p j).discussion.transcriptLaw ≪ ν, |
| Tendsto (fun j => ((p j).output R hR P hP ν (hAC j)).distance τ) atTop (nhds 0) := |
| Iff.rfl |
| |
| structure CompletedKeyTrial {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) (ell : ℕ) where |
| messages : ClassicalRecordSpace.{u} |
| eveDim : ℕ |
| purification : Matrix (Fin a × Fin b) (Fin eveDim) ℂ |
| prepares : purification * purificationᴴ = R |
| referenceMeasure : Measure (ℕ → messages) |
| sigmaFinite : SigmaFinite referenceMeasure |
| actual : KeyDensity referenceMeasure (KeyWord ell) (Fin eveDim) |
| completed : @IsCompletedKeyOutput _ _ _ _ _ _ R hR purification prepares |
| messages referenceMeasure sigmaFinite actual |
| ideal : EveDensity referenceMeasure (Fin eveDim) |
| |
| 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) |
| |
| def error : ℝ := p.actual.idealError p.ideal |
| |
| end CompletedKeyTrial |
| |
| end |
| |
| section |
| |
| open scoped ComplexOrder MatrixOrder Kronecker |
| |
| open Matrix |
| |
| def groupIndex (a b c d : ℕ) : |
| (Fin (a*c) × Fin (b*d)) ≃ ((Fin a × Fin b) × (Fin c × Fin d)) where |
| toFun i := (((finProdFinEquiv.symm i.1).1,(finProdFinEquiv.symm i.2).1), |
| ((finProdFinEquiv.symm i.1).2,(finProdFinEquiv.symm i.2).2)) |
| invFun i := (finProdFinEquiv (i.1.1,i.2.1),finProdFinEquiv (i.1.2,i.2.2)) |
| left_inv i := by |
| apply Prod.ext <;> exact finProdFinEquiv.apply_symm_apply _ |
| right_inv i := by simp |
| |
| def 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) ℂ) : |
| Matrix (Fin (a*c) × Fin (b*d)) (Fin (a*c) × Fin (b*d)) ℂ := |
| (R ⊗ₖ S).submatrix (groupIndex a b c d) (groupIndex a b c d) |
| |
| lemma trace_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) ℂ) : |
| trace (groupTensor R S) = trace R * trace S := by |
| rw [← trace_kronecker] |
| exact Equiv.sum_comp (groupIndex a b c d) (fun x => (R ⊗ₖ S) x x) |
| |
| lemma Density.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 : Density R) (hS : Density S) : Density (groupTensor R S) := by |
| refine ⟨(hR.1.kronecker hS.1).submatrix _,?_⟩ |
| rw [trace_groupTensor,hR.2,hS.2,one_mul] |
| |
| def copyDim (a : ℕ) : ℕ → ℕ |
| | 0 => a |
| | k+1 => copyDim a k * a |
| |
| lemma copyDim_eq (a k : ℕ) : copyDim a k = a^(k+1) := by |
| induction k with |
| | zero => simp [copyDim] |
| | succ k ih => simp only [copyDim,ih,pow_succ] |
| |
| def positiveCopies {a b : ℕ} (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) : |
| (k : ℕ) → Matrix (Fin (copyDim a k) × Fin (copyDim b k)) |
| (Fin (copyDim a k) × Fin (copyDim b k)) ℂ |
| | 0 => R |
| | k+1 => groupTensor (positiveCopies R k) R |
| |
| end |
| |
| section |
| |
| open Matrix MeasureTheory ProbabilityTheory Filter |
| |
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator ENNReal |
| |
| universe u |
| |
| lemma Density.positiveCopies {a b : ℕ} |
| {R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ} (hR : Density R) (k : ℕ) : |
| Density (positiveCopies R k) := by |
| induction k with |
| | zero => exact hR |
| | succ k ih => exact ih.groupTensor hR |
| |
| instance positiveCopy_nonempty (a k : ℕ) [Nonempty (Fin a)] : Nonempty (Fin (copyDim a k)) := by |
| have ha : 0 < copyDim a k := by |
| induction k with |
| | zero => exact (show 0 < a from Fin.size_positive') |
| | succ k ih => exact Nat.mul_pos ih (show 0 < a from Fin.size_positive') |
| exact ⟨⟨0,ha⟩⟩ |
| |
| structure CompletedKeyScheme {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) where |
| length : ℕ → ℕ |
| trial : (k : ℕ) → CompletedKeyTrial.{u} (positiveCopies R k) (by |
| induction k with |
| | zero => exact hR |
| | succ k ih => |
| refine ⟨(ih.1.kronecker hR.1).submatrix _, ?_⟩ |
| change trace (groupTensor (positiveCopies R k) R) = 1 |
| have ht := Equiv.sum_comp (groupIndex (copyDim a k) (copyDim b k) a b) |
| (fun x => (Matrix.kronecker (positiveCopies R k) R) x x) |
| change trace (groupTensor (positiveCopies R k) R) = trace (Matrix.kronecker (positiveCopies R k) R) at ht |
| rw [ht, Matrix.kronecker, trace_kronecker, ih.2, hR.2, one_mul]) (length k) |
| |
| 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) |
| |
| def error (k : ℕ) : ℝ := (s.trial k).error |
| |
| def Secure : Prop := Tendsto s.error atTop (nhds 0) |
| |
| def lowerRate : ℝ≥0∞ := liminf (fun k : ℕ => (s.length k : ℝ≥0∞) / (k+1 : ℕ)) atTop |
| |
| end CompletedKeyScheme |
| |
| def distillableSecretKey {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) : ℝ≥0∞ := |
| sSup {r | r = 0 ∨ ∃ s : CompletedKeyScheme.{u} R hR, s.Secure ∧ r = s.lowerRate} |
|
|
| end |
|
|
| open Matrix MeasureTheory ProbabilityTheory Filter |
|
|
| open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator ENNReal |
|
|
| universe u |
|
|
| def UniformProtocolGap {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (_hR : Density R) : Prop := |
| ∀ (k : ℕ) (O M : Type u) [MeasurableSpace O] [MeasurableSpace M] |
| [StandardBorelSpace O] [Nonempty O] [StandardBorelSpace M] [Nonempty M] |
| (d : Discussion O M) (A B : ℕ → Type u) |
| [∀ n, AddCommGroup (A n)] [∀ n, Module ℂ (A n)] [∀ n, One (A n)] [∀ n, LE (A n)] |
| [∀ n, AddCommGroup (B n)] [∀ n, Module ℂ (B n)] [∀ n, One (B n)] [∀ n, LE (B n)] |
| (TA TB CA CB : Type u) |
| [AddCommGroup TA] [Module ℂ TA] [One TA] [LE TA] |
| [AddCommGroup TB] [Module ℂ TB] [One TB] [LE TB] |
| [AddCommGroup CA] [Module ℂ CA] [One CA] [LE CA] |
| [AddCommGroup CB] [Module ℂ CB] [One CB] [LE CB] |
| (p : BitProtocol (ι := Fin (copyDim a k)) (η := Fin (copyDim b k)) d A B TA TB CA CB) |
| (e : ℕ) (P : Matrix (Fin (copyDim a k) × Fin (copyDim b k)) (Fin e) ℂ) |
| (_hP : P * Pᴴ = positiveCopies R k) |
| (sigma : PositiveMatrixMeasure (ℕ → M) (Fin e)), |
| (trace (sigma.value Set.univ)).re = 1 → |
| 1/5 ≤ p.rawPurifiedSecretBitError P sigma |
|
|
| def UniformCompletedGap {a b : ℕ} [Nonempty (Fin a)] [Nonempty (Fin b)] |
| (R : Matrix (Fin a × Fin b) (Fin a × Fin b) ℂ) (hR : Density R) : Prop := |
| ∀ (k ell : ℕ), 0 < ell → |
| ∀ p : CompletedKeyTrial.{u} (positiveCopies R k) (by |
| induction k with |
| | zero => exact hR |
| | succ k ih => |
| refine ⟨(ih.1.kronecker hR.1).submatrix _, ?_⟩ |
| change trace (groupTensor (positiveCopies R k) R) = 1 |
| have ht := Equiv.sum_comp (groupIndex (copyDim a k) (copyDim b k) a b) |
| (fun x => (Matrix.kronecker (positiveCopies R k) R) x x) |
| change trace (groupTensor (positiveCopies R k) R) = trace (Matrix.kronecker (positiveCopies R k) R) at ht |
| rw [ht, Matrix.kronecker, trace_kronecker, ih.2, hR.2, one_mul]) ell, |
| 1/5 ≤ p.error |
|
|
| namespace Explicit |
|
|
| lemma m_pos : 0 < m := by rw [m_eq] |
|
|
| instance output_nonempty : Nonempty (Fin m) := by |
| have hb : 0 < b := by |
| unfold b |
| exact Nat.choose_pos (by decide) |
| have hq : 0 < Q := by unfold Q |
| have hd (q : ℕ) : 0 < dimensionFunction q := pow_pos (by decide) _ |
| have hD : 0 < D := by unfold D |
| have hm (q d : ℕ) (hq : 0 < q) (hd : 0 < d) : |
| 0 < outputDimensionFunction q d := Nat.mul_pos hq hd |
| exact ⟨⟨0, by unfold m |
|
|
| def MainClaim : Prop := |
| ∃ hR : Density rhoFin, ¬ Separable rhoFin ∧ |
| distillableSecretKey.{u} rhoFin hR = 0 ∧ |
| UniformProtocolGap.{u} rhoFin hR ∧ |
| UniformCompletedGap.{u} rhoFin hR |
|
|
| end Explicit |
|
|
| end ZeroKey |
|
|
| end |
|
|
| end OAI |
|
|
