lean/OAI/InformationTheory/SecretKey/Extensions.lean

import OAI.InformationTheory.SecretKey.KeyRate

namespace OAI

noncomputable section

namespace UnrestrictedQuantum

open Matrix MeasureTheory ProbabilityTheory Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator

universe v11816_0 v11816_1 v11816_2

variable {K : Type v11816_0} {A : Type v11816_1} {ι : Type v11816_2} [inst11816_0 : MeasurableSpace K] [inst11816_1 : MeasurableSingletonClass K] [inst11816_2 : DecidableEq K]
  [inst11816_3 : AddCommGroup A] [inst11816_4 : Module ℂ A] [inst11816_5 : One A] [inst11816_6 : Preorder A]
  [inst11816_7 : Fintype ι] [inst11816_8 : DecidableEq ι]

def deterministicInstrument (k : K) : ObservableInstrument K A A := by
  classical
  exact {
    operation := fun E => if k ∈ E then LinearMap.id else 0
    positive := by
      intro E hE x hx
      by_cases h : k ∈ E
      · simpa only [h, ite_eq_left, LinearMap.id_apply] using hx
      · simp only [h]; exact le_rfl
    total_unit := by simp
  }

def deterministicRun (k : K) (S : ReferenceFunctional A ι)
    (hS : PositiveFunctional S) (hn : trace (S 1) = 1) :
    InstrumentRun (deterministicInstrument (A := A) k) S where
  law := Measure.dirac k
  probability := inferInstance
  posterior _ := S
  posterior_positive _ := hS
  posterior_trace _ := hn
  integrable _ _ _ := integrable_const _
  update E hE x i j := by
    by_cases h : k ∈ E
    · simp [deterministicInstrument,h,Measure.real, Measure.dirac_apply', hE]
    · simp [deterministicInstrument,h,Measure.real, Measure.dirac_apply', hE]

omit inst11816_1 inst11816_7 inst11816_8 in
lemma deterministic_event [MeasurableSingletonClass K] [Fintype ι] [DecidableEq ι] (k l : K) (S : ReferenceFunctional A ι) :
    S ((deterministicInstrument (A := A) k).operation {l} 1) =
      if k = l then S 1 else 0 := by
  by_cases h : k = l <;> simp [deterministicInstrument,h]

universe v11853_0

variable {Ω : Type v11853_0} {L : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω}
  {μ : Measure Ω} {F : Filtration ℕ mΩ} {U : ℕ → Ω → Matrix ι ι ℂ}

def scalarReference (G : Matrix ι ι ℂ) : ReferenceFunctional ℂ ι where
  toFun z := z • G
  map_add' z w := add_smul z w G
  map_smul' z w := by simp [smul_smul]

omit inst11816_7 inst11816_8 in
lemma scalarReference_positive [Fintype ι] [DecidableEq ι] {G : Matrix ι ι ℂ} (hG : G.PosSemidef) :
    PositiveFunctional (scalarReference G) := by
  intro z hz
  exact hG.smul hz

omit inst11816_7 inst11816_8 in
@[simp] lemma scalarReference_one [Fintype ι] [DecidableEq ι] (G : Matrix ι ι ℂ) : scalarReference G 1 = G := one_smul _ _

def scalarIncoming (G : Ω → Matrix ι ι ℂ)
    (hG : ∀ x, ZeroKey.Density (G x)) (hm : Measurable[L] G)
    (hc : ∀ n E, MeasurableSet[F n] E →
      (∫ x in E, G x ∂μ) = ∫ x in E, U n x ∂μ) :
    IncomingObservableProcess (L := L) (A := ℂ) μ F U where
  state x := scalarReference (G x)
  positive x := scalarReference_positive (hG x).1
  positive_unit := zero_le_one
  normalized x := by simpa using (hG x).2
  local_measurable := by simpa using hm
  causality := by simpa using hc

namespace IncomingObservableProcess

variable (e : IncomingObservableProcess (L := L) (A := A) μ F U)
  [inst11884_0 : Fintype K] [inst11884_1 : Nonempty K]

def classicalReadout (f : Ω → K) (hf : Measurable[L] f) : e.FiniteReadout (K := K) (B := A) where
  instrument x := deterministicInstrument (f x)
  run x := deterministicRun (f x) (e.state x) (e.positive x) (e.normalized x)
  positive_unit := e.positive_unit
  local_measurable k := by
    simp_rw [deterministic_event]
    exact e.local_measurable.ite (measurableSet_eq_fun hf measurable_const) measurable_const

omit inst11884_1 in
lemma classicalReadout_value [Nonempty K] (f : Ω → K) (hf : Measurable[L] f) (k : K) (x : Ω) :
    (e.classicalReadout f hf).value k x = if f x = k then e.state x 1 else 0 :=
  deterministic_event _ _ _

end IncomingObservableProcess

end UnrestrictedQuantum

namespace ZeroKey

section

open MeasureTheory Matrix Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator ProbabilityTheory ENNReal NNReal Topology

universe v11915_0 v11915_1

variable {Ω : Type v11915_0} {ι : Type v11915_1} {mΩ : MeasurableSpace Ω} [inst11915_0 : Fintype ι] [inst11915_1 : DecidableEq ι]
  {μ : Measure Ω} [inst11915_2 : IsFiniteMeasure μ] (F : Filtration ℕ mΩ)

structure ConsistentReferenceHistory where
  finiteMeasure : (n : ℕ) → @PositiveMatrixMeasure Ω ι (F n) _
  traceLaw : ∀ n, @PositiveMatrixMeasure.traceMeasure Ω ι (F n) _ (finiteMeasure n) = μ.trim (F.le n)
  consistency : ∀ n k, n ≤ k → ∀ S, MeasurableSet[F n] S →
    @PositiveMatrixMeasure.value Ω ι (F n) _ (finiteMeasure n) S =
      @PositiveMatrixMeasure.value Ω ι (F k) _ (finiteMeasure k) S

namespace ConsistentReferenceHistory

variable {F}

variable (H : ConsistentReferenceHistory (ι := ι) (μ := μ) F)

def finiteValue (n : ℕ) (S : Set Ω) : Matrix ι ι ℂ :=
  @PositiveMatrixMeasure.value Ω ι (F n) _ (H.finiteMeasure n) S

def density (n : ℕ) : Ω → Matrix ι ι ℂ :=
  @PositiveMatrixMeasure.density Ω ι (F n) _ (H.finiteMeasure n) (μ.trim (F.le n))

omit inst11915_2 in
lemma measurable_density [IsFiniteMeasure μ] (n : ℕ) : Measurable[F n] (H.density n) :=
  @PositiveMatrixMeasure.measurable_density Ω ι (F n) _ _ (H.finiteMeasure n) _

lemma measurable_entry (n : ℕ) (i j : ι) : Measurable[F n] (fun ω => H.density n ω i j) := by
  let L : Matrix ι ι ℂ →L[ℂ] ℂ := (Matrix.entryLinearMap ℂ ℂ i j).toContinuousLinearMap
  exact L.continuous.measurable.comp (H.measurable_density n)

omit inst11915_2 in
lemma integrable_entry [IsFiniteMeasure μ] (n : ℕ) (i j : ι) : Integrable (fun ω => H.density n ω i j) μ :=
  integrable_of_integrable_trim (F.le n)
    (@PositiveMatrixMeasure.integrable_entry Ω ι (F n) _ _ (H.finiteMeasure n) _ i j)

lemma integral_entry (n : ℕ) (S : Set Ω) (hS : MeasurableSet[F n] S) (i j : ι) :
    (∫ ω in S, H.density n ω i j ∂μ) = H.finiteValue n S i j := by
  rw [setIntegral_trim (F.le n) (H.measurable_entry n i j).stronglyMeasurable hS]
  let : MeasurableSpace Ω := F n
  apply (H.finiteMeasure n).integral_density_entry _ _ S hS i j
  intro T hT hμ
  apply (H.finiteMeasure n).value_zero_of_traceMeasure_zero T hT
  rwa [H.traceLaw n]

lemma density_pos (n : ℕ) : ∀ᵐ ω ∂μ, (H.density n ω).PosSemidef := by
  apply ae_of_ae_trim (F.le n)
  let : MeasurableSpace Ω := F n
  apply density_posSemidef_ae (H.finiteMeasure n)
  intro S hS hs
  apply (H.finiteMeasure n).value_zero_of_traceMeasure_zero S hS
  rwa [H.traceLaw n]

lemma density_trace (n : ℕ) : ∀ᵐ ω ∂μ, (trace (H.density n ω)).re = 1 := by
  apply ae_of_ae_trim (F.le n)
  let : MeasurableSpace Ω := F n
  let W := H.finiteMeasure n
  let ν := μ.trim (F.le n)
  have hi := (W.integrable_trace_density ν).re
  apply Integrable.ae_eq_of_forall_setIntegral_eq _ _ hi (integrable_const (1 : ℝ))
  intro S hS _
  change (∫ ω in S, RCLike.re (trace (W.density ν ω)) ∂ν) = _
  rw [integral_re (W.integrable_trace_density ν).integrableOn]
  have hAC : ∀ T, MeasurableSet[F n] T → ν T = 0 → W.value T = 0 := by
    intro T hT hμ
    apply W.value_zero_of_traceMeasure_zero T hT
    rwa [H.traceLaw n]
  rw [W.integral_trace_density ν hAC S hS,integral_const]
  simp only [smul_eq_mul,mul_one]
  change (trace (W.value S)).re = (ν.restrict S).real Set.univ
  rw [← W.traceMeasure_real S hS,H.traceLaw n]
  simp only [Measure.real,Measure.restrict_apply_univ]
  rfl

lemma density_entry_martingale_re (i j : ι) :
    Martingale (fun n ω => (H.density n ω i j).re) F μ := by
  refine ⟨fun n => ((H.measurable_entry n i j).re).stronglyMeasurable, ?_⟩
  intro n k hnk
  symm
  apply ae_eq_condExp_of_forall_setIntegral_eq (F.le n) ((H.integrable_entry k i j).re)
  · intro S _ _
    exact (H.integrable_entry n i j).re.integrableOn
  · intro S hS _
    change (∫ ω in S, RCLike.re (H.density n ω i j) ∂μ) =
      ∫ ω in S, RCLike.re (H.density k ω i j) ∂μ
    rw [integral_re (H.integrable_entry n i j).integrableOn,
      integral_re (H.integrable_entry k i j).integrableOn,
      H.integral_entry n S hS i j,
      H.integral_entry k S ((F.mono hnk) S hS) i j]
    exact congrArg (fun Z : Matrix ι ι ℂ => (Z i j).re) (H.consistency n k hnk S hS)
  · exact ((H.measurable_entry n i j).re).stronglyMeasurable.aestronglyMeasurable

lemma density_entry_martingale_im (i j : ι) :
    Martingale (fun n ω => (H.density n ω i j).im) F μ := by
  refine ⟨fun n => ((H.measurable_entry n i j).im).stronglyMeasurable, ?_⟩
  intro n k hnk
  symm
  apply ae_eq_condExp_of_forall_setIntegral_eq (F.le n) ((H.integrable_entry k i j).im)
  · intro S _ _
    exact (H.integrable_entry n i j).im.integrableOn
  · intro S hS _
    change (∫ ω in S, RCLike.im (H.density n ω i j) ∂μ) =
      ∫ ω in S, RCLike.im (H.density k ω i j) ∂μ
    rw [integral_im (H.integrable_entry n i j).integrableOn,
      integral_im (H.integrable_entry k i j).integrableOn,
      H.integral_entry n S hS i j,
      H.integral_entry k S ((F.mono hnk) S hS) i j]
    exact congrArg (fun Z : Matrix ι ι ℂ => (Z i j).im) (H.consistency n k hnk S hS)
  · exact ((H.measurable_entry n i j).im).stronglyMeasurable.aestronglyMeasurable

theorem full_reference_measure : ∃ V : PositiveMatrixMeasure Ω ι,
    ∀ n S, MeasurableSet[F n] S → V.value S = H.finiteValue n S := by
  obtain ⟨V,hV⟩ := positive_matrix_martingale_extension (H.density)
    H.density_entry_martingale_re H.density_entry_martingale_im H.density_pos
    (fun n => (H.density_trace n).mono (fun _ h => le_of_eq h))
  refine ⟨V,fun n S hS => ?_⟩
  rw [hV n S hS]
  ext i j
  exact H.integral_entry n S hS i j

end ConsistentReferenceHistory

end

section

open Matrix MeasureTheory ProbabilityTheory Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator

section

namespace PositiveMatrixMeasure

universe v12052_0 v12052_1 v12052_2

variable {Ω : Type v12052_0} {T : Type v12052_1} {ι : Type v12052_2} {mΩ : MeasurableSpace Ω} [inst12052_0 : MeasurableSpace T]
  [inst12052_1 : Fintype ι] [inst12052_2 : DecidableEq ι]

def restrictEvent (W : PositiveMatrixMeasure Ω ι) (A : Set Ω) (hA : MeasurableSet A) :
    PositiveMatrixMeasure Ω ι where
  entry i j := (W.entry i j).restrict A
  positive S hS := by
    simpa only [VectorMeasure.restrict_apply _ hA hS] using W.positive (S ∩ A) (hS.inter hA)

omit inst12052_2 in
lemma restrictEvent_value [DecidableEq ι] (W : PositiveMatrixMeasure Ω ι) (A : Set Ω)
    (hA : MeasurableSet A) (S : Set Ω) (hS : MeasurableSet S) :
    (W.restrictEvent A hA).value S = W.value (S ∩ A) := by
  ext i j
  exact VectorMeasure.restrict_apply _ hA hS

omit inst12052_2 in
lemma eq_of_value [DecidableEq ι] (W V : PositiveMatrixMeasure Ω ι)
    (h : ∀ S, MeasurableSet S → W.value S = V.value S) : W = V := by
  have he : W.entry = V.entry := by
    funext i j
    apply VectorMeasure.ext
    intro S hS
    exact congrArg (fun X : Matrix ι ι ℂ => X i j) (h S hS)
  cases W
  cases V
  cases he
  rfl

universe v12080_0

lemma restrictEvent_filter {κ : Type v12080_0} [Fintype κ] [DecidableEq κ]
    (W : PositiveMatrixMeasure Ω ι) (A : Set Ω) (hA : MeasurableSet A)
    (K : Matrix κ ι ℂ) :
    (W.filter K).restrictEvent A hA = (W.restrictEvent A hA).filter K := by
  apply eq_of_value
  intro S hS
  rw [restrictEvent_value _ _ _ _ hS,filter_value,filter_value,
    restrictEvent_value _ _ _ _ hS]

def testMeasure (W : PositiveMatrixMeasure Ω ι) (E : Matrix ι ι ℂ) : Measure Ω :=
  (W.filter (CFC.sqrt E)).traceMeasure

instance testMeasure_finite (W : PositiveMatrixMeasure Ω ι) (E : Matrix ι ι ℂ) :
    IsFiniteMeasure (W.testMeasure E) := inferInstanceAs (IsFiniteMeasure (W.filter (CFC.sqrt E)).traceMeasure)

lemma testMeasure_real (W : PositiveMatrixMeasure Ω ι) (E : Matrix ι ι ℂ)
    (hE : E.PosSemidef) (S : Set Ω) (hS : MeasurableSet S) :
    (W.testMeasure E).real S = (trace (E * W.value S)).re := by
  rw [testMeasure,traceMeasure_real _ S hS,filter_value]
  have hs : (CFC.sqrt E)ᴴ = CFC.sqrt E := (CFC.sqrt_nonneg E).isSelfAdjoint.isHermitian.eq
  rw [hs,Matrix.trace_mul_cycle]
  rw [CFC.sqrt_mul_sqrt_self E hE.nonneg]

def bitReadout (W : PositiveMatrixMeasure Ω ι) (record : Ω → T) (hr : Measurable record)
    (a b : Ω → Bool) (ha : Measurable a) (hb : Measurable b) (i j : Bool) :
    PositiveMatrixMeasure T ι :=
  (W.restrictEvent ((a ⁻¹' {i}) ∩ (b ⁻¹' {j}))
    ((ha (measurableSet_singleton i)).inter (hb (measurableSet_singleton j)))).pushforward record hr

lemma bitReadout_value (W : PositiveMatrixMeasure Ω ι) (record : Ω → T) (hr : Measurable record)
    (a b : Ω → Bool) (ha : Measurable a) (hb : Measurable b) (i j : Bool)
    (S : Set T) (hS : MeasurableSet S) :
    (W.bitReadout record hr a b ha hb i j).value S =
      W.value ((record ⁻¹' S) ∩ ((a ⁻¹' {i}) ∩ (b ⁻¹' {j}))) := by
  rw [bitReadout,pushforward_value _ _ _ S hS,
    restrictEvent_value _ _ _ _ (hr hS)]

universe v12122_0

lemma bitReadout_filter {κ : Type v12122_0} [Fintype κ] [DecidableEq κ]
    (W : PositiveMatrixMeasure Ω ι) (record : Ω → T) (hr : Measurable record)
    (a b : Ω → Bool) (ha : Measurable a) (hb : Measurable b) (i j : Bool)
    (K : Matrix κ ι ℂ) (S : Set T) (hS : MeasurableSet S) :
    ((W.filter K).bitReadout record hr a b ha hb i j).value S =
      ((W.bitReadout record hr a b ha hb i j).filter K).value S := by
  rw [bitReadout_value _ _ _ _ _ _ _ _ _ _ hS,filter_value,filter_value,
    bitReadout_value _ _ _ _ _ _ _ _ _ _ hS]

end PositiveMatrixMeasure

open MeasurableSpace

universe v12136_0

lemma scalar_measure_ext_on_filtration {Ω : Type v12136_0} {mΩ : MeasurableSpace Ω}
    (μ ν : Measure Ω) [IsFiniteMeasure μ] (F : Filtration ℕ mΩ)
    (hm : mΩ = ⨆ n, F n)
    (h : ∀ n S, MeasurableSet[F n] S → μ S = ν S) : μ = ν := 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Ω = generateFrom C := by
    rw [hm]
    apply le_antisymm
    · apply iSup_le; intro n S hS
      exact measurableSet_generateFrom ⟨n,hS⟩
    · apply generateFrom_le
      rintro S ⟨n,hn⟩
      exact (le_iSup (fun n => F n) n) S hn
  exact ext_of_generate_finite C hgen hc (fun S ⟨n,hn⟩ => h n S hn)
    (h 0 Set.univ MeasurableSet.univ)

namespace ConsistentReferenceHistory

universe v12159_0 v12159_1

variable {Ω : Type v12159_0} {ι : Type v12159_1} {mΩ : MeasurableSpace Ω} [inst12159_0 : Fintype ι] [inst12159_1 : DecidableEq ι]
  {μ : Measure Ω} [inst12159_2 : IsFiniteMeasure μ] {F : Filtration ℕ mΩ}
  (H : ConsistentReferenceHistory (ι := ι) (μ := μ) F)

theorem full_reference_born (hm : mΩ = ⨆ n, F n) :
    ∃ W : PositiveMatrixMeasure Ω ι,
      (∀ n S, MeasurableSet[F n] S → W.value S = H.finiteValue n S) ∧
      ∀ (E : Matrix ι ι ℂ), E.PosSemidef → ∀ (ν : Measure Ω) [IsFiniteMeasure ν],
        (∀ n S, MeasurableSet[F n] S →
          (trace (E * H.finiteValue n S)).re = ν.real S) → W.testMeasure E = ν := by
  obtain ⟨W,hW⟩ := H.full_reference_measure
  refine ⟨W,hW,?_⟩
  intro E hE ν hν htests
  apply scalar_measure_ext_on_filtration _ _ F hm
  intro n S hS
  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
  change (W.testMeasure E).real S = ν.real S
  rw [W.testMeasure_real E hE S (F.le n S hS),hW n S hS]
  exact htests n S hS

end ConsistentReferenceHistory

end

namespace PositiveMatrixMeasure

universe v12187_0 v12187_1 v12187_2 v12187_3

variable {Ω : Type v12187_0} {T : Type v12187_1} {ι : Type v12187_2} {α : Type v12187_3} [inst12187_0 : MeasurableSpace Ω] [inst12187_1 : MeasurableSpace T]
  [inst12187_2 : Fintype ι] [inst12187_3 : DecidableEq ι]

omit inst12187_3 in
lemma value_sum_readout [DecidableEq ι] [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α]
    (W : PositiveMatrixMeasure Ω ι) (a : Ω → α) (ha : Measurable a)
    (S : Set Ω) (hS : MeasurableSet S) :
    ∑ i, W.value (S ∩ a ⁻¹' {i}) = W.value S := by
  classical
  have hd : Set.PairwiseDisjoint (↑(Finset.univ : Finset α)) (fun i => S ∩ a ⁻¹' {i}) := by
    intro i _ j _ hij
    apply Set.disjoint_left.mpr
    intro x hi hj
    exact hij (hi.2.symm.trans hj.2)
  have hm : ∀ i ∈ (Finset.univ : Finset α), MeasurableSet (S ∩ a ⁻¹' {i}) :=
    fun i _ => hS.inter (ha (measurableSet_singleton i))
  have hu : (⋃ i ∈ (Finset.univ : Finset α), S ∩ a ⁻¹' {i}) = S := by
    ext x
    simp only [Finset.mem_univ,Set.iUnion_true,Set.mem_iUnion,Set.mem_inter_iff,
      Set.mem_preimage,Set.mem_singleton_iff]
    exact ⟨fun ⟨_,hx,_⟩ => hx, fun hx => ⟨a x,hx,rfl⟩⟩
  ext i j
  simp only [Matrix.sum_apply]
  have h := (W.entry i j).of_biUnion_finset hd hm
  rw [hu] at h
  simpa only [Finset.mem_univ,ite_true,value] using h.symm

lemma bitReadout_total (W : PositiveMatrixMeasure Ω ι) (record : Ω → T) (hr : Measurable record)
    (a b : Ω → Bool) (ha : Measurable a) (hb : Measurable b)
    (S : Set T) (hS : MeasurableSet S) :
    ∑ i, ∑ j, (W.bitReadout record hr a b ha hb i j).value S = W.value (record ⁻¹' S) := by
  simp_rw [bitReadout_value _ _ _ _ _ _ _ _ _ _ hS, ← Set.inter_assoc]
  have hi (i : Bool) : (∑ j, W.value ((record ⁻¹' S ∩ a ⁻¹' {i}) ∩ b ⁻¹' {j})) =
      W.value (record ⁻¹' S ∩ a ⁻¹' {i}) :=
    W.value_sum_readout b hb _ ((hr hS).inter (ha (measurableSet_singleton i)))
  simp_rw [hi]
  exact W.value_sum_readout a ha _ (hr hS)

theorem filtered_bitReadout_normalized [Nonempty ι]
    (W : PositiveMatrixMeasure Ω ι)
    (hprobe : W.value Set.univ = keepReference (outer (localProbe (ι := ι)) localProbe))
    (record : Ω → T) (hr : Measurable record)
    (a b : Ω → Bool) (ha : Measurable a) (hb : Measurable b)
    (R : Matrix ι ι ℂ) (hR : Density R) :
    (trace (∑ i, ∑ j,
      ((W.bitReadout record hr a b ha hb i j).filter (preparationFilter R)).value Set.univ)).re = 1 := by
  have he : (∑ i, ∑ j,
      ((W.bitReadout record hr a b ha hb i j).filter (preparationFilter R)).value Set.univ) =
      ((W.filter (preparationFilter R)).value Set.univ) := by
    simp_rw [← bitReadout_filter _ _ _ _ _ _ _ _ _ _ _ MeasurableSet.univ]
    rw [bitReadout_total _ _ _ _ _ _ _ _ MeasurableSet.univ,Set.preimage_univ]
  rw [he,filter_value,hprobe,← keepReference_filter,preparation_filter_identity,
    canonical_reference R hR.1,Matrix.trace_transpose,hR.2]
  rfl

end PositiveMatrixMeasure

end

section

open Matrix MeasureTheory ProbabilityTheory Function Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker

open UnrestrictedQuantum

universe v12259_0 v12259_1 v12259_2 v12259_3 v12259_4 v12259_5 v12259_6

variable {O : Type v12259_0} {M : Type v12259_1} {ι : Type v12259_2} {η : Type v12259_3} [inst12259_0 : MeasurableSpace O] [inst12259_1 : MeasurableSpace M]
  [inst12259_2 : StandardBorelSpace O] [inst12259_3 : Nonempty O] [inst12259_4 : StandardBorelSpace M] [inst12259_5 : Nonempty M]
  [inst12259_6 : Fintype ι] [inst12259_7 : Fintype η] [inst12259_8 : DecidableEq ι] [inst12259_9 : DecidableEq η]
  {K : Type v12259_4} [inst12259_10 : MeasurableSpace K] [inst12259_11 : MeasurableSingletonClass K]
  [inst12259_12 : Fintype K] [inst12259_13 : DecidableEq K] [inst12259_14 : Nonempty K]
  (d : Discussion O M)
  (A : ℕ → Type v12259_5) (B : ℕ → Type v12259_6)
  [inst12259_15 : ∀ n, AddCommGroup (A n)] [inst12259_16 : ∀ n, Module ℂ (A n)] [inst12259_17 : ∀ n, One (A n)] [inst12259_18 : ∀ n, LE (A n)]
  [inst12259_19 : ∀ n, AddCommGroup (B n)] [inst12259_20 : ∀ n, Module ℂ (B n)] [inst12259_21 : ∀ n, One (B n)] [inst12259_22 : ∀ n, LE (B n)]

structure ClassicalProtocol 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)
  outputA : (ℕ → O) → K
  outputB : (ℕ → O) → K
  measurableA : Measurable[d.sampler.localField true] outputA
  measurableB : Measurable[d.sampler.localField false] outputB

variable {d A B}

namespace ClassicalProtocol

variable (p : ClassicalProtocol (ι := ι) (η := η) (K := K) d A B)

structure Completion where
  G : (ℕ → O) → Matrix ι ι ℂ
  H : (ℕ → O) → Matrix η η ℂ
  measurableG : Measurable[d.sampler.localField true] G
  measurableH : Measurable[d.sampler.localField false] H
  densityG : ∀ x, Density (G x)
  densityH : ∀ x, Density (H x)
  consistentG : ∀ n S, MeasurableSet[historyFiltration n] S →
    (∫ x in S, G x ∂d.probeLaw) = ∫ x in S,
      AdaptiveQuantum.globalLocalReferenceA d.sampler d.kernelA p.executionA n (historyPrefix n x) ∂d.probeLaw
  consistentH : ∀ n S, MeasurableSet[historyFiltration n] S →
    (∫ x in S, H x ∂d.probeLaw) = ∫ x in S,
      AdaptiveQuantum.globalLocalReferenceB d.sampler d.kernelB p.executionB n (historyPrefix n x) ∂d.probeLaw
  reference : PositiveMatrixMeasure (ℕ → O) (ι × η)
  reference_value : ∀ S, MeasurableSet S → reference.value S = ∫ x in S, G x ⊗ₖ H x ∂d.probeLaw
  reference_prefix : ∀ n S, MeasurableSet[historyFiltration n] S →
    reference.value S = ∫ x in S,
      AdaptiveQuantum.jointReference d.sampler d.kernelA d.kernelB p.executionA p.executionB
        n (historyPrefix n x) ∂d.probeLaw

omit inst12259_4 inst12259_5 inst12259_11 inst12259_12 inst12259_13 inst12259_14 in
lemma completion_exists [StandardBorelSpace M] [Nonempty M] [MeasurableSingletonClass K] [Fintype K] [DecidableEq K] [Nonempty K] : Nonempty p.Completion := by
  obtain ⟨G,H,hGm,hHm,hG,hH,hGc,hHc,W,hW,hWc⟩ :=
    AdaptiveQuantum.full_reference_extension d.sampler d.kernelA d.kernelB p.executionA p.executionB
      d.probeLaw d.probeLaw_prefix
  exact ⟨⟨G,H,hGm,hHm,hG,hH,hGc,hHc,W,hW,hWc⟩⟩

def completion : p.Completion := Classical.choice p.completion_exists

def toFinite : FiniteProtocol (ι := ι) (η := η) (K := K) d A B ℂ ℂ ℂ ℂ where
  executionA := p.executionA
  executionB := p.executionB
  initialA := p.initialA
  initialB := p.initialB
  incomingA := scalarIncoming p.completion.G p.completion.densityG p.completion.measurableG p.completion.consistentG
  incomingB := scalarIncoming p.completion.H p.completion.densityH p.completion.measurableH p.completion.consistentH
  readoutA := (scalarIncoming p.completion.G p.completion.densityG p.completion.measurableG
    p.completion.consistentG).classicalReadout p.outputA p.measurableA
  readoutB := (scalarIncoming p.completion.H p.completion.densityH p.completion.measurableH
    p.completion.consistentH).classicalReadout p.outputB p.measurableB

lemma completeReference_value (i j : K) (x : ℕ → O) :
    p.toFinite.completeReference i j x =
      if p.outputA x = i ∧ p.outputB x = j then p.completion.G x ⊗ₖ p.completion.H x else 0 := by
  simp only [FiniteProtocol.completeReference, toFinite,
    IncomingObservableProcess.classicalReadout_value, scalarIncoming]
  by_cases ha : p.outputA x = i <;> by_cases hb : p.outputB x = j <;>
    simp [ha,hb,scalarReference_one]

theorem output_event (i j : K) (S : Set (ℕ → M)) (hS : MeasurableSet S) :
    (p.toFinite.probeOutput i j).value S = p.completion.reference.value
      ((d.sampler.publicRecord ⁻¹' S) ∩ (p.outputA ⁻¹' {i} ∩ p.outputB ⁻¹' {j})) := by
  have ha := p.measurableA.mono (d.sampler.localField_le true) le_rfl
  have hb := p.measurableB.mono (d.sampler.localField_le false) le_rfl
  have he := (ha (measurableSet_singleton i)).inter (hb (measurableSet_singleton j))
  rw [p.toFinite.probeOutput_event i j S hS,p.completion.reference_value _
    ((d.sampler.measurable_publicRecord hS).inter he)]
  have hind : (fun x => p.toFinite.completeReference i j x) =
      (p.outputA ⁻¹' {i} ∩ p.outputB ⁻¹' {j}).indicator
        (fun x => p.completion.G x ⊗ₖ p.completion.H x) := by
    funext x
    simp only [p.completeReference_value,Set.indicator,Set.mem_inter_iff,Set.mem_preimage,
      Set.mem_singleton_iff]
  rw [hind,integral_indicator he,Measure.restrict_restrict he]
  rw [Set.inter_comm]

theorem canonicalOutput_event (R : Matrix (ι × η) (ι × η) ℂ)
    (i j : K) (S : Set (ℕ → M)) (hS : MeasurableSet S) :
    (p.toFinite.canonicalOutput R i j).value S =
      (p.completion.reference.filter (preparationFilter R)).value
        ((d.sampler.publicRecord ⁻¹' S) ∩ (p.outputA ⁻¹' {i} ∩ p.outputB ⁻¹' {j})) := by
  rw [FiniteProtocol.canonicalOutput,PositiveMatrixMeasure.filter_value,p.output_event i j S hS,
    PositiveMatrixMeasure.filter_value]

end ClassicalProtocol

end

open Matrix MeasureTheory ProbabilityTheory Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator

namespace PositiveMatrixMeasure

universe v12382_0 v12382_1 v12382_2

variable {Ω : Type v12382_0} {T : Type v12382_1} {ι : Type v12382_2} {mΩ : MeasurableSpace Ω} [inst12382_0 : MeasurableSpace T]
  [inst12382_1 : Fintype ι] [inst12382_2 : DecidableEq ι]

lemma value_eq_of_ae_set (W : PositiveMatrixMeasure Ω ι)
    (S U : Set Ω) (hS : MeasurableSet S) (hU : MeasurableSet U)
    (h : S =ᵐ[W.traceMeasure] U) : W.value S = W.value U := by
  ext i j
  rw [← W.integral_density_entry W.traceMeasure W.value_zero_of_traceMeasure_zero S hS i j,
    ← W.integral_density_entry W.traceMeasure W.value_zero_of_traceMeasure_zero U hU i j]
  exact setIntegral_congr_set h

theorem bitReadout_eq_off_private_null (W : PositiveMatrixMeasure Ω ι)
    (record : Ω → T) (hr : Measurable record)
    (a b a' b' : Ω → Bool) (ha : Measurable a) (hb : Measurable b)
    (ha' : Measurable a') (hb' : Measurable b')
    (N : Set Ω) (hN : W.traceMeasure N = 0)
    (hbits : ∀ x, x ∉ N → a x = a' x ∧ b x = b' x)
    (i j : Bool) :
    W.bitReadout record hr a b ha hb i j = W.bitReadout record hr a' b' ha' hb' i j := by
  apply eq_of_value
  intro S hS
  rw [bitReadout_value _ _ _ _ _ _ _ _ _ _ hS,
    bitReadout_value _ _ _ _ _ _ _ _ _ _ hS]
  apply value_eq_of_ae_set _ _ _
    ((hr hS).inter ((ha (measurableSet_singleton i)).inter (hb (measurableSet_singleton j))))
    ((hr hS).inter ((ha' (measurableSet_singleton i)).inter (hb' (measurableSet_singleton j))))
  have hn : ∀ᵐ x ∂W.traceMeasure, x ∉ N := by
    rw [ae_iff]
    simpa only [not_not,Set.ofPred_mem_eq] using hN
  filter_upwards [hn] with x hx
  rcases hbits x hx with ⟨he,hf⟩
  apply propext
  change (record x ∈ S ∧ (a x = i ∧ b x = j)) ↔
    (record x ∈ S ∧ (a' x = i ∧ b' x = j))
  rw [he,hf]

universe v12423_0

theorem prepared_default_outputs {κ : Type v12423_0} [Fintype κ] [DecidableEq κ]
    (V : PositiveMatrixMeasure Ω κ) (W : PositiveMatrixMeasure Ω ι)
    (K : Matrix κ ι ℂ) (F : Filtration ℕ mΩ) (hm : mΩ = ⨆ n, F n)
    (hfinite : ∀ n S, MeasurableSet[F n] S → V.value S = K * W.value S * Kᴴ)
    (record : Ω → T) (hr : Measurable record)
    (a b a' b' : Ω → Bool) (ha : Measurable a) (hb : Measurable b)
    (ha' : Measurable a') (hb' : Measurable b')
    (N : Set Ω) (hN : V.traceMeasure N = 0)
    (hbits : ∀ x, x ∉ N → a x = a' x ∧ b x = b' x)
    (i j : Bool) :
    V.bitReadout record hr a b ha hb i j =
      (W.bitReadout record hr a' b' ha' hb' i j).filter K := by
  rw [V.bitReadout_eq_off_private_null record hr a b a' b' ha hb ha' hb' N hN hbits i j]
  have he : V = W.filter K := by
    exact W.filter_eq_of_filtration V K F hm hfinite
  rw [he]
  apply eq_of_value
  intro S hS
  exact W.bitReadout_filter record hr a' b' ha' hb' i j K S hS

end PositiveMatrixMeasure

end ZeroKey

section

open Matrix MeasureTheory ProbabilityTheory

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator Kronecker TensorProduct

namespace UnrestrictedQuantum

section Algebra

universe v12456_0 v12456_1 v12456_2 v12456_3 v12456_4 v12456_5 v12456_6

variable {A : Type v12456_0} {B : Type v12456_1} {C : Type v12456_2} {D : Type v12456_3}
  [inst12456_0 : AddCommGroup A] [inst12456_1 : Module ℂ A] [inst12456_2 : AddCommGroup B] [inst12456_3 : Module ℂ B]
  [inst12456_4 : AddCommGroup C] [inst12456_5 : Module ℂ C] [inst12456_6 : AddCommGroup D] [inst12456_7 : Module ℂ D]
  {ι : Type v12456_4} {η : Type v12456_5} {κ : Type v12456_6} [inst12456_8 : Fintype ι] [inst12456_9 : Fintype η] [inst12456_10 : Fintype κ]
  [inst12456_11 : DecidableEq ι] [inst12456_12 : DecidableEq η] [inst12456_13 : DecidableEq κ]

omit inst12456_10 inst12456_11 inst12456_12 inst12456_13 in
theorem tensor_filter_precompose [Fintype κ] [DecidableEq ι] [DecidableEq η] [DecidableEq κ]
    (S : ReferenceFunctional A ι) (T : ReferenceFunctional B η)
    (K : Matrix κ (ι × η) ℂ) (L : C →ₗ[ℂ] A) (N : D →ₗ[ℂ] B) :
    (filterFunctional K (tensorReferenceFunctional S T)).comp (TensorProduct.map L N) =
      filterFunctional K (tensorReferenceFunctional (S.comp L) (T.comp N)) := by
  apply TensorProduct.ext'
  intro a b
  simp only [LinearMap.comp_apply, TensorProduct.map_tmul]
  rfl

theorem tensor_filter_event [One C] [One D]
    (S : ReferenceFunctional A ι) (T : ReferenceFunctional B η)
    (K : Matrix κ (ι × η) ℂ) (L : C →ₗ[ℂ] A) (N : D →ₗ[ℂ] B) :
    ((filterFunctional K (tensorReferenceFunctional S T)).comp
      (TensorProduct.map L N)) (1 ⊗ₜ[ℂ] 1) = K * (S (L 1) ⊗ₖ T (N 1)) * Kᴴ := by
  rw [tensor_filter_precompose]
  rfl

end Algebra

universe v12490_0 v12490_1 v12490_2 v12490_3 v12490_4 v12490_5 v12490_6

variable {O : Type v12490_0} {A : Type v12490_1} {B : Type v12490_2} {C : Type v12490_3} {ι : Type v12490_4} {η : Type v12490_5} {κ : Type v12490_6} [inst12490_0 : MeasurableSpace O]
  [inst12490_1 : AddCommGroup A] [inst12490_2 : Module ℂ A] [inst12490_3 : One A] [inst12490_4 : LE A]
  [inst12490_5 : AddCommGroup B] [inst12490_6 : Module ℂ B] [inst12490_7 : One B] [inst12490_8 : LE B]
  [inst12490_9 : AddCommGroup C] [inst12490_10 : Module ℂ C] [inst12490_11 : One C]
  [inst12490_12 : Fintype ι] [inst12490_13 : Fintype η] [inst12490_14 : Fintype κ]
  [inst12490_15 : DecidableEq ι] [inst12490_16 : DecidableEq η] [inst12490_17 : DecidableEq κ]
  (J : ObservableInstrument O A B) (S : ReferenceFunctional A ι)
  (r : InstrumentRun J S) (T : ReferenceFunctional C η)

omit inst12490_11 in
theorem InstrumentRun.tensor_event [One C] (E : Set O) (hE : MeasurableSet E)
    (a : B) (b : C) :
    (∫ o in E, r.posterior o a ⊗ₖ T b ∂r.law) = S (J.operation E a) ⊗ₖ T b := by
  have hi : Integrable (fun o => r.posterior o a ⊗ₖ T b) r.law := by
    apply ZeroKey.integrable_matrix_of_entries
    intro i j
    exact (r.integrable a i.1 j.1).mul_const _
  ext i j
  rw [ZeroKey.integral_matrix_entry hi.integrableOn]
  simp only [Matrix.kroneckerMap_apply]
  rw [integral_mul_const,r.update E hE]

theorem InstrumentRun.filtered_tensor_event (K : Matrix κ (ι × η) ℂ)
    (E : Set O) (hE : MeasurableSet E) (a : B) (b : C) :
    (∫ o in E, K * (r.posterior o a ⊗ₖ T b) * Kᴴ ∂r.law) =
      K * (S (J.operation E a) ⊗ₖ T b) * Kᴴ := by
  have hi : Integrable (fun o => r.posterior o a ⊗ₖ T b) r.law := by
    apply ZeroKey.integrable_matrix_of_entries
    intro i j
    exact (r.integrable a i.1 j.1).mul_const _
  rw [ZeroKey.integral_filter _ hi.integrableOn,InstrumentRun.tensor_event J S r T E hE]

end UnrestrictedQuantum

namespace ZeroKey

open UnrestrictedQuantum

universe v12531_0 v12531_1 v12531_2 v12531_3 v12531_4 v12531_5 v12531_6 v12531_7 v12531_8 v12531_9 v12531_10

variable {O : Type v12531_0} {M : Type v12531_1} {ι : Type v12531_2} {η : Type v12531_3} {κ : Type v12531_4} [inst12531_0 : MeasurableSpace O] [inst12531_1 : MeasurableSpace M]
  [inst12531_2 : StandardBorelSpace O] [inst12531_3 : Nonempty O] [inst12531_4 : StandardBorelSpace M] [inst12531_5 : Nonempty M]
  [inst12531_6 : Fintype ι] [inst12531_7 : Fintype η] [inst12531_8 : Fintype κ] [inst12531_9 : DecidableEq ι] [inst12531_10 : DecidableEq η] [inst12531_11 : DecidableEq κ]
  {d : Discussion O M} {A : ℕ → Type v12531_5} {B : ℕ → Type v12531_6}
  [inst12531_12 : ∀ n, AddCommGroup (A n)] [inst12531_13 : ∀ n, Module ℂ (A n)] [inst12531_14 : ∀ n, One (A n)] [inst12531_15 : ∀ n, LE (A n)]
  [inst12531_16 : ∀ n, AddCommGroup (B n)] [inst12531_17 : ∀ n, Module ℂ (B n)] [inst12531_18 : ∀ n, One (B n)] [inst12531_19 : ∀ n, LE (B n)]
  {TA : Type v12531_7} {TB : Type v12531_8} {CA : Type v12531_9} {CB : Type v12531_10}
  [inst12531_20 : AddCommGroup TA] [inst12531_21 : Module ℂ TA] [inst12531_22 : One TA] [inst12531_23 : LE TA]
  [inst12531_24 : AddCommGroup TB] [inst12531_25 : Module ℂ TB] [inst12531_26 : One TB] [inst12531_27 : LE TB]
  [inst12531_28 : AddCommGroup CA] [inst12531_29 : Module ℂ CA] [inst12531_30 : One CA] [inst12531_31 : LE CA]
  [inst12531_32 : AddCommGroup CB] [inst12531_33 : Module ℂ CB] [inst12531_34 : One CB] [inst12531_35 : LE CB]
  (p : BitProtocol (ι := ι) (η := η) d A B TA TB CA CB)

theorem BitProtocol.filtered_output_event (K : Matrix κ (ι × η) ℂ)
    (i j : Bool) (E : Set (ℕ → M)) (hE : MeasurableSet E) :
    ((p.probeOutput i j).filter K).value E =
      ∫ x in d.sampler.publicRecord ⁻¹' E,
        ((filterFunctional K (tensorReferenceFunctional (p.incomingA.state x) (p.incomingB.state x))).comp
          (TensorProduct.map ((p.readoutA.instrument x).operation {i})
            ((p.readoutB.instrument x).operation {j}))) (1 ⊗ₜ[ℂ] 1) ∂d.probeLaw := by
  rw [PositiveMatrixMeasure.filter_value,p.probeOutput_event i j E hE]
  simp_rw [tensor_filter_event]
  exact (integral_filter _ (p.completeReference_integrable i j).integrableOn).symm

end ZeroKey

end

namespace ZeroKey

open Matrix MeasureTheory ProbabilityTheory Filter

open scoped ComplexOrder MatrixOrder Matrix.Norms.L2Operator

open UnrestrictedQuantum

universe v12573_0 v12573_1 v12573_2 v12573_3 v12573_4 v12573_5

variable {O : Type v12573_0} {M : Type v12573_1} {ι : Type v12573_2} {η : Type v12573_3} [inst12573_0 : MeasurableSpace O] [inst12573_1 : MeasurableSpace M]
  [inst12573_2 : StandardBorelSpace O] [inst12573_3 : Nonempty O] [inst12573_4 : StandardBorelSpace M] [inst12573_5 : Nonempty M]
  [inst12573_6 : Fintype ι] [inst12573_7 : Fintype η] [inst12573_8 : DecidableEq ι] [inst12573_9 : DecidableEq η]
  {d : Discussion O M} {A : ℕ → Type v12573_4} {B : ℕ → Type v12573_5}
  [inst12573_10 : ∀ n, AddCommGroup (A n)] [inst12573_11 : ∀ n, Module ℂ (A n)] [inst12573_12 : ∀ n, One (A n)] [inst12573_13 : ∀ n, LE (A n)]
  [inst12573_14 : ∀ n, AddCommGroup (B n)] [inst12573_15 : ∀ n, Module ℂ (B n)] [inst12573_16 : ∀ n, One (B n)] [inst12573_17 : ∀ n, LE (B n)]

namespace ClassicalProtocol

variable (p : ClassicalProtocol (ι := ι) (η := η) (K := Bool) d A B)

def toBit : BitProtocol (ι := ι) (η := η) d A B ℂ ℂ ℂ ℂ := p.toFinite.toBit id

lemma toBit_completeReference (i j : Bool) (x : ℕ → O) :
    p.toBit.completeReference i j x = p.toFinite.completeReference i j x := rfl

lemma toBit_probeOutput (i j : Bool) : p.toBit.probeOutput i j = p.toFinite.probeOutput i j := by
  apply PositiveMatrixMeasure.eq_of_value
  intro S hS
  rw [p.toBit.probeOutput_event i j S hS,p.toFinite.probeOutput_event i j S hS]
  rfl

universe v12596_0

theorem toBit_purifiedOutput {κ : Type v12596_0} [Fintype κ] [DecidableEq κ]
    (K : Matrix κ (ι × η) ℂ) (i j : Bool) :
    (p.toBit.probeOutput i j).filter K =
      (p.completion.reference.filter K).bitReadout
        d.sampler.publicRecord d.sampler.measurable_publicRecord p.outputA p.outputB
        (p.measurableA.mono (d.sampler.localField_le true) le_rfl)
        (p.measurableB.mono (d.sampler.localField_le false) le_rfl) i j := by
  apply PositiveMatrixMeasure.eq_of_value
  intro S hS
  rw [PositiveMatrixMeasure.bitReadout_value _ _ _ _ _ _ _ _ _ _ hS,
    PositiveMatrixMeasure.filter_value,PositiveMatrixMeasure.filter_value,
    p.toBit_probeOutput,p.output_event i j S hS]

universe v12613_0

theorem prepared_actual_output {κ : Type v12613_0} [Fintype κ] [DecidableEq κ]
    (K : Matrix κ (ι × η) ℂ) (V : PositiveMatrixMeasure (ℕ → O) κ)
    (hfinite : ∀ n S, MeasurableSet[historyFiltration n] S →
      V.value S = K * (∫ x in S,
        AdaptiveQuantum.jointReference d.sampler d.kernelA d.kernelB p.executionA p.executionB
          n (historyPrefix n x) ∂d.probeLaw) * Kᴴ)
    (a b : (ℕ → O) → Bool) (ha : Measurable a) (hb : Measurable b)
    (N : Set (ℕ → O)) (hN : V.traceMeasure N = 0)
    (hbits : ∀ x, x ∉ N → a x = p.outputA x ∧ b x = p.outputB x)
    (i j : Bool) :
    V.bitReadout d.sampler.publicRecord d.sampler.measurable_publicRecord a b ha hb i j =
      (p.toBit.probeOutput i j).filter K := by
  have he : V = p.completion.reference.filter K := by
    apply p.completion.reference.filter_eq_of_filtration V K historyFiltration
    · exact historyFiltration_generates
    · intro n S hS
      rw [p.completion.reference_prefix n S hS]
      exact hfinite n S hS
  rw [V.bitReadout_eq_off_private_null _ _ a b p.outputA p.outputB ha hb
    (p.measurableA.mono (d.sampler.localField_le true) le_rfl)
    (p.measurableB.mono (d.sampler.localField_le false) le_rfl) N hN hbits i j,he,
    p.toBit_purifiedOutput K i j]

end ClassicalProtocol

end ZeroKey

open Matrix MeasureTheory ProbabilityTheory

open scoped ComplexOrder MatrixOrder

namespace UnrestrictedQuantum

universe v12649_0 v12649_1 v12649_2

variable {O : Type v12649_0} {A : Type v12649_1} {ι : Type v12649_2} [inst12649_0 : MeasurableSpace O]
  [inst12649_1 : AddCommGroup A] [inst12649_2 : Module ℂ A] [inst12649_3 : One A] [inst12649_4 : LE A]
  [inst12649_5 : Fintype ι] [inst12649_6 : DecidableEq ι]
  (μ : Measure O) [inst12649_7 : IsProbabilityMeasure μ]
  (positive_scaling : ∀ (r : ℝ), 0 ≤ r → ∀ a : A, 0 ≤ a → 0 ≤ (r : ℂ) • a)

def independentCoinInstrument : ObservableInstrument O A A where
  operation E := (μ.real E : ℂ) • LinearMap.id
  positive E hE a ha := positive_scaling (μ.real E) ENNReal.toReal_nonneg a ha
  total_unit := by simp [Measure.real]

def independentCoinRun (S : ReferenceFunctional A ι) (hS : PositiveFunctional S)
    (hn : trace (S 1) = 1) : InstrumentRun (independentCoinInstrument μ positive_scaling) S where
  law := μ
  probability := inferInstance
  posterior _ := S
  posterior_positive _ := hS
  posterior_trace _ := hn
  integrable _ _ _ := integrable_const _
  update E hE a i j := by
    simp only [independentCoinInstrument,LinearMap.smul_apply,LinearMap.id_apply,
      map_smul,Matrix.smul_apply,integral_const,
      smul_eq_mul,Complex.real_smul]
    simp only [Measure.real, Measure.restrict_apply_univ]

omit inst12649_6 in
lemma independentCoinRun_reference [DecidableEq ι] (S : ReferenceFunctional A ι) (hS : PositiveFunctional S)
    (hn : trace (S 1) = 1) (o : O) (a : A) :
    (independentCoinRun μ positive_scaling S hS hn).posterior o a = S a := rfl

end UnrestrictedQuantum

end

end OAI