lean/OAI/InformationTheory/SecretKey/Sampling.lean

import OAI.InformationTheory.SecretKey.Construction

namespace OAI

noncomputable section

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 κ]

def filterFunctional (K : Matrix κ ι ℂ) (S : ReferenceFunctional A ι) :
    ReferenceFunctional A κ where
  toFun x := K * S x * Kᴴ
  map_add' x y := by rw [map_add, Matrix.mul_add, Matrix.add_mul]
  map_smul' z x := by simp only [map_smul, Matrix.mul_smul, Matrix.smul_mul,
    RingHom.id_apply]

omit inst3096_2 inst3096_5 inst3096_10 inst3096_11 inst3096_12 in
theorem filter_precompose [One A] [One B] [Fintype κ] [DecidableEq ι] [DecidableEq κ] (K : Matrix κ ι ℂ) (S : ReferenceFunctional A ι)
    (L : B →ₗ[ℂ] A) :
    filterFunctional K (S.comp L) = (filterFunctional K S).comp L := rfl

omit inst3096_2 inst3096_5 inst3096_8 inst3096_10 inst3096_11 inst3096_12 in
theorem filter_precompose_two [One A] [One B] [One C] [Fintype κ] [DecidableEq ι] [DecidableEq κ] (K : Matrix κ ι ℂ) (S : ReferenceFunctional A ι)
    (L : B →ₗ[ℂ] A) (M : C →ₗ[ℂ] B) :
    filterFunctional K ((S.comp L).comp M) =
      ((filterFunctional K S).comp L).comp M := rfl

omit inst3096_2 inst3096_11 inst3096_12 in
lemma filter_positive [One A] [DecidableEq ι] [DecidableEq κ] [LE A] (K : Matrix κ ι ℂ)
    {S : ReferenceFunctional A ι} (hS : PositiveFunctional S) :
    PositiveFunctional (filterFunctional K S) := by
  intro x hx
  exact (hS x hx).mul_mul_conjTranspose_same K

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 ι)

namespace InstrumentRun

variable (r : InstrumentRun J S)

omit inst3096_11 in
theorem event_reference [DecidableEq ι] (E : Set O) (hE : MeasurableSet E) :
    (fun i j => ∫ o in E, r.posterior o 1 i j ∂r.law) =
      S (J.operation E 1) := by
  ext i j
  exact r.update E hE 1 i j

omit inst3096_10 inst3096_11 inst3096_12 in
theorem filter_event [Fintype κ] [DecidableEq ι] [DecidableEq κ] (K : Matrix κ ι ℂ) (E : Set O) (hE : MeasurableSet E) :
    (fun i j => ∫ o in E, filterFunctional K (r.posterior o) 1 i j ∂r.law) =
      filterFunctional K S (J.operation E 1) := by
  ext i j
  simp only [filterFunctional, LinearMap.coe_mk, AddHom.coe_mk,
    Matrix.mul_apply, Finset.sum_mul]
  rw [integral_finsetSum _ (fun k _ =>
    integrable_finsetSum _ (fun l _ =>
      (((r.integrable 1 l k).const_mul (K i l)).mul_const (Kᴴ k j)).integrableOn))]
  simp_rw [integral_finsetSum _ (fun l _ =>
    (((r.integrable 1 l _).const_mul (K i l)).mul_const _).integrableOn),
    integral_mul_const, integral_const_mul, r.update E hE]

end InstrumentRun

end UnrestrictedQuantum

open MeasureTheory ProbabilityTheory Set Function unitInterval

open scoped ENNReal

namespace ZeroKey

universe v3238_0 v3238_1 v3238_2

