| import OAI.Probability.InvariantIsing.Fields.CascadeSeedTree |
|
|
| namespace OAI |
|
|
| /-! The full retained finite vector cascade is realized by ancestor-dependent seeds. -/ |
| noncomputable section |
| open MeasureTheory ProbabilityTheory IsingPerceptron |
| open scoped NNReal ENNReal |
| namespace InvariantIsing |
|
|
| theorem cascadeSeedTree_retained_law {ι : Type} [Fintype ι] |
| (n : ℕ) (b : ℕ → ℝ) (μ : ℕ → ProbabilityMeasure (ι → ℝ)) |
| (c : ℕ → (ι → ℝ) × (ι → ℝ) → ℝ) |
| (ψ : ℕ → (ι → ℝ) → unitInterval → (ι → ℝ)) |
| (hc : ∀ i, Measurable (c i)) (hψ : ∀ i, Measurable (Function.uncurry (ψ i))) |
| (hcpos : ∀ i z a, 0 < c i (z,a)) |
| (hm : ∀ i z, (∫⁻ a, ENNReal.ofReal (c i (z,a)^b i) ∂(μ i : Measure (ι → ℝ))) = 1) |
| (hseed : ∀ i z, volume.map (ψ i z) = (μ i : Measure (ι → ℝ)).withDensity |
| (fun a => ENNReal.ofReal (c i (z,a)^b i))) (z : ι → ℝ) : |
| (noiseCascadeLaw unitInterval n b (fun _ => cascadeSeedLaw) : |
| Measure (NoiseTree unitInterval n)).map (cascadeSeedTree n b ψ z) = |
| (noiseCascadeLaw (ι → ℝ) n b μ : Measure (NoiseTree (ι → ℝ) n)).map |
| (noiseTreeKeep n b μ c (fun _ p => p.1+p.2) z) := by |
| induction n generalizing b μ c ψ z with |
| | zero => |
| change (Measure.dirac (PUnit.unit : PUnit)).map (fun _ => PUnit.unit) = |
| (Measure.dirac (PUnit.unit : PUnit)).map (fun _ => PUnit.unit) |
| rfl |
| | succ n ih => |
| let bs := fun j => b (j+1) |
| let ms := fun j => μ (j+1) |
| let cs := fun j => c (j+1) |
| let ps := fun j => ψ (j+1) |
| let Q : Measure (NoiseTree unitInterval n) := |
| noiseCascadeLaw unitInterval n bs (fun _ => cascadeSeedLaw) |
| let P : Measure (NoiseTree (ι → ℝ) n) := noiseCascadeLaw (ι → ℝ) n bs ms |
| let ρ : Measure (ι → ℝ) := (μ 0 : Measure (ι → ℝ)).withDensity |
| (fun a => ENNReal.ofReal (c 0 (z,a)^b 0)) |
| let : IsProbabilityMeasure ρ := ⟨by |
| change ((μ 0 : Measure (ι → ℝ)).withDensity _ ) Set.univ = 1 |
| rw [withDensity_apply _ MeasurableSet.univ, setLIntegral_univ] |
| exact hm 0 z⟩ |
| let : IsProbabilityMeasure Q := by |
| change IsProbabilityMeasure (noiseCascadeLaw unitInterval n bs (fun _ => cascadeSeedLaw) : Measure (NoiseTree unitInterval n)) |
| infer_instance |
| let : IsProbabilityMeasure P := by |
| change IsProbabilityMeasure (noiseCascadeLaw (ι → ℝ) n bs ms : Measure (NoiseTree (ι → ℝ) n)) |
| infer_instance |
| let G : (ι → ℝ) × NoiseTree unitInterval n → NoiseTree (ι → ℝ) n := |
| fun p => cascadeSeedTree n bs ps (z+p.1) p.2 |
| let H : (ι → ℝ) × NoiseTree (ι → ℝ) n → NoiseTree (ι → ℝ) n := |
| fun p => noiseTreeKeep n bs ms cs (fun _ p => p.1+p.2) (z+p.1) p.2 |
| have hG : Measurable G := (measurable_cascadeSeedTree n bs ps (fun i => hψ (i+1))).comp |
| ((measurable_const.add measurable_fst).prodMk measurable_snd) |
| have hH : Measurable H := |
| (measurable_noiseTreeKeep n bs ms (fun i => hc (i+1)) |
| (fun _ => measurable_fst.add measurable_snd)).comp |
| ((measurable_const.add measurable_fst).prodMk measurable_snd) |
| have hsub a : Q.map (fun q => G (a,q)) = P.map (fun p => H (a,p)) := |
| ih bs ms cs ps (fun i => hc (i+1)) (fun i => hψ (i+1)) |
| (fun i => hcpos (i+1)) (fun i => hm (i+1)) (fun i => hseed (i+1)) (z+a) |
| have hf : Measurable (ψ 0 z) := (hψ 0).comp (measurable_const.prodMk measurable_id) |
| have hlaw : (cascadeSeedLaw : Measure unitInterval).map (ψ 0 z) = ρ := hseed 0 z |
| have hpair := ancestor_fiber_map_product (cascadeSeedLaw : Measure unitInterval) ρ Q P hf hlaw hG hH hsub |
| have hmap : Measurable (fun p : unitInterval × NoiseTree unitInterval n => |
| (ψ 0 z p.1,G (ψ 0 z p.1,p.2))) := |
| (hf.comp measurable_fst).prodMk (hG.comp ((hf.comp measurable_fst).prodMk measurable_snd)) |
| rw [cascadeSeedTree_law_succ n b ψ hψ z, |
| noiseTreeKeep_law_succ n b μ (u := fun (_ : ℕ) (p : (ι → ℝ) × (ι → ℝ)) => p.1+p.2) |
| hc (fun _ => measurable_fst.add measurable_snd) hcpos z] |
| apply poissonLaw_congr |
| change (((powerIntensity (b 0)).prod ((cascadeSeedLaw : Measure unitInterval).prod Q)).map |
| (Prod.map id (fun p => (ψ 0 z p.1,G (ψ 0 z p.1,p.2))))) = |
| (powerIntensity (b 0)).prod |
| ((((μ 0 : Measure (ι → ℝ)).prod P).withDensity |
| (fun p => ENNReal.ofReal (c 0 (z,p.1)^b 0))).map (fun p => (p.1,H p))) |
| rw [← Measure.map_prod_map _ _ measurable_id hmap, Measure.map_id, hpair] |
| congr 1 |
| congr 1 |
| exact prod_withDensity_left |
| ((((hc 0).comp (measurable_const.prodMk measurable_id)).pow_const (b 0)).ennreal_ofReal) |
|
|
| end InvariantIsing |
|
|
| end |
|
|
| end OAI |
|
|
