| import OAI.Probability.GaussianReplacement.StreamingModel | |
| namespace OAI | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped ENNReal NNReal RealInnerProductSpace Topology | |
| noncomputable section | |
| universe u | |
| namespace CurrentProjection | |
| namespace StreamKernel | |
| open NoiselessRegression unitInterval | |
| namespace CompletedLearner | |
| variable {d M T : ℕ} {K : CompletedLearner d M T} | |
| def Sampling.initialStatus (R : K.Sampling) (u : I) : NoiselessRegression.Learner.RunStatus M := | |
| startStatus (R.initial u) | |
| def Sampling.stepStatus (R : K.Sampling) (s : UnitSphere d) (x : Samples d T) : | |
| ℕ → NoiselessRegression.Learner.RunStatus M → I → NoiselessRegression.Learner.RunStatus M | |
| | 0, a, _ => a | |
| | _+1, .inr done, _ => .inr done | |
| | n+1, .inl a, u => if hn : n < T then | |
| choiceStatus (n+1) (R.transition ((n+1,a),(x ⟨n,hn⟩,⟪x ⟨n,hn⟩,s.val⟫)) u) | |
| else .inl a | |
| lemma Sampling.measurable_initialStatus (R : K.Sampling) : Measurable R.initialStatus := | |
| (measurable_of_countable startStatus).comp R.measurable_initial | |
| lemma Sampling.measurable_stepStatus (R : K.Sampling) (s : UnitSphere d) (x : Samples d T) | |
| (n : ℕ) : Measurable (Function.uncurry (R.stepStatus s x n)) := by | |
| cases n with | |
| | zero => exact measurable_fst | |
| | succ n => | |
| apply measurable_from_prod_countable_right | |
| intro a | |
| cases a with | |
| | inr done => exact measurable_const | |
| | inl a => | |
| by_cases hn : n < T | |
| · change Measurable (fun u : I => if h : n < T then | |
| choiceStatus (n+1) (R.transition ((n+1,a),(x ⟨n,h⟩,⟪x ⟨n,h⟩,s.val⟫)) u) | |
| else Sum.inl a) | |
| simp only [dite_eq_left hn] | |
| exact (measurable_of_countable (choiceStatus (M:=M) (n+1))).comp | |
| R.measurable_transition.of_uncurry_left | |
| · change Measurable (fun u : I => if h : n < T then | |
| choiceStatus (n+1) (R.transition ((n+1,a),(x ⟨n,h⟩,⟪x ⟨n,h⟩,s.val⟫)) u) | |
| else Sum.inl a) | |
| simpa only [dite_eq_right hn] using | |
| (measurable_const : Measurable (fun _ : I => | |
| (Sum.inl a : NoiselessRegression.Learner.RunStatus M))) | |
| lemma Sampling.stepStatus_law (R : K.Sampling) (s : UnitSphere d) (x : Samples d T) | |
| (n : ℕ) (a : NoiselessRegression.Learner.RunStatus M) : | |
| (volume : Measure I).map (R.stepStatus s x (n+1) a) = K.borel.nextLaw s x n a := by | |
| cases a with | |
| | inr done => | |
| change (volume : Measure I).map (fun _ => Sum.inr done) = Measure.dirac (Sum.inr done) | |
| simp | |
| | inl a => | |
| by_cases hn : n < T | |
| · change (volume : Measure I).map (fun u => if h : n < T then | |
| choiceStatus (n+1) (R.transition ((n+1,a),(x ⟨n,h⟩,⟪x ⟨n,h⟩,s.val⟫)) u) | |
| else Sum.inl a) = _ | |
| simp only [nextLaw, dite_eq_left hn] | |
| rw [← R.transition_law ((n+1,a),(x ⟨n,hn⟩,⟪x ⟨n,hn⟩,s.val⟫)), | |
| Measure.map_map (measurable_of_countable _) R.measurable_transition.of_uncurry_left] | |
| rfl | |
| · change (volume : Measure I).map (fun u => if h : n < T then | |
| choiceStatus (n+1) (R.transition ((n+1,a),(x ⟨n,h⟩,⟪x ⟨n,h⟩,s.val⟫)) u) | |
| else Sum.inl a) = _ | |
| simp [nextLaw, hn] | |
| lemma Sampling.foldCoins_law (R : K.Sampling) (s : UnitSphere d) (x : Samples d T) | |
| (n : ℕ) : | |
| (coinLaw n).map (foldCoins R.initialStatus (R.stepStatus s x) n) = K.borel.runLaw s x n := by | |
| induction n with | |
| | zero => | |
| have he := (measurePreserving_eval (fun _ : Fin 1 => (volume : Measure I)) 0).map_eq | |
| change (coinLaw 0).map (fun z => R.initialStatus (z 0)) = K.initial.map startStatus | |
| have hm : Measurable (fun z : Coins 0 => z 0) := measurable_pi_apply 0 | |
| trans ((coinLaw 0).map (fun z => z 0)).map R.initialStatus | |
| · exact (Measure.map_map (μ:=coinLaw 0) R.measurable_initialStatus hm).symm | |
| change ((Measure.pi (fun _ : Fin 1 => (volume : Measure I))).map (fun z => z 0)).map _ = _ | |
| rw [he, ← R.initial_law, | |
| Measure.map_map (measurable_of_countable _) R.measurable_initial] | |
| rfl | |
| | succ n ih => | |
| rw [map_foldCoins_succ _ _ R.measurable_initialStatus (R.measurable_stepStatus s x), ih] | |
| change (K.borel.runLaw s x n).bind _ = (K.borel.runLaw s x n).bind _ | |
| congr 1 | |
| funext a | |
| exact R.stepStatus_law s x n a | |
| lemma Sampling.run_eq_fold (R : K.Sampling) (s : UnitSphere d) (z : Coins (T+1)) | |
| (x : Samples d T) (n : ℕ) (hn : n ≤ T) : | |
| R.program.run s z x n = | |
| foldCoins R.initialStatus (R.stepStatus s x) n | |
| (fun i => z ⟨i.val, lt_of_lt_of_le i.isLt (by omega)⟩) := by | |
| induction n with | |
| | zero => rfl | |
| | succ n ih => | |
| have hn' : n ≤ T := by omega | |
| rw [NoiselessRegression.Learner.run, ih hn'] | |
| simp only [foldCoins, Sampling.stepStatus] | |
| have he : (Fin.init (fun i : Fin (n+2) => z ⟨i.val, lt_of_lt_of_le i.isLt (by omega)⟩)) = | |
| (fun i : Fin (n+1) => z ⟨i.val, lt_of_lt_of_le i.isLt (by omega)⟩) := rfl | |
| rw [he] | |
| cases hstatus : foldCoins R.initialStatus (R.stepStatus s x) n | |
| (fun i : Fin (n+1) => z ⟨i.val, lt_of_lt_of_le i.isLt (by omega)⟩) with | |
| | inr done => rfl | |
| | inl a => | |
| simp only [dite_eq_left (show n < T by omega), Sampling.program, coinIndex, | |
| dite_eq_left (show n+1 < T+2 by omega), choiceStatus] | |
| rfl | |
| lemma Sampling.estimate_law (R : K.Sampling) (s : UnitSphere d) (x : Samples d T) : | |
| (coinLaw (T+1)).map (fun z => R.program.estimate s z x) = K.borel.estimateLaw s x := by | |
| have hr : (fun z : Coins (T+1) => R.program.estimate s z x) = | |
| (fun z => R.output (terminalStatus (T:=T) | |
| (foldCoins R.initialStatus (R.stepStatus s x) T (Fin.init z))) (z (Fin.last (T+1)))) := by | |
| funext z | |
| have he := R.run_eq_fold s z x T le_rfl | |
| change R.output (terminalStatus (T:=T) (R.program.run s z x T)) | |
| (z (Fin.last (T+1))) = _ | |
| rw [he] | |
| rfl | |
| rw [hr] | |
| have hf := measurable_foldCoins _ _ R.measurable_initialStatus (R.measurable_stepStatus s x) T | |
| have ht : Measurable (terminalStatus (M:=M) (T:=T)) := measurable_of_countable _ | |
| trans ((coinLaw T).map (fun w => terminalStatus (T:=T) | |
| (foldCoins R.initialStatus (R.stepStatus s x) T w))).bind | |
| (fun a => (volume : Measure I).map (R.output a)) | |
| · exact map_freshCoin T (fun w => terminalStatus (T:=T) | |
| (foldCoins R.initialStatus (R.stepStatus s x) T w)) R.output (ht.comp hf) R.measurable_output | |
| · have he : (coinLaw T).map (fun w => terminalStatus (T:=T) | |
| (foldCoins R.initialStatus (R.stepStatus s x) T w)) = | |
| ((coinLaw T).map (foldCoins R.initialStatus (R.stepStatus s x) T)).map | |
| (terminalStatus (T:=T)) := (Measure.map_map ht hf).symm | |
| rw [he, R.foldCoins_law s x T] | |
| simp only [R.output_law] | |
| rfl | |
| end CompletedLearner | |
| end StreamKernel | |
| namespace StreamKernel | |
| open NoiselessRegression unitInterval | |
| namespace CompletedLearner | |
| variable {d M T : ℕ} {K : CompletedLearner d M T} | |
| lemma Sampling.uniformSuccess_eq (R : K.Sampling) (ε : ℝ) | |
| [SFinite (NoiselessRegression.uniformSphere d)] [SFinite (sampleLaw d T)] : | |
| R.program.uniformSuccess (coinLaw (T+1)) ε = K.borel.uniformSuccess ε := by | |
| let S : Set (UnitSphere d × (Coins (T+1) × Samples d T)) := | |
| {z | NoiselessRegression.Learner.angularError z.1 (R.program.estimate z.1 z.2.1 z.2.2) ≤ ε} | |
| have hE := measurable_program_estimate R.program R.measurable_initialChoice | |
| R.measurable_program_transition R.measurable_program_output | |
| have hS : MeasurableSet S := by | |
| exact measurableSet_le | |
| (Real.continuous_arccos.measurable.comp | |
| ((measurable_subtype_coe.comp hE).inner measurable_fst.subtype_val)) measurable_const | |
| let P : ((UnitSphere d × Samples d T) × Coins (T+1)) → | |
| UnitSphere d × (Coins (T+1) × Samples d T) := fun z => (z.1.1,(z.2,z.1.2)) | |
| have hp : MeasurePreserving P | |
| (((NoiselessRegression.uniformSphere d).prod (sampleLaw d T)).prod (coinLaw (T+1))) | |
| ((NoiselessRegression.uniformSphere d).prod ((coinLaw (T+1)).prod (sampleLaw d T))) := by | |
| exact ((MeasurePreserving.id (NoiselessRegression.uniformSphere d)).prod | |
| (Measure.measurePreserving_swap (μ:=sampleLaw d T) (ν:=coinLaw (T+1)))).comp | |
| (measurePreserving_prodAssoc _ _ _) | |
| have he := hp.measure_preimage hS.nullMeasurableSet | |
| change _ = _ at he | |
| change ((NoiselessRegression.uniformSphere d).prod ((coinLaw (T+1)).prod (sampleLaw d T))) S = _ | |
| rw [← he, Measure.prod_apply (hp.measurable hS)] | |
| apply lintegral_congr | |
| intro z | |
| change (coinLaw (T+1)) {u | NoiselessRegression.Learner.angularError z.1 | |
| (R.program.estimate z.1 u z.2) ≤ ε} = _ | |
| have hc : MeasurableSet {v : UnitSphere d | | |
| NoiselessRegression.Learner.angularError z.1 v ≤ ε} := | |
| measurableSet_le (Real.continuous_arccos.measurable.comp | |
| (measurable_subtype_coe.inner measurable_const)) measurable_const | |
| have hf : Measurable (fun u : Coins (T+1) => R.program.estimate z.1 u z.2) := | |
| hE.comp (measurable_const.prodMk (measurable_id.prodMk measurable_const)) | |
| calc | |
| _ = ((coinLaw (T+1)).map (fun u => R.program.estimate z.1 u z.2)) | |
| {v | NoiselessRegression.Learner.angularError z.1 v ≤ ε} := | |
| (Measure.map_apply hf hc).symm | |
| _ = _ := by rw [R.estimate_law] | |
| end CompletedLearner | |
| end StreamKernel | |
| end CurrentProjection | |
| end | |
| end OAI | |