theorem sample_instrument_update {S : Type v3238_0} {O : Type v3238_1} {Z : Type v3238_2} [MeasurableSpace S]
    [MeasurableSpace O] [StandardBorelSpace O] [Nonempty O] [MeasurableSpace Z]
    (κ : Kernel S O) [IsMarkovKernel κ]
    (update : S × O → Z) (hu : Measurable update) :
    ∃ f : S → I → O, Measurable (uncurry f) ∧
      ∀ (μ : Measure S) [IsFiniteMeasure μ],
        (μ.prod (volume : Measure I)).map (fun p => update (p.1, f p.1 p.2)) =
          (μ ⊗ₘ κ).map update := by
  obtain ⟨f,hf,_,hLaw⟩ := sample_instrument_kernel κ
  change Measurable (fun p : S × I => f p.1 p.2) at hf
  refine ⟨f,hf,?_⟩
  intro μ hμ
  rw [← hLaw μ, Measure.map_map hu (measurable_fst.prodMk hf)]
  rfl

lemma uniform_prefix_fresh_independent (n : ℕ) :
    IndepFun (fun u : UniformTape => fun i : Fin n => u i) (fun u => u n) uniformTapeLaw := by
  have h := iIndepFun_infinitePi (P := fun _ : ℕ => (volume : Measure I))
    (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) → I => fun j : Fin n =>
      x ⟨j,Finset.mem_range.mpr j.isLt⟩) from by fun_prop)
    (show Measurable (fun x : (i : ({n} : Finset ℕ)) → I => x ⟨n,by simp⟩) from by fun_prop)
  exact hh'

lemma uniform_tape_eval (n : ℕ) : uniformTapeLaw.map (fun u => u n) = volume :=
  Measure.infinitePi_map_eval _ _

universe v3280_0

structure CausalSampler (O : Type v3280_0) [MeasurableSpace O] where
  step : (n : ℕ) → (Fin n → O) × I → O
  measurable_step : ∀ n, Measurable (step n)

namespace CausalSampler

universe v3285_0

variable {O : Type v3285_0} [inst3285_0 : MeasurableSpace O] (f : CausalSampler O)

def finiteHistory : (n : ℕ) → (Fin n → I) → (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) → I => 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 : UniformTape) : 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 : UniformTape) :
    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) uniformTapeLaw :=
  (uniform_prefix_fresh_independent n).comp (f.measurable_finiteHistory n) measurable_id

lemma prefix_fresh_law (n : ℕ) :
    uniformTapeLaw.map (fun u => (f.history n u,u n)) =
      (uniformTapeLaw.map (f.history n)).prod volume := by
  rw [(f.prefix_fresh_independent n).map_prod_eq_prod_map_map
    (f.measurable_prefix n).aemeasurable (measurable_pi_apply n).aemeasurable,
    uniform_tape_eval]

