| import OAI.Probability.FKMaps.MarkedSpines |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open List Set MeasureTheory ProbabilityTheory |
| open scoped BigOperators ENNReal |
| namespace FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma CriticalEvenOffspring.code_singleton (p : CriticalEvenOffspring) (n : ℕ) |
| (d : Code (2*n+1)) : p.codeLaw n {d}=ENNReal.ofReal (codeWeight p d/codePartition p (2*n+1)) := by |
| rw [← ofReal_measureReal,← integral_indicator_one (measurableSet_singleton d),p.code_integral] |
| simp [Set.indicator] |
|
|
| lemma CriticalEvenOffspring.marked_singleton {A : Type*} [MeasurableSpace A] |
| [MeasurableSingletonClass A] (p : CriticalEvenOffspring) (κ : ℕ → PMF A) (n : ℕ) |
| (d : Code (2*n+1)) (a : Fin (2*n+1) → A) : |
| p.markedCodeLaw (fun k => (κ k).toMeasure) n {(d,a)}= |
| ENNReal.ofReal (codeWeight p d/codePartition p (2*n+1)) * ∏ i,κ (d.val i).val (a i) := by |
| have he : ({(d,a)} : Set (Code (2*n+1)×(Fin (2*n+1) → A)))={d}×ˢ{a} := by ext x;simp |
| rw [he,CriticalEvenOffspring.markedCodeLaw,Measure.compProd_apply_prod |
| (measurableSet_singleton _) (measurableSet_singleton _),lintegral_singleton] |
| simp only [codeMarkKernel,Kernel.coe_mk,codeMarkLaw,Measure.pi_singleton ] |
| simp_rw [PMF.toMeasure_apply_singleton _ _ (measurableSet_singleton _)] |
| rw [p.code_singleton,mul_comm] |
| |
| end FKCRT.TreeCoding |
| namespace FKCRT.Inventory |
| open FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
| |
| namespace CoreTree |
| |
| lemma word_length_degrees (T : CoreTree) : T.word.length=T.degrees.sum := by |
| induction T with |
| | leaf => simp [word,degrees,labels,CoreLabel.arity] |
| | branch c ts ih => |
| have hw : (branch c ts).word.length=∑ i,(1+(ts i).word.length) := by |
| simp [word,cornerInsert,cornerList,List.length_flatMap,List.map_ofFn,List.sum_ofFn, |
| add_comm] |
| have hd : (branch c ts).degrees.sum=c.val.length+∑ i,(ts i).degrees.sum := by |
| simp [degrees,labels_branch,CoreLabel.arity,List.flatMap_def,List.map_flatten, |
| List.sum_flatten,List.map_ofFn,List.sum_ofFn] |
| rw [hw,hd] |
| simp_rw [ih] |
| simp [Finset.sum_add_distrib] |
|
|
| lemma labels_length (T : CoreTree) : T.labels.length=T.word.length+1 := by |
| have h := T.shape.degrees_sum |
| rw [T.shape_degrees,← T.word_length_degrees] at h |
| simpa only [degrees,List.length_map] using h.symm |
|
|
| def toCode (T : CoreTree) : Code T.labels.length := |
| ⟨fun i => ⟨(T.labels[i.val]).arity,by |
| have hm : (T.labels[i.val]).arity∈T.shape.degrees := by |
| rw [T.shape_degrees] |
| exact List.mem_map.mpr ⟨_,List.getElem_mem _,rfl⟩ |
| have hl := T.shape.degree_lt_length hm |
| simpa only [shape_degrees,degrees,List.length_map] using hl⟩,by |
| rw [isTreeCode_iff] |
| convert T.degrees_excursion using 1 |
| unfold degreeList PlaneTree.incrementWord degrees |
| simp only [List.map_map,Function.comp_def] |
| exact List.ofFn_getElem_eq_map T.labels (fun c => (c.arity:ℤ)-1)⟩ |
|
|
| abbrev MarkedCode (N : ℕ) := {x : Code N × (Fin N → CoreLabel) // ∀ i,(x.2 i).arity=(x.1.val i).val} |
|
|
| abbrev Sized (N : ℕ) := {T : CoreTree // T.labels.length=N} |
|
|
| def ofMarkedCode {N : ℕ} (x : MarkedCode N) : CoreTree := |
| labelEquiv.symm ⟨List.ofFn x.val.2,by |
| have h : (List.ofFn x.val.2).map CoreLabel.arity=List.ofFn (fun i => (x.val.1.val i).val) := by |
| simp only [List.map_ofFn,Function.comp_def] |
| exact congrArg List.ofFn (funext x.property) |
| rw [h,PlaneTree.incrementWord_ofFn] |
| exact (isTreeCode_iff _).mp x.val.1.property⟩ |
|
|
| lemma ofMarkedCode_labels {N : ℕ} (x : MarkedCode N) : |
| (ofMarkedCode x).labels=List.ofFn x.val.2 := |
| congrArg Subtype.val (labelEquiv.apply_symm_apply _) |
|
|
| lemma ofMarkedCode_size {N : ℕ} (x : MarkedCode N) : (ofMarkedCode x).labels.length=N := by |
| rw [ofMarkedCode_labels,List.length_ofFn] |
|
|
| lemma ofMarkedCode_injective (N : ℕ) : Function.Injective (@ofMarkedCode N) := by |
| intro x y h |
| have hl := congrArg labels h |
| rw [ofMarkedCode_labels,ofMarkedCode_labels] at hl |
| have ha : x.val.2=y.val.2 := List.ofFn_injective hl |
| have hd : x.val.1=y.val.1 := by |
| apply Subtype.ext |
| funext i |
| apply Fin.ext |
| rw [← x.property i,← y.property i,ha] |
| exact Subtype.ext (Prod.ext hd ha) |
|
|
| def sizedEquiv (N : ℕ) : MarkedCode N ≃ Sized N := Equiv.ofBijective |
| (fun x => ⟨ofMarkedCode x,ofMarkedCode_size x⟩) ⟨by |
| intro x y h |
| exact ofMarkedCode_injective N (congrArg Subtype.val h),by |
| rintro ⟨T,hT⟩ |
| subst N |
| let d : Code T.labels.length := T.toCode |
| let a : Fin T.labels.length → CoreLabel := fun i => T.labels[i.val] |
| have ha : List.ofFn a=T.labels := List.ofFn_getElem |
| have hcomp : ∀ i,(a i).arity=(d.val i).val := fun _ => rfl |
| refine ⟨⟨(d,a),hcomp⟩,Subtype.ext ?_⟩ |
| apply labels_injective |
| rw [ofMarkedCode_labels,ha]⟩ |
|
|
| end CoreTree |
|
|
| /-- The actual conditioned independent marking density, with no change of |
| root distribution and no appeal to a conditional GW law as a hypothesis. -/ |
| theorem actual_marked_singleton (P : Parameters) (n : ℕ) |
| (d : Code (2*n+1)) (a : Fin (2*n+1) → CoreLabel) : |
| (actualOffspring P).markedCodeLaw (fun k => (CoreLabel.markLaw P k).toMeasure) n {(d,a)}= |
| (if ∀ i,(a i).arity=(d.val i).val then ∏ i,CoreLabel.rootLaw P (a i) else 0)/ |
| ENNReal.ofReal (codePartition (actualOffspring P) (2*n+1)) := by |
| rw [CriticalEvenOffspring.marked_singleton,ENNReal.ofReal_div_of_pos |
| (codePartition_odd_pos _ n)] |
| have hw : ENNReal.ofReal (codeWeight (actualOffspring P) d)= |
| ∏ i,(actualOffspring P).law (d.val i).val := by |
| unfold codeWeight |
| rw [ENNReal.ofReal_prod_of_nonneg (fun _ _ => (actualOffspring P).nonneg _)] |
| simp only [CriticalEvenOffspring.law_apply] |
| rw [hw] |
| simp only [div_eq_mul_inv] |
| rw [mul_right_comm,CoreLabel.product_disintegration] |
| by_cases h : ∀ i,(a i).arity=(d.val i).val |
| · rw [ite_eq_left h,ite_eq_left h] |
| · rw [ite_eq_right h,ite_eq_right h] |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open List Set MeasureTheory ProbabilityTheory |
| open scoped BigOperators ENNReal |
| namespace FKCRT.Inventory |
| open FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| namespace CoreTree |
|
|
| /-- The actual successful words and compatible independently marked tree |
| codes are equivalent at each fixed total edge size. -/ |
| def sizedWordEquiv (N : ℕ) : Sized (N+1) ≃ {w : EmptyTypedWord // w.val.length=N} := |
| Equiv.ofBijective (fun T => ⟨wordEquiv T.val,by |
| have h := T.val.labels_length |
| have hT := T.property |
| change T.val.word.length=N |
| omega⟩) ⟨by |
| intro T U h |
| exact Subtype.ext (word_injective (congrArg (fun w => w.val.val) h)),by |
| rintro ⟨w,hw⟩ |
| let T := wordEquiv.symm w |
| have hT : T.word=w.val := congrArg Subtype.val (wordEquiv.apply_symm_apply w) |
| refine ⟨⟨T,?_⟩,Subtype.ext (Subtype.ext hT)⟩ |
| rw [T.labels_length,hT,hw]⟩ |
|
|
| abbrev SizedWord (N : ℕ) := {w : EmptyTypedWord // w.val.length=N} |
|
|
| def markedWordEquiv (N : ℕ) : MarkedCode (N+1) ≃ SizedWord N := |
| (sizedEquiv (N+1)).trans (sizedWordEquiv N) |
|
|
| lemma markedWordEquiv_word (N : ℕ) (x : MarkedCode (N+1)) : |
| ((markedWordEquiv N) x).val.val=(ofMarkedCode x).word := rfl |
|
|
| lemma rootMass_product (P : Parameters) {N : ℕ} (x : MarkedCode N) : |
| (∏ i,CoreLabel.rootMass P (x.val.2 i))= |
| wordMonomial (flexParameter P) (Real.sqrt (radiusParameter P)) (ofMarkedCode x).word/emptyTotal P := by |
| have h := (ofMarkedCode x).productMass_eq (flexParameter P) |
| (Real.sqrt (radiusParameter P)) (emptyTotal P) (emptyTotal_pos P).ne' |
| rw [productMass_labels,ofMarkedCode_labels,List.map_ofFn,List.prod_ofFn] at h |
| exact h |
|
|
| lemma rootLaw_product (P : Parameters) {N : ℕ} (x : MarkedCode N) : |
| (∏ i,CoreLabel.rootLaw P (x.val.2 i))=ENNReal.ofReal |
| (wordMonomial (flexParameter P) (Real.sqrt (radiusParameter P)) (ofMarkedCode x).word/emptyTotal P) := by |
| rw [← rootMass_product] |
| rw [ENNReal.ofReal_prod_of_nonneg (fun _ _ => CoreLabel.rootMass_nonneg P _)] |
| rfl |
|
|
| end CoreTree |
|
|
| /-- Complete pointwise finite-law density, now expressed in the word of the |
| original map bijection. Every leaf, every admissible arity and the common |
| normalizing factor are retained. -/ |
| theorem actual_marked_word_density (P : Parameters) (n : ℕ) |
| (x : CoreTree.MarkedCode (2*n+1)) : |
| (actualOffspring P).markedCodeLaw (fun k => (CoreLabel.markLaw P k).toMeasure) n {x.val}= |
| ENNReal.ofReal (wordMonomial (flexParameter P) (Real.sqrt (radiusParameter P)) |
| ((CoreTree.markedWordEquiv (2*n)) x).val.val/emptyTotal P)/ |
| ENNReal.ofReal (codePartition (actualOffspring P) (2*n+1)) := by |
| rw [actual_marked_singleton P n x.val.1 x.val.2,ite_eq_left x.property, |
| CoreTree.rootLaw_product P x] |
| rfl |
|
|
| /-- There is no positive mass on inconsistent marks. In particular the |
| arbitrary mark at an impossible offspring value is irrelevant. -/ |
| theorem actual_marked_compatible (P : Parameters) (n : ℕ) : |
| ∀ᵐ x ∂(actualOffspring P).markedCodeLaw (fun k => (CoreLabel.markLaw P k).toMeasure) n, |
| ∀ i,(x.2 i).arity=(x.1.val i).val := by |
| rw [ae_iff_of_countable] |
| intro x hx |
| by_contra hc |
| have h := actual_marked_singleton P n x.1 x.2 |
| rw [ite_eq_right hc,ENNReal.zero_div] at h |
| exact hx h |
|
|
| end FKCRT.Inventory |
| end |
|
|
| end OAI |
|
|
