| import Mathlib |
| import OAI.Probability.LogConcave.Numerics.ChildNoise |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.MeanTree |
| open MeasureTheory ProbabilityTheory OracleCompiler |
| open scoped Classical BigOperators |
|
|
| variable {X : Type*} [MeasurableSpace X] {d : ℕ} |
|
|
| lemma appendSlots_preserving {E : Type*} [MeasurableSpace E] |
| (μ : Measure E) [SigmaFinite μ] (c k : ℕ) : |
| MeasurePreserving (fun z : (Fin c → E) × (Fin k → E) => Fin.append z.1 z.2) |
| ((Measure.pi fun _ : Fin c => μ).prod (Measure.pi fun _ : Fin k => μ)) |
| (Measure.pi fun _ : Fin (c+k) => μ) := by |
| have hm : Measurable (fun z : (Fin c → E) × (Fin k → E) => Fin.append z.1 z.2) := by |
| apply Measurable.of_eval |
| intro i |
| refine Fin.addCases (fun _ => ?_) (fun _ => ?_) i <;> simp only [Fin.append_left,Fin.append_right] <;> fun_prop |
| refine ⟨hm,?_⟩ |
| rw [←(Expression.split_slots_preserving μ c k).map_eq,Measure.map_map hm |
| (Expression.split_slots_preserving μ c k).measurable] |
| have he : (fun z : (Fin c → E) × (Fin k → E) => Fin.append z.1 z.2) ∘ |
| (fun g : Fin (c+k) → E => ((fun i => g (Fin.castAdd k i)),fun i => g (Fin.natAdd c i)))=id := by |
| funext g; exact Fin.append_castAdd_natAdd |
| rw [he,Measure.map_id] |
|
|
| lemma finPi_head_preserving {k : ℕ} {E : Fin (k+1) → Type*} [∀i,MeasurableSpace (E i)] |
| (μ : ∀i,Measure (E i)) [∀i,SigmaFinite (μ i)] : |
| MeasurePreserving (fun z : ∀i,E i => (z 0,fun i : Fin k => z i.succ)) |
| (Measure.pi μ) ((μ 0).prod (Measure.pi fun i : Fin k => μ i.succ)) := by |
| exact measurePreserving_piFinSuccAbove (m:=fun i => inferInstance) μ 0 |
|
|
| abbrev RowTape {k : ℕ} (C : Fin k → Expression X d) (M : Fin k → SeedProgram d) := |
| ∀i,(Fin (C i).slots → Point d) × (Fin (M i).slots → Point d) |
|
|
| def rowLaw {k : ℕ} (C : Fin k → Expression X d) (M : Fin k → SeedProgram d) : Measure (RowTape C M) := |
| Measure.pi fun i => (Measure.pi fun _ : Fin (C i).slots => stdGaussian (Point d)).prod |
| (Measure.pi fun _ : Fin (M i).slots => stdGaussian (Point d)) |
|
|
| instance {k : ℕ} (C : Fin k → Expression X d) (M : Fin k → SeedProgram d) : |
| IsProbabilityMeasure (rowLaw C M) := by unfold rowLaw; infer_instance |
|
|
| def concatTerms (D : ℝ) : (k : ℕ) → (a : Fin k → ℝ) → (C : Fin k → Expression X d) → |
| (M : Fin k → SeedProgram d) → (E : Expression X d) → |
| RowTape C M × (Fin E.slots → Point d) → (Fin (compileTerms D k a C M E).slots → Point d) |
| | 0,_,_,_,_,z => z.2 |
| | k+1,a,C,M,E,z => Fin.append (z.1 0).1 (Fin.append (z.1 0).2 |
| (concatTerms D k (fun i => a i.succ) (fun i => C i.succ) (fun i => M i.succ) E |
| ((fun i => z.1 i.succ),z.2))) |
|
|
| lemma concatTerms_preserving (D : ℝ) (k : ℕ) (a : Fin k → ℝ) |
| (C : Fin k → Expression X d) (M : Fin k → SeedProgram d) (E : Expression X d) : |
| MeasurePreserving (concatTerms D k a C M E) |
| ((rowLaw C M).prod (Measure.pi fun _ : Fin E.slots => stdGaussian (Point d))) |
| (Measure.pi fun _ : Fin (compileTerms D k a C M E).slots => stdGaussian (Point d)) := by |
| induction k with |
| | zero => |
| change MeasurePreserving Prod.snd ((rowLaw C M).prod |
| (Measure.pi fun _ : Fin E.slots => stdGaussian (Point d))) _ |
| exact measurePreserving_snd |
| | succ k ih => |
| let γ := stdGaussian (Point d) |
| let μc := Measure.pi fun _ : Fin (C 0).slots => γ |
| let μm := Measure.pi fun _ : Fin (M 0).slots => γ |
| let μr := rowLaw (fun i : Fin k => C i.succ) (fun i : Fin k => M i.succ) |
| let μe := Measure.pi fun _ : Fin E.slots => γ |
| have h₁ := (finPi_head_preserving (fun i => |
| (Measure.pi fun _ : Fin (C i).slots => γ).prod |
| (Measure.pi fun _ : Fin (M i).slots => γ))).prod (MeasurePreserving.id μe) |
| have h₂ := (measurePreserving_prodAssoc (μc.prod μm) μr μe).comp h₁ |
| have h₃ := ((MeasurePreserving.id (μc.prod μm)).prod |
| (ih (fun i => a i.succ) (fun i => C i.succ) (fun i => M i.succ))).comp h₂ |
| have h₄ := (measurePreserving_prodAssoc μc μm |
| (Measure.pi fun _ : Fin (compileTerms D k (fun i => a i.succ) |
| (fun i => C i.succ) (fun i => M i.succ) E).slots => γ)).comp h₃ |
| have h₅ := ((MeasurePreserving.id μc).prod (appendSlots_preserving γ _ _)).comp h₄ |
| exact (appendSlots_preserving γ _ _).comp h₅ |
|
|
| lemma leftBlock_append {c k t : ℕ} (x : Fin c → Point d) (y : Fin k → Point d) (z : Fin t → Point d) : |
| Expression.leftBlock (Fin.append x (Fin.append y z))=x := by |
| funext i; exact Fin.append_left _ _ i |
| lemma middleBlock_append {c k t : ℕ} (x : Fin c → Point d) (y : Fin k → Point d) (z : Fin t → Point d) : |
| Expression.middleBlock (Fin.append x (Fin.append y z))=y := by |
| funext i |
| change Fin.append x (Fin.append y z) (Fin.natAdd c (Fin.castAdd t i))=y i |
| rw [Fin.append_right,Fin.append_left] |
| lemma rightBlock_append {c k t : ℕ} (x : Fin c → Point d) (y : Fin k → Point d) (z : Fin t → Point d) : |
| Expression.rightBlock (Fin.append x (Fin.append y z))=z := by |
| funext i |
| change Fin.append x (Fin.append y z) (Fin.natAdd c (Fin.natAdd k i))=z i |
| rw [Fin.append_right,Fin.append_right] |
|
|
| lemma eval_concatTerms (V : Point d → ℝ) (D : ℝ) (k : ℕ) (a : Fin k → ℝ) |
| (C : Fin k → Expression X d) (M : Fin k → SeedProgram d) (E : Expression X d) |
| (x : X) (z : RowTape C M × (Fin E.slots → Point d)) : |
| (compileTerms D k a C M E).eval V x (concatTerms D k a C M E z)= |
| (∑i,a i • (M i).program.run V ((C i).eval V x (z.1 i).1,(M i).damping D (z.1 i).2))+ |
| E.eval V x z.2 := by |
| induction k with |
| | zero => simp [compileTerms,concatTerms] |
| | succ k ih => |
| simp only [compileTerms,concatTerms,Expression.eval,leftBlock_append,middleBlock_append, |
| rightBlock_append,ih,Fin.sum_univ_succ,add_assoc] |
| end LogConcaveSampling.MeanTree |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