theorem prefix_law_succ (κ : (n : ℕ) → Kernel (Fin n → O) O)
    [∀ n, IsMarkovKernel (κ n)]
    (hlaw : ∀ n s, volume.map (fun u => f.step n (s,u)) = κ n s)
    (n : ℕ) :
    uniformTapeLaw.map (f.history (n+1)) =
      ((uniformTapeLaw.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 : ((uniformTapeLaw.map (f.history n)).prod (volume : Measure I)).map
      (fun p => (p.1, f.step n p)) = (uniformTapeLaw.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 : I => 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 : UniformTape) (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 : UniformTape) (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, volume.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) = uniformTapeLaw.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) =
      uniformTapeLaw.map (fun _ : UniformTape => 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, volume.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 = uniformTapeLaw.map f.record := by
  let Q := uniformTapeLaw.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 = (uniformTapeLaw.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 CausalSampler

universe v3434_0

theorem exists_causal_sampler {O : Type v3434_0} [MeasurableSpace O]
    [StandardBorelSpace O] [Nonempty O]
    (κ : (n : ℕ) → Kernel (Fin n → O) O) [∀ n, IsMarkovKernel (κ n)] :
    ∃ f : CausalSampler O, ∀ n s, volume.map (fun u => f.step n (s,u)) = κ n s := by
  have h (n : ℕ) := sample_instrument_kernel (κ n)
  choose sample hmeas hlaw hrest using h
  exact ⟨⟨fun n p => sample n p.1 p.2, hmeas⟩, hlaw⟩

end ZeroKey

open MeasureTheory ProbabilityTheory Filter

open scoped ENNReal

namespace ZeroKey

section

universe v3447_0

variable {Ω : Type v3447_0} {mΩ : MeasurableSpace Ω} [inst3447_0 : StandardBorelSpace Ω]
  {μ : Measure Ω} [inst3447_1 : IsFiniteMeasure μ]

lemma condIndep_public_prefixes (ℱ : Filtration ℕ mΩ)
    (A B : MeasurableSpace Ω) (hA : A ≤ mΩ) (hB : B ≤ mΩ)
    (hinitial : CondIndep (ℱ 0) A B (ℱ.le 0) μ)
    (hlocal : ∀ n, ℱ (n+1) ≤ A ⊔ ℱ n ∨ ℱ (n+1) ≤ B ⊔ ℱ n) :
    ∀ n, CondIndep (ℱ n) A B (ℱ.le n) μ := by
  intro n
  induction n with
  | zero => exact hinitial
  | succ n ih =>
    rcases hlocal n with h | h
    · exact condIndep_local_message (ℱ.le n) hA hB (ℱ.mono (Nat.le_succ n)) h ih
    · exact (condIndep_local_message (ℱ.le n) hB hA (ℱ.mono (Nat.le_succ n)) h ih.symm).symm

end

open MeasureTheory ProbabilityTheory

universe v3676_0

variable {Ω : Type v3676_0} {mΩ : MeasurableSpace Ω} [inst3676_0 : StandardBorelSpace Ω]
  {μ : Measure Ω} [inst3676_1 : IsFiniteMeasure μ]

theorem independent_tapes_given_full_transcript (ℱ : Filtration ℕ mΩ)
    (A B : MeasurableSpace Ω) (hA : A ≤ mΩ) (hB : B ≤ mΩ)
    (hinitial : CondIndep (ℱ 0) A B (ℱ.le 0) μ)
    (hlocal : ∀ n, ℱ (n+1) ≤ A ⊔ ℱ n ∨ ℱ (n+1) ≤ B ⊔ ℱ n) :
    CondIndep (⨆ n, ℱ n) (A ⊔ ⨆ n, ℱ n) (B ⊔ ⨆ n, ℱ n)
      (iSup_le fun n => ℱ.le n) μ := by
  have h := condIndep_full_transcript ℱ A B hA hB
    (condIndep_public_prefixes ℱ A B hA hB hinitial hlocal)
  have hC := iSup_le fun n => ℱ.le n
  have h1 := (condIndep_join_public_right hC hB hA h.symm).symm
  exact condIndep_join_public_right hC (sup_le hA hC) hB h1

end ZeroKey

open MeasureTheory ProbabilityTheory Function Set

namespace ZeroKey

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 message (n : ℕ) (ω : U × V) : M :=
  if p.alice 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]
      split
      · exact (p.measA n).comp (measurable_fst.prodMk ih)
      · exact (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
  unfold message
  split
  · exact (p.measA n).comp (measurable_fst.prodMk (p.measurable_prefix n))
  · exact (p.measB n).comp (measurable_snd.prodMk (p.measurable_prefix n))

@[instance_reducible]
def 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_local (n : ℕ) :
    p.field (n+1) ≤ MeasurableSpace.comap Prod.fst ‹MeasurableSpace U› ⊔ p.field n ∨
      p.field (n+1) ≤ MeasurableSpace.comap Prod.snd ‹MeasurableSpace V› ⊔ p.field n := by
  have hp {C : MeasurableSpace (U × V)} (hC : p.field n ≤ C) :
      @Measurable (U × V) (Fin n → M) C _ (p.publicPrefix n) := Measurable.of_comap_le hC
  have hf {C : MeasurableSpace (U × V)}
      (hC : MeasurableSpace.comap Prod.fst ‹MeasurableSpace U› ≤ C) :
      @Measurable (U × V) U C _ Prod.fst := Measurable.of_comap_le hC
  have hg {C : MeasurableSpace (U × V)}
      (hC : MeasurableSpace.comap Prod.snd ‹MeasurableSpace V› ≤ C) :
      @Measurable (U × V) V C _ Prod.snd := Measurable.of_comap_le hC
  cases ha : p.alice n
  · right
    let : MeasurableSpace (U × V) := MeasurableSpace.comap Prod.snd ‹MeasurableSpace V› ⊔ p.field n
    apply Measurable.comap_le
    apply Measurable.of_eval
    intro i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simpa only [publicPrefix, Fin.snoc_last, ha, Bool.false_eq_true, ↓reduceIte, Function.comp_def] using
        (p.measB n).comp ((hg le_sup_left).prodMk (hp le_sup_right))
    · simpa only [publicPrefix, Fin.snoc_castSucc] using (hp le_sup_right).eval (a := j)
  · left
    let : MeasurableSpace (U × V) := MeasurableSpace.comap Prod.fst ‹MeasurableSpace U› ⊔ p.field n
    apply Measurable.comap_le
    apply Measurable.of_eval
    intro i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simpa only [publicPrefix, Fin.snoc_last, ha, ↓reduceIte, Function.comp_def] using
        (p.measA n).comp ((hf le_sup_left).prodMk (hp le_sup_right))
    · simpa only [publicPrefix, Fin.snoc_castSucc] using (hp le_sup_right).eval (a := j)

theorem tapes_conditionally_independent [StandardBorelSpace U] [StandardBorelSpace V]
    (μ : 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
  apply independent_tapes_given_full_transcript p.filtration _ _
    measurable_fst.comap_le measurable_snd.comap_le
  · 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
  · exact p.field_local

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 v3866_0 v3866_1

theorem final_records_conditionally_independent
    [StandardBorelSpace U] [StandardBorelSpace V]
    (μ : Measure U) (ν : Measure V) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    {A : Type v3866_0} {B : Type v3866_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 LocalTapeProgram

end ZeroKey

open MeasureTheory ProbabilityTheory Function Set unitInterval

namespace ZeroKey

theorem selected_tapes_law (alice : ℕ → Bool) :
    (uniformTapeLaw.prod uniformTapeLaw).map
      (fun uv : UniformTape × UniformTape => fun n => if alice n then uv.1 n else uv.2 n) =
      uniformTapeLaw := 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
  let chooseTape : UniformTape × UniformTape → UniformTape :=
    fun uv n => if alice n then uv.1 n else uv.2 n
  have hm : Measurable chooseTape := by
    apply Measurable.of_eval
    intro n
    dsimp [chooseTape]
    split <;> fun_prop
  rw [← hsplit, Measure.map_map hm hs]
  let index : ℕ → Fin 2 × ℕ := fun n => (if alice n then 0 else 1,n)
  have hi : Injective index := by intro a b hab; exact congrArg Prod.snd hab
  have h := Measure.map_infinitePi_infinitePi_of_inj
    (P := fun _ : Fin 2 × ℕ => (volume : Measure I)) hi
  have he : chooseTape ∘ split = fun u n => u (index n) := by
    funext u n
    dsimp [chooseTape,split,index]
    split <;> rfl
  rw [he]
  exact h

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)

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]
      split
      · apply measurable_inl.comp
        split
        · exact (p.sampleA_meas n).comp (((ih.comp hr).prodMk hv).prodMk
            ((measurable_pi_apply n).comp measurable_fst))
        · exact (p.sampleB_meas n).comp (((ih.comp hr).prodMk hv).prodMk
            ((measurable_pi_apply n).comp measurable_fst))
      · exact measurable_const
    · simpa only [privatePrefix,Fin.snoc_castSucc,Function.comp_def] using
        (ih.comp hr).eval (a := j)

def tapeProgram : LocalTapeProgram UniformTape UniformTape M where
  alice := p.alice
  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 privateRecord (a : Bool) (pair : UniformTape × (ℕ → M)) (n : ℕ) : (O ⊕ Unit) :=
  if p.alice n = a then
    let past := fun i : Fin n => pair.2 i
    let privatePast := p.privatePrefix a n (pair.1,past)
    Sum.inl (if a then p.sampleA n ((privatePast,past),pair.1 n)
      else p.sampleB n ((privatePast,past),pair.1 n))
  else Sum.inr ()

lemma measurable_privateRecord (a : Bool) : Measurable (p.privateRecord a) := by
  apply Measurable.of_eval
  intro n
  have hp : Measurable (fun pair : UniformTape × (ℕ → M) => fun i : Fin n => pair.2 i) := by fun_prop
  have hl := (p.measurable_privatePrefix a n).comp (measurable_fst.prodMk hp)
  simp only [privateRecord]
  split
  · apply measurable_inl.comp
    split
    · exact (p.sampleA_meas n).comp ((hl.prodMk hp).prodMk
        ((measurable_pi_apply n).comp measurable_fst))
    · exact (p.sampleB_meas n).comp ((hl.prodMk hp).prodMk
        ((measurable_pi_apply n).comp measurable_fst))
  · exact measurable_const

universe v4032_0 v4032_1

theorem final_records_independent {A : Type v4032_0} {B : Type v4032_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))

lemma measurable_extractPrivate (a : Bool) (n : ℕ) :
    Measurable (p.extractPrivate a n) := by
  apply Measurable.of_eval
  intro i
  unfold extractPrivate
  split
  · exact measurable_inl.comp (measurable_pi_apply i)
  · exact measurable_const

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 = a then Sum.inl z else Sum.inr ()) := by
  funext i
  refine Fin.lastCases ?_ (fun j => ?_) i
  · simp only [extractPrivate,Fin.snoc_last,Fin.val_last]
  · simp only [extractPrivate,Fin.snoc_castSucc,Fin.val_castSucc]

lemma measurable_publicFrom : ∀ n, Measurable (p.publicFrom n) := by
  intro n
  induction n with
  | zero => exact Measurable.of_eval (fun i => Fin.elim0 i)
  | succ n ih =>
    have hr : Measurable (fun x : Fin (n+1) → O => fun i : Fin n => x i.castSucc) := by fun_prop
    apply Measurable.of_eval
    intro i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simp only [publicFrom,Fin.snoc_last]
      split
      · exact (p.sendA_meas n).comp ((((p.measurable_extractPrivate true n).comp hr).prodMk
          (ih.comp hr)).prodMk (measurable_pi_apply (Fin.last n)))
      · exact (p.sendB_meas n).comp ((((p.measurable_extractPrivate false n).comp hr).prodMk
          (ih.comp hr)).prodMk (measurable_pi_apply (Fin.last n)))
    · simpa only [publicFrom,Fin.snoc_castSucc,Function.comp_def] using (ih.comp hr).eval (a := j)

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 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,Fin.snoc_castSucc,Fin.snoc_last]

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 = 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]

