Download data/lean/OAI/InformationTheory/SecretKey/Model.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 299 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/InformationTheory/SecretKey/Model.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/InformationTheory/SecretKey/Model.lean
-
curl -L -o Model.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/InformationTheory/SecretKey/Model.lean
299 kB
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;1,0]
def pauliY : Matrix (Fin 2) (Fin 2) ℂ := !![0,-Complex.I;Complex.I,0]
def pauliZ : Matrix (Fin 2) (Fin 2) ℂ := !![1,0;0,-1]
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]; exact trivialProjection_projection a
· rw [h]; exact contextProjection_projection t a
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]; exact trivialProjection_sum
· rw [h]; exact contextProjection_sum t
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 <;> by_cases hxt : x∈t <;> simp [hxs,hxt]
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; intro i
apply Measurable.of_eval; intro j
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; intro i _
apply integrable_finsetSum; intro j _
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; intro i _
rw [integral_finsetSum _ (fun j _ => ((hF i j).const_mul _).mul_const _)]
apply Finset.sum_congr rfl; intro j _
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]; exact CFC.sqrt_mul_sqrt_self M hM.nonneg
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]; exact norm_eq_sqrt_re_inner (𝕜 := ℂ) (v i)
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]; exact norm_inner_le_norm _ _
_ ≤ 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; intro s _
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; intro i _; ring
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; intro s _
apply Finset.sum_congr rfl; intro t _
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 <;> cases j <;> simp
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; simp [s]
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]; exact Nat.mul_pos Q_pos D_pos
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; exact pow_pos hb 3
have hd (q : ℕ) : 0 < dimensionFunction q := pow_pos (by decide) _
have hD : 0 < D := by unfold D; exact hd Q
have hm (q d : ℕ) (hq : 0 < q) (hd : 0 < d) :
0 < outputDimensionFunction q d := Nat.mul_pos hq hd
exact ⟨⟨0, by unfold m; exact hm Q D hq hD⟩⟩
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
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