def causal : CausalSampler O where
  step n pair := if p.alice n then
    p.sampleA n ((p.extractPrivate true n pair.1,p.publicFrom n pair.1),pair.2) else
    p.sampleB n ((p.extractPrivate false n pair.1,p.publicFrom n pair.1),pair.2)
  measurable_step n := by
    split
    · exact (p.sampleA_meas n).comp ((((p.measurable_extractPrivate true n).comp measurable_fst).prodMk
        ((p.measurable_publicFrom n).comp measurable_fst)).prodMk measurable_snd)
    · exact (p.sampleB_meas n).comp ((((p.measurable_extractPrivate false n).comp measurable_fst).prodMk
        ((p.measurable_publicFrom n).comp measurable_fst)).prodMk measurable_snd)

def selectedTape (uv : UniformTape × UniformTape) (n : ℕ) : I :=
  if p.alice n then uv.1 n else uv.2 n

lemma measurable_selectedTape : Measurable p.selectedTape := by
  apply Measurable.of_eval
  intro n
  unfold selectedTape
  split <;> fun_prop

theorem replay_matches (n : ℕ) (uv : UniformTape × UniformTape) :
    p.publicFrom n (p.causal.history n (p.selectedTape uv)) = p.tapeProgram.publicPrefix n uv ∧
    ∀ a : Bool, p.extractPrivate a n (p.causal.history n (p.selectedTape uv)) =
      p.privatePrefix a n ((if a then uv.1 else uv.2),p.tapeProgram.publicPrefix n uv) := by
  induction n with
  | zero =>
    constructor
    · rfl
    · intro a; funext i; exact Fin.elim0 i
  | succ n ih =>
    have hs : p.causal.step n (p.causal.history n (p.selectedTape uv),p.selectedTape uv n) =
      if p.alice n 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 then
        p.sampleA n ((p.extractPrivate true n (p.causal.history n (p.selectedTape uv)),
          p.publicFrom n (p.causal.history n (p.selectedTape uv))),p.selectedTape uv n)
        else p.sampleB n ((p.extractPrivate false n (p.causal.history n (p.selectedTape uv)),
          p.publicFrom n (p.causal.history n (p.selectedTape uv))),p.selectedTape uv n)) = _
      rw [ih.1,ih.2 true,ih.2 false]
      simp only [Bool.false_eq_true,↓reduceIte,selectedTape]
      split <;> simp_all only []
    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 LocalTapeProgram.message tapeProgram
      split <;> simp_all only [↓reduceIte]
    · intro a
      rw [p.extractPrivate_snoc,ih.2 a,p.tapeProgram.prefix_succ,p.privatePrefix_snoc]
      congr 1
      cases a <;> cases hrole : p.alice n <;>
        simp only [Bool.false_eq_true,Bool.true_eq_false,↓reduceIte]

def outcomeRecord (uv : UniformTape × UniformTape) : ℕ → O :=
  p.causal.record (p.selectedTape uv)

lemma measurable_outcomeRecord : Measurable p.outcomeRecord :=
  p.causal.measurable_record.comp p.measurable_selectedTape

lemma outcomeRecord_law (κ : (n : ℕ) → Kernel (Fin n → O) O)
    [∀ n, IsMarkovKernel (κ n)]
    (hlaw : ∀ n s, 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 ∘ p.selectedTape) = _
  rw [← Measure.map_map p.causal.measurable_record p.measurable_selectedTape]
  congr 1
  exact selected_tapes_law p.alice

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 :=
  if p.alice n = a then Sum.inl (x n) else Sum.inr ()

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
  unfold localRecord
  split
  · exact measurable_inl.comp (measurable_pi_apply n)
  · exact measurable_const

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) (p.selectedTape uv) := by
    funext i
    exact (p.causal.prefix_eq_record (n+1) (p.selectedTape 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)
  rw [p.causal.prefix_succ,p.extractPrivate_snoc,p.tapeProgram.prefix_succ,
    p.privatePrefix_snoc] at h
  simp only [Fin.snoc_last] at h
  have he : p.tapeProgram.publicPrefix n uv = fun i : Fin n => p.tapeProgram.record uv i := by
    funext i; exact p.tapeProgram.prefix_eq_record n uv i
  rw [he] at h
  exact h

universe v4239_0 v4239_1

theorem full_readout_law {A : Type v4239_0} {B : Type v4239_1} [MeasurableSpace A] [MeasurableSpace B]
    (κ : (n : ℕ) → Kernel (Fin n → O) O) [∀ n, IsMarkovKernel (κ n)]
    (hlaw : ∀ n s, 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]

end LocalOutcomeSampler

end ZeroKey

end

end OAI