Blame for lean/OAI/NumberTheory/PrimePackets/ConditionalFibers.lean

import Mathlib
import OAI.NumberTheory.PrimePackets.LeafAnchors

namespace OAI

section
noncomputable section
open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal
open MeasureTheory Filter Set Module
universe u
open scoped TensorProduct
open Set Module
open MeasureTheory Set
open scoped ENNReal
open IsDiscreteValuationRing IsLocalRing
open scoped ENNReal BigOperators
open MeasureTheory Set IsDiscreteValuationRing
open Filter
open scoped BigOperators Topology
open NumberField
open scoped NumberField nonZeroDivisors
open scoped BigOperators ArithmeticFunction.zeta
open Finset
open scoped BigOperators Classical
open Finset Nat ArithmeticFunction BoundingSieve
open scoped BigOperators Classical
open Finset Nat
open scoped BigOperators
open Filter Topology
open scoped nonZeroDivisors
open Ideal NumberField Finset UniqueFactorizationMonoid
open Filter Set Topology NumberField
open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal NumberField Pointwise nonZeroDivisors
open MeasureTheory Filter Set Module NumberField FractionalIdeal Topology TopologicalSpace
open Filter Set Topology
open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal NumberField Pointwise nonZeroDivisors RealInnerProductSpace
open MeasureTheory Filter Set Module NumberField FractionalIdeal Topology TopologicalSpace Matrix
open MeasureTheory Filter Set Module TopologicalSpace
open MeasureTheory Filter Set
open scoped BigOperators Topology ENNReal
open scoped BigOperators Topology ENNReal Classical
open scoped BigOperators Topology ENNReal Classical Matrix Matrix.Norms.Elementwise
open scoped BigOperators Topology ENNReal Classical Matrix Matrix.Norms.Elementwise Pointwise
open scoped BigOperators Topology ENNReal Classical Matrix Pointwise
open scoped BigOperators Topology ENNReal Classical Matrix
open MeasureTheory ProbabilityTheory Filter Set
open Set Filter
open scoped Topology
open scoped Classical
open scoped Topology ENNReal Classical
open scoped ENNReal Classical
open MeasureTheory Set Topology UniformSpace TopologicalSpace
open scoped ENNReal Topology
open MeasureTheory Filter Set Matrix
open scoped Topology Classical
open scoped Matrix Classical
open scoped Topology Classical Matrix
open scoped Classical Pointwise
open scoped Topology Classical ENNReal
open scoped Matrix Topology Classical
open MeasureTheory ProbabilityTheory Set Filter
open scoped Matrix Topology Classical ENNReal ProbabilityTheory
open scoped ENNReal ProbabilityTheory
open Set Filter Topology
open Set Filter Topology MeasureTheory
open MeasureTheory Set Filter Topology
open MeasureTheory ProbabilityTheory Set Filter Topology
open scoped Matrix ENNReal NNReal ProbabilityTheory
open MeasureTheory
open scoped BigOperators ENNReal
open NumberField Finset
open NumberField Filter Set Topology
open MeasureTheory ProbabilityTheory Matrix
open scoped Classical BigOperators ENNReal
open MeasureTheory Set Filter Topology Module
open scoped BigOperators SchwartzMap
open MeasureTheory Set Filter Topology Module WithLp
open scoped BigOperators SchwartzMap ZeroAtInfty
open scoped FourierTransform
open scoped BigOperators SchwartzMap FourierTransform
open scoped BigOperators FourierTransform
open MeasureTheory Set Filter Topology Module WithLp Asymptotics
open Module WithLp MeasureTheory
open scoped BigOperators Matrix
open Module MeasureTheory
open MeasureTheory Module WithLp
open scoped BigOperators NumberField nonZeroDivisors ENNReal
open Complex Set Metric Filter
open Complex Set Metric Filter MeromorphicOn
open scoped Topology ComplexConjugate
open MeasureTheory Set Filter
open scoped ENNReal BigOperators Topology
open MeasureTheory Set Module
open scoped BigOperators ENNReal NumberField nonZeroDivisors
open scoped BigOperators ENNReal NumberField nonZeroDivisors Topology
open Set
open Filter Set Module MeasureTheory
open scoped Topology NumberField
open Filter Set Module MeasureTheory WithLp
open scoped Topology NumberField BigOperators nonZeroDivisors
open scoped Topology NumberField BigOperators nonZeroDivisors ComplexConjugate
open MeasureTheory Set Filter Module WithLp
open scoped Topology BigOperators NumberField nonZeroDivisors
open Complex Set Filter Module
open Complex
open Complex Set Filter
open scoped Topology NumberField ComplexConjugate
open scoped Topology NumberField ComplexConjugate Classical
open Filter Set Topology Module
open MeasureTheory ProbabilityTheory Set Filter TopologicalSpace
open MeasureTheory MeasureTheory.Measure ProbabilityTheory Set Filter
open scoped Matrix Topology Classical ENNReal NNReal ProbabilityTheory
namespace PrimeDegreePackets
variable {α β γ δ : Type*} [MeasurableSpace α] [MeasurableSpace β]
  [MeasurableSpace γ] [MeasurableSpace δ]

lemma fst_map_fibers_of_measurable (ρ : Measure (α × β))
    (e : α → γ) (he : Measurable e) (F : α × β → δ) (hF : Measurable F) :
    (ρ.map (fun z => (e z.1,F z))).fst = ρ.fst.map e := by
  have hfull : Measurable (fun z : α × β => (e z.1,F z)) := (he.comp measurable_fst).prodMk hF
  rw [Measure.fst,Measure.map_map measurable_fst hfull,
    Measure.fst,Measure.map_map he measurable_fst]
  rfl

lemma compProd_map_fibers_leftInverse (μ : Measure α) [SFinite μ] (κ : Kernel α β)
    [IsFiniteKernel κ] (e : α → γ) (he : Measurable e)
    (r : γ → α) (hr : Measurable r) (hre : Function.LeftInverse r e)
    (F : α × β → δ) (hF : Measurable F) :
    (μ ⊗ₘ κ).map (fun z => (e z.1,F z)) =
      μ.map e ⊗ₘ (mapFibers κ F hF).comap r hr := by
  have hfull : Measurable (fun z : α × β => (e z.1,F z)) := (he.comp measurable_fst).prodMk hF
  ext S hS
  rw [Measure.map_apply hfull hS,Measure.compProd_apply (hfull hS),Measure.compProd_apply hS,
    lintegral_map (Kernel.measurable_kernel_prodMk_left hS) he]
  apply lintegral_congr
  intro a
  rw [Kernel.comap_apply,hre a,mapFibers_apply]
  exact (Measure.map_apply (hF.comp measurable_prodMk_left)
    (show MeasurableSet (Prod.mk (e a) ⁻¹' S) from measurable_prodMk_left hS)).symm

lemma conditional_map_fibers_leftInverse [StandardBorelSpace β] [Nonempty β]
    [StandardBorelSpace δ] [Nonempty δ] (ρ : Measure (α × β)) [IsFiniteMeasure ρ]
    (e : α → γ) (he : Measurable e) (r : γ → α) (hr : Measurable r)
    (hre : Function.LeftInverse r e) (F : α × β → δ) (hF : Measurable F) :
    ∀ᵐ a ∂ρ.fst, (ρ.map (fun z => (e z.1,F z))).condKernel (e a) =
      (ρ.condKernel a).map (fun b => F (a,b)) := by
  let κ := (mapFibers ρ.condKernel F hF).comap r hr
  have heq : ρ.map (fun z => (e z.1,F z)) = (ρ.map (fun z => (e z.1,F z))).fst ⊗ₘ κ := by
    rw [fst_map_fibers_of_measurable ρ e he F hF,
      ←compProd_map_fibers_leftInverse ρ.fst ρ.condKernel e he r hr hre F hF,
      Measure.disintegrate]
  have H := eq_condKernel_of_measure_eq_compProd κ heq
  rw [fst_map_fibers_of_measurable ρ e he F hF] at H
  have H' := ae_of_ae_map he.aemeasurable H
  filter_upwards [H'] with a ha
  simpa only [κ,Kernel.comap_apply,hre a,mapFibers_apply] using ha.symm

 

theorem conditional_map_fibers_embedding [StandardBorelSpace β] [Nonempty β]
    [StandardBorelSpace δ] [Nonempty δ] (ρ : Measure (α × β)) [IsFiniteMeasure ρ]
    (e : α → γ) (he : MeasurableEmbedding e) (F : α × β → δ) (hF : Measurable F) :
    ∀ᵐ a ∂ρ.fst, (ρ.map (fun z => (e z.1,F z))).condKernel (e a) =
      (ρ.condKernel a).map (fun b => F (a,b)) := by
  cases isEmpty_or_nonempty α with
  | inl h => exact ae_of_all _ (fun a => isEmptyElim a)
  | inr h =>
    exact conditional_map_fibers_leftInverse ρ e he.measurable he.invFun
      he.measurable_invFun he.leftInverse_invFun F hF

end PrimeDegreePackets


namespace PrimeDegreePackets
variable {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]

abbrev baseSubtypeMap (U : Set α) : U × β → α × β := fun z => (z.1.val,z.2)

lemma baseSubtypeMap_embedding (U : Set α) (hU : MeasurableSet U) :
    MeasurableEmbedding (baseSubtypeMap (β := β) U) :=
  (MeasurableEmbedding.subtype_coe hU).prodMap MeasurableEmbedding.id

omit [MeasurableSpace α] [MeasurableSpace β] in
lemma baseSubtypeMap_range (U : Set α) :
    Set.range (baseSubtypeMap (β := β) U) = U ×ˢ univ := by
  ext z
  simp only [Set.mem_range,Set.mem_prod,Set.mem_univ,and_true]
  constructor
  · rintro ⟨x,rfl⟩; exact x.1.prop
  · intro hz; exact ⟨(⟨z.1,hz⟩,z.2),Prod.ext rfl rfl⟩

lemma map_comap_baseSubtype (ρ : Measure (α × β)) (U : Set α) (hU : MeasurableSet U) :
    (ρ.comap (baseSubtypeMap U)).map (baseSubtypeMap U) = ρ.restrict (U ×ˢ univ) := by
  rw [(baseSubtypeMap_embedding U hU).map_comap,baseSubtypeMap_range]

lemma fst_map_comap_baseSubtype [StandardBorelSpace β] [Nonempty β]
    (ρ : Measure (α × β)) [IsFiniteMeasure ρ] (U : Set α) (hU : MeasurableSet U) :
    ((ρ.comap (baseSubtypeMap U)).fst).map Subtype.val = ρ.fst.restrict U := by
  rw [←fst_map_fibers_of_measurable _ Subtype.val measurable_subtype_coe Prod.snd measurable_snd]
  change ((ρ.comap (baseSubtypeMap U)).map (baseSubtypeMap U)).fst = _
  rw [map_comap_baseSubtype ρ U hU,restricted_conditional_marginal ρ hU MeasurableSet.univ]
  simp only [measure_univ]
  exact MeasureTheory.withDensity_one

theorem conditional_comap_baseSubtype [StandardBorelSpace β] [Nonempty β]
    (ρ : Measure (α × β)) [IsFiniteMeasure ρ] (U : Set α) (hU : MeasurableSet U) :
    ∀ᵐ a ∂(ρ.comap (baseSubtypeMap U)).fst,
      (ρ.comap (baseSubtypeMap U)).condKernel a = ρ.condKernel a.val := by
  have H₁ := conditional_map_fibers_embedding (ρ.comap (baseSubtypeMap U))
    Subtype.val (MeasurableEmbedding.subtype_coe hU) Prod.snd measurable_snd
  have he : (ρ.comap (baseSubtypeMap U)).map (fun z => (z.1.val,Prod.snd z)) =
      ρ.restrict (U ×ˢ univ) := map_comap_baseSubtype ρ U hU
  have H₂ : ∀ᵐ a ∂ρ.fst.restrict U,
      (ρ.restrict (U ×ˢ univ)).condKernel a = ρ.condKernel a := by
    filter_upwards [restricted_conditional_kernel ρ hU MeasurableSet.univ] with a ha
    simpa only [measure_univ,one_smul,Measure.restrict_univ] using ha
  rw [←fst_map_comap_baseSubtype ρ U hU] at H₂
  have H₂' := ae_of_ae_map measurable_subtype_coe.aemeasurable H₂
  filter_upwards [H₁,H₂'] with a ha hb
  simp only [he] at ha
  exact (Measure.map_id (μ := (ρ.comap (baseSubtypeMap U)).condKernel a)).symm.trans
    (ha.symm.trans hb)

end PrimeDegreePackets


namespace PrimeDegreePackets
variable {n : ℕ} {i j k l : Fin n} {hij : i ≠ j}

lemma rootSliceOverlap_isOpen (γ : G n) :
    IsOpen {s : RootSlice i j k | (γ * s.val).1 l i ≠ 0} := by
  apply isOpen_ne_fun _ continuous_const
  have hc : Continuous (fun s : RootSlice i j k =>
      ((γ * s.val) : Matrix (Fin n) (Fin n) ℝ)) :=
    Matrix.SpecialLinearGroup.isClosedEmbedding_val.continuous.comp
      (show Continuous (fun s : RootSlice i j k => γ * s.val) from
        continuous_const.mul continuous_subtype_val)
  exact (continuous_apply i).comp ((continuous_apply l).comp hc)

abbrev rootOverlapParam (hij : i ≠ j) (γ : G n) : RootSliceOverlap i j k l γ × ℝ → X n :=
  fun z => rootQuotientParametrization hij (z.1.val,z.2)

namespace RootBox

abbrev overlapDomain (A : RootBox hij k) (γ : G n) (l : Fin n) :
    Set (RootSliceOverlap i j k l γ × ℝ) :=
  baseSubtypeMap {s : RootSlice i j k | (γ * s.val).1 l i ≠ 0} ⁻¹' A.domain

def overlapMeasure (A : RootBox hij k) (γ : G n) (l : Fin n) (μ : Measure (X n)) :
    Measure (RootSliceOverlap i j k l γ × ℝ) :=
  (A.coordinateMeasure μ).comap (baseSubtypeMap {s : RootSlice i j k | (γ * s.val).1 l i ≠ 0})

instance overlapMeasure_finite (A : RootBox hij k) (γ : G n) (l : Fin n)
    (μ : Measure (X n)) [IsFiniteMeasure μ] : IsFiniteMeasure (A.overlapMeasure γ l μ) := by
  unfold overlapMeasure
  infer_instance

lemma overlapDomain_open (A : RootBox hij k) (γ : G n) (l : Fin n) :
    IsOpen (A.overlapDomain γ l) :=
  (A.transverse_open.prod A.time_open).preimage
    ((continuous_subtype_val.comp continuous_fst).prodMk continuous_snd)

lemma overlapMeasure_apply (A : RootBox hij k) (γ : G n) (l : Fin n)
    (μ : Measure (X n)) {S : Set (RootSliceOverlap i j k l γ × ℝ)} (hS : MeasurableSet S) :
    A.overlapMeasure γ l μ S =
      μ (rootOverlapParam hij γ '' (S ∩ A.overlapDomain γ l)) := by
  let U := {s : RootSlice i j k | (γ * s.val).1 l i ≠ 0}
  have he := baseSubtypeMap_embedding (β := ℝ) U (rootSliceOverlap_isOpen γ).measurableSet
  rw [overlapMeasure,he.comap_apply,A.coordinateMeasure_apply μ (he.measurableSet_image.mpr hS)]
  congr 1
  ext x
  constructor
  · rintro ⟨z,⟨⟨w,hw,rfl⟩,hd⟩,rfl⟩
    exact ⟨w,⟨hw,hd⟩,rfl⟩
  · rintro ⟨w,⟨hw,hd⟩,rfl⟩
    exact ⟨baseSubtypeMap U w,⟨⟨w,hw,rfl⟩,hd⟩,rfl⟩

lemma overlapMeasure_conditional (A : RootBox hij k) (γ : G n) (l : Fin n)
    (μ : Measure (X n)) [IsFiniteMeasure μ] :
    ∀ᵐ s ∂(A.overlapMeasure γ l μ).fst,
      (A.overlapMeasure γ l μ).condKernel s = A.conditionalKernel μ s.val :=
  conditional_comap_baseSubtype (A.coordinateMeasure μ) _ (rootSliceOverlap_isOpen γ).measurableSet

 

theorem overlapMeasure_transition (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (hγ : γ ∈ integralGroup n) (μ : Measure (X n)) :
    ((A.overlapMeasure γ l μ).restrict
      ((rootTransitionCoordinates hij γ) ⁻¹' B.overlapDomain γ⁻¹ k)).map
        (rootTransitionCoordinates hij γ) =
      (B.overlapMeasure γ⁻¹ k μ).restrict
        (rootTransitionCoordinates hij γ '' A.overlapDomain γ l) := by
  let E := rootTransitionCoordinates (k := k) (l := l) hij γ
  ext S hS
  rw [Measure.map_apply E.measurable hS,Measure.restrict_apply (E.measurable hS),
    A.overlapMeasure_apply γ l μ ((E.measurable hS).inter
      (E.measurable (B.overlapDomain_open γ⁻¹ k).measurableSet)),
    Measure.restrict_apply hS,B.overlapMeasure_apply γ⁻¹ k μ
      (hS.inter (E.measurableEmbedding.measurableSet_image.mpr
        (A.overlapDomain_open γ l).measurableSet))]
  congr 1
  ext x
  constructor
  · rintro ⟨z,⟨⟨hzS,hzB⟩,hzA⟩,rfl⟩
    exact ⟨E z,⟨⟨hzS,⟨z,hzA,rfl⟩⟩,hzB⟩,rootTransitionCoordinates_param hij γ hγ z⟩
  · rintro ⟨w,⟨⟨hwS,z,hzA,rfl⟩,hzB⟩,rfl⟩
    exact ⟨z,⟨⟨hwS,hzB⟩,hzA⟩,(rootTransitionCoordinates_param hij γ hγ z).symm⟩

end RootBox
end PrimeDegreePackets


namespace PrimeDegreePackets
variable {α β γ δ : Type*} [MeasurableSpace α] [MeasurableSpace β]
  [MeasurableSpace γ] [MeasurableSpace δ]

lemma conditional_restrict_normalized [StandardBorelSpace β] [Nonempty β]
    (ρ : Measure (α × β)) [IsFiniteMeasure ρ] (T : Set (α × β)) (hT : MeasurableSet T) :
    ∀ᵐ a ∂(ρ.restrict T).fst,
      ρ.condKernel a (Prod.mk a ⁻¹' T) ≠ 0 ∧
      (ρ.restrict T).condKernel a =
        (anchorNormalize (ρ.condKernel a) (Prod.mk a ⁻¹' T)).restrict (Prod.mk a ⁻¹' T) := by
  let w := fun a => ρ.condKernel a (Prod.mk a ⁻¹' T)
  have hw : Measurable w := Kernel.measurable_kernel_prodMk_left hT
  have hp : ∀ᵐ a ∂(ρ.restrict T).fst, w a ≠ 0 := by
    rw [conditional_restrict_marginal ρ T hT]
    exact (ae_withDensity_iff hw).mpr (ae_of_all _ fun _ h => h)
  have H : ∀ᵐ a ∂(ρ.restrict T).fst,
      w a • (ρ.restrict T).condKernel a = (ρ.condKernel a).restrict (Prod.mk a ⁻¹' T) := by
    rw [conditional_restrict_marginal ρ T hT]
    exact (withDensity_absolutelyContinuous ρ.fst w).ae_le (conditional_restrict_fibers ρ T hT)
  filter_upwards [hp,H] with a hpa ha
  refine ⟨hpa,?_⟩
  have he := congrArg (fun ν : Measure β => (w a)⁻¹ • ν) ha
  rw [smul_smul,ENNReal.inv_mul_cancel hpa (measure_ne_top _ _),one_smul] at he
  simpa only [anchorNormalize,Measure.restrict_smul] using he

 

theorem conditional_overlap_normalized [StandardBorelSpace β] [Nonempty β]
    [StandardBorelSpace δ] [Nonempty δ]
    (ρ : Measure (α × β)) [IsFiniteMeasure ρ]
    (σ : Measure (γ × δ)) [IsFiniteMeasure σ]
    (T : Set (α × β)) (hT : MeasurableSet T)
    (W : Set (γ × δ)) (hW : MeasurableSet W)
    (e : α ≃ᵐ γ) (F : α × β → δ) (hF : Measurable F)
    (he : (ρ.restrict T).map (fun z => (e z.1,F z)) = σ.restrict W) :
    ∀ᵐ a ∂(ρ.restrict T).fst,
      ρ.condKernel a (Prod.mk a ⁻¹' T) ≠ 0 ∧
      σ.condKernel (e a) (Prod.mk (e a) ⁻¹' W) ≠ 0 ∧
      ((anchorNormalize (ρ.condKernel a) (Prod.mk a ⁻¹' T)).restrict (Prod.mk a ⁻¹' T)).map
        (fun b => F (a,b)) =
      (anchorNormalize (σ.condKernel (e a)) (Prod.mk (e a) ⁻¹' W)).restrict (Prod.mk (e a) ⁻¹' W) := by
  have Hρ := conditional_restrict_normalized ρ T hT
  have Hσ := conditional_restrict_normalized σ W hW
  have hm := congrArg Measure.fst he
  rw [fst_map_fibers _ e F hF] at hm
  rw [←hm] at Hσ
  have Hσ' := ae_of_ae_map e.measurable.aemeasurable Hσ
  have Hcov := conditional_map_fibers (ρ.restrict T) e F hF
  filter_upwards [Hρ,Hσ',Hcov] with a ha hb hc
  simp only [he] at hc
  refine ⟨ha.1,hb.1,?_⟩
  rw [←ha.2,←hb.2]
  exact hc.symm

end PrimeDegreePackets


namespace PrimeDegreePackets.RootBox
variable {n : ℕ} {i j k l : Fin n} {hij : i ≠ j}

theorem overlap_conditional_projective (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (hγ : γ ∈ integralGroup n) (μ : Measure (X n)) [IsFiniteMeasure μ] :
    let E := rootTransitionCoordinates (k := k) (l := l) hij γ
    let T := E ⁻¹' B.overlapDomain γ⁻¹ k
    let W := E '' A.overlapDomain γ l
    ∀ᵐ s ∂((A.overlapMeasure γ l μ).restrict T).fst,
      A.conditionalKernel μ s.val (Prod.mk s ⁻¹' T) ≠ 0 ∧
      B.conditionalKernel μ (rootTransitionSlice hij γ s).val
        (Prod.mk (rootTransitionSlice hij γ s) ⁻¹' W) ≠ 0 ∧
      ((anchorNormalize (A.conditionalKernel μ s.val) (Prod.mk s ⁻¹' T)).restrict
        (Prod.mk s ⁻¹' T)).map (Homeomorph.addRight (rootTransitionTime γ s)) =
      (anchorNormalize (B.conditionalKernel μ (rootTransitionSlice hij γ s).val)
        (Prod.mk (rootTransitionSlice hij γ s) ⁻¹' W)).restrict
        (Prod.mk (rootTransitionSlice hij γ s) ⁻¹' W) := by
  intro E T W
  let e := (rootSliceTransition (k := k) (l := l) hij γ).toMeasurableEquiv
  let F : RootSliceOverlap i j k l γ × ℝ → ℝ := fun z => z.2 + rootTransitionTime γ z.1
  have hF : Measurable F := measurable_snd.add
    ((continuous_rootTransitionTime γ).measurable.comp measurable_fst)
  have H := conditional_overlap_normalized (A.overlapMeasure γ l μ) (B.overlapMeasure γ⁻¹ k μ)
    T (E.measurable (B.overlapDomain_open γ⁻¹ k).measurableSet)
    W (E.measurableEmbedding.measurableSet_image.mpr (A.overlapDomain_open γ l).measurableSet)
    e F hF (A.overlapMeasure_transition B γ hγ μ)
  have HA : ∀ᵐ s ∂((A.overlapMeasure γ l μ).restrict T).fst,
      (A.overlapMeasure γ l μ).condKernel s = A.conditionalKernel μ s.val :=
    (Measure.absolutelyContinuous_of_le (Measure.fst_mono Measure.restrict_le_self)).ae_le
      (A.overlapMeasure_conditional γ l μ)
  have HB : ∀ᵐ t ∂((B.overlapMeasure γ⁻¹ k μ).restrict W).fst,
      (B.overlapMeasure γ⁻¹ k μ).condKernel t = B.conditionalKernel μ t.val :=
    (Measure.absolutelyContinuous_of_le (Measure.fst_mono Measure.restrict_le_self)).ae_le
      (B.overlapMeasure_conditional γ⁻¹ k μ)
  have hm := congrArg Measure.fst (A.overlapMeasure_transition B γ hγ μ)
  change (((A.overlapMeasure γ l μ).restrict T).map (fun z => (e z.1,F z))).fst = _ at hm
  rw [fst_map_fibers _ e F hF] at hm
  rw [←hm] at HB
  have HB' := ae_of_ae_map e.measurable.aemeasurable HB
  filter_upwards [H,HA,HB'] with s hs ha hb
  rw [ha,hb] at hs
  exact hs

end PrimeDegreePackets.RootBox


namespace PrimeDegreePackets

lemma fst_restrict_base {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]
    (ρ : Measure (α × β)) {U : Set α} (hU : MeasurableSet U) :
    (ρ.restrict (Prod.fst ⁻¹' U)).fst = ρ.fst.restrict U := by
  exact (Measure.restrict_map measurable_fst hU).symm

namespace RootBox
variable {n : ℕ} {i j k l : Fin n} {hij : i ≠ j}

abbrev transitionOverlapMeasure (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (μ : Measure (X n)) : Measure (RootSliceOverlap i j k l γ × ℝ) :=
  (A.overlapMeasure γ l μ).restrict
    ((rootTransitionCoordinates hij γ) ⁻¹' B.overlapDomain γ⁻¹ k)

lemma transitionOverlapMeasure_apply (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (μ : Measure (X n)) {S : Set (RootSliceOverlap i j k l γ × ℝ)}
    (hS : MeasurableSet S) :
    A.transitionOverlapMeasure B γ μ S = μ (rootOverlapParam hij γ ''
      ((S ∩ (rootTransitionCoordinates hij γ) ⁻¹' B.overlapDomain γ⁻¹ k) ∩ A.overlapDomain γ l)) := by
  rw [transitionOverlapMeasure,Measure.restrict_apply hS,A.overlapMeasure_apply γ l μ
    (hS.inter ((rootTransitionCoordinates hij γ).measurable (B.overlapDomain_open γ⁻¹ k).measurableSet))]

 

lemma transitionOverlapMeasure_restrict_le (A D : RootBox hij k) (B F : RootBox hij l)
    (hAD : A.time ⊆ D.time) (hBF : B.time ⊆ F.time)
    (γ : G n) (μ : Measure (X n)) :
    (A.transitionOverlapMeasure B γ μ).restrict (Prod.fst ⁻¹'
      {s | s.val ∈ D.transverse ∧ (rootTransitionSlice hij γ s).val ∈ F.transverse}) ≤
      D.transitionOverlapMeasure F γ μ := by
  let U := {s : RootSliceOverlap i j k l γ |
    s.val ∈ D.transverse ∧ (rootTransitionSlice hij γ s).val ∈ F.transverse}
  have hU : MeasurableSet U :=
    (measurable_subtype_coe D.transverse_open.measurableSet).inter
      ((continuous_rootTransitionSlice hij γ).measurable
        (measurable_subtype_coe F.transverse_open.measurableSet))
  apply Measure.le_iff.mpr
  intro S hS
  have hSU : MeasurableSet (S ∩ Prod.fst ⁻¹' U) := hS.inter (measurable_fst hU)
  rw [Measure.restrict_apply hS,transitionOverlapMeasure_apply _ _ _ _ hSU,
    transitionOverlapMeasure_apply _ _ _ _ hS]
  apply measure_mono
  apply Set.image_mono
  rintro z ⟨⟨⟨hzS,hzD,hzF⟩,hzB⟩,hzA⟩
  exact ⟨⟨hzS,⟨hzF,hBF hzB.2⟩⟩,⟨hzD,hAD hzA.2⟩⟩

lemma transition_base_ae_of_ae (A D : RootBox hij k) (B F : RootBox hij l)
    (hAD : A.time ⊆ D.time) (hBF : B.time ⊆ F.time)
    (γ : G n) (μ : Measure (X n)) {P : RootSliceOverlap i j k l γ → Prop}
    (hP : ∀ᵐ s ∂(D.transitionOverlapMeasure F γ μ).fst, P s) :
    ∀ᵐ s ∂(A.transitionOverlapMeasure B γ μ).fst,
      s.val ∈ D.transverse → (rootTransitionSlice hij γ s).val ∈ F.transverse → P s := by
  let U := {s : RootSliceOverlap i j k l γ |
    s.val ∈ D.transverse ∧ (rootTransitionSlice hij γ s).val ∈ F.transverse}
  have hU : MeasurableSet U :=
    (measurable_subtype_coe D.transverse_open.measurableSet).inter
      ((continuous_rootTransitionSlice hij γ).measurable
        (measurable_subtype_coe F.transverse_open.measurableSet))
  have H := (Measure.absolutelyContinuous_of_le
    (Measure.fst_mono (A.transitionOverlapMeasure_restrict_le D B F hAD hBF γ μ))).ae_le hP
  rw [fst_restrict_base _ hU] at H
  filter_upwards [(ae_restrict_iff' hU).mp H] with s hs
  exact fun hD hF => hs ⟨hD,hF⟩

lemma transition_base_ae_source (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (μ : Measure (X n)) [IsFiniteMeasure μ]
    {P : RootSlice i j k → Prop} (hP : ∀ᵐ s ∂(A.coordinateMeasure μ).fst, P s) :
    ∀ᵐ s ∂(A.transitionOverlapMeasure B γ μ).fst, P s.val := by
  let U := {s : RootSlice i j k | (γ*s.val).1 l i ≠ 0}
  have H := (Measure.absolutelyContinuous_of_le (Measure.restrict_le_self (s := U))).ae_le hP
  rw [←fst_map_comap_baseSubtype (A.coordinateMeasure μ) U
    (rootSliceOverlap_isOpen γ).measurableSet] at H
  exact (Measure.absolutelyContinuous_of_le (Measure.fst_mono Measure.restrict_le_self)).ae_le
    (ae_of_ae_map measurable_subtype_coe.aemeasurable H)

lemma transition_base_ae_target (A : RootBox hij k) (B : RootBox hij l)
    (γ : G n) (hγ : γ ∈ integralGroup n) (μ : Measure (X n)) [IsFiniteMeasure μ]
    {P : RootSlice i j l → Prop} (hP : ∀ᵐ s ∂(B.coordinateMeasure μ).fst, P s) :
    ∀ᵐ s ∂(A.transitionOverlapMeasure B γ μ).fst, P (rootTransitionSlice hij γ s).val := by
  let U := {s : RootSlice i j l | (γ⁻¹*s.val).1 k i ≠ 0}
  have H := (Measure.absolutelyContinuous_of_le (Measure.restrict_le_self (s := U))).ae_le hP
  rw [←fst_map_comap_baseSubtype (B.coordinateMeasure μ) U
    (rootSliceOverlap_isOpen γ⁻¹).measurableSet] at H
  have H' := ae_of_ae_map measurable_subtype_coe.aemeasurable H
  have H'' := (Measure.absolutelyContinuous_of_le (Measure.fst_mono
    (Measure.restrict_le_self (s := rootTransitionCoordinates hij γ '' A.overlapDomain γ l)))).ae_le H'
  change ∀ᵐ s ∂((B.overlapMeasure γ⁻¹ k μ).restrict
    (rootTransitionCoordinates hij γ '' A.overlapDomain γ l)).fst, P s.val at H''
  rw [←A.overlapMeasure_transition B γ hγ μ] at H''
  have hm := fst_map_fibers (A.transitionOverlapMeasure B γ μ)
    (rootSliceTransition hij γ).toMeasurableEquiv
    (fun z => z.2 + rootTransitionTime γ z.1)
    (measurable_snd.add ((continuous_rootTransitionTime γ).measurable.comp measurable_fst))
  change ((A.transitionOverlapMeasure B γ μ).map (rootTransitionCoordinates hij γ)).fst = _ at hm
  rw [hm] at H''
  exact ae_of_ae_map (rootSliceTransition hij γ).measurable.aemeasurable H''

end RootBox
end PrimeDegreePackets


namespace PrimeDegreePackets
variable {α β : Type*} [MeasurableSpace α] [MeasurableSpace β]

lemma anchorNormalize_map (ν : Measure α) (e : α ≃ᵐ β) {J : Set α}
    (hJ : MeasurableSet J) :
    (anchorNormalize ν J).map e = anchorNormalize (ν.map e) (e '' J) := by
  unfold anchorNormalize
  rw [Measure.map_smul _ e.measurable.aemeasurable,Measure.map_apply e.measurable
    (e.measurableEmbedding.measurableSet_image.mpr hJ),e.preimage_image]

lemma anchorNormalize_congr_restriction (ν p : Measure α) {D J : Set α}
    (hJ : MeasurableSet J) (hJD : J ⊆ D)
    (c : ℝ≥0∞) (hc0 : c ≠ 0) (hcT : c ≠ ∞)
    (he : ν.restrict D = c • p) :
    (anchorNormalize ν J).restrict D = anchorNormalize p J := by
  rw [←anchorNormalize_restrict_comm ν hJ hJD,he,anchorNormalize_smul _ _ _ hc0 hcT]

lemma anchorNormalize_reanchor_map (p : Measure α) (q : Measure β)
    (e : α ≃ᵐ β) {V : Set α} {W : Set β} {J : Set α}
    (hJ : MeasurableSet J) (hJV : J ⊆ V) (hJW : e '' J ⊆ W)
    (hpV0 : p V ≠ 0) (hpVT : p V ≠ ∞) (hqW0 : q W ≠ 0) (hqWT : q W ≠ ∞)
    (he : ((anchorNormalize p V).restrict V).map e = (anchorNormalize q W).restrict W) :
    ((anchorNormalize p J).restrict V).map e = (anchorNormalize q (e '' J)).restrict W := by
  have H := congrArg (fun ρ : Measure β => anchorNormalize ρ (e '' J)) he
  rw [←anchorNormalize_map _ e hJ,anchorNormalize_restrict_comm _ hJ hJV,
    anchorNormalize_twice _ _ _ hpV0 hpVT,
    anchorNormalize_restrict_comm _ (e.measurableEmbedding.measurableSet_image.mpr hJ) hJW,
    anchorNormalize_twice _ _ _ hqW0 hqWT] at H
  exact H

 

theorem projective_extensions_overlap
    (ν p : Measure α) (η q : Measure β) (e : α ≃ᵐ β)
    {D V J : Set α} {E W : Set β}
    (hD : MeasurableSet D) (hE : MeasurableSet E)
    (hJ : MeasurableSet J) (hJD : J ⊆ D) (hJV : J ⊆ V)
    (hJE : e '' J ⊆ E) (hJW : e '' J ⊆ W)
    (c d : ℝ≥0∞) (hc0 : c ≠ 0) (hcT : c ≠ ∞) (hd0 : d ≠ 0) (hdT : d ≠ ∞)
    (hν : ν.restrict D = c • p) (hη : η.restrict E = d • q)
    (hpV0 : p V ≠ 0) (hpVT : p V ≠ ∞) (hqW0 : q W ≠ 0) (hqWT : q W ≠ ∞)
    (he : ((anchorNormalize p V).restrict V).map e = (anchorNormalize q W).restrict W) :
    ((anchorNormalize ν J).restrict (V ∩ D)).map e =
      (anchorNormalize η (e '' J)).restrict (W ∩ E) := by
  have Hν := anchorNormalize_congr_restriction ν p hJ hJD c hc0 hcT hν
  have Hη := anchorNormalize_congr_restriction η q
    (e.measurableEmbedding.measurableSet_image.mpr hJ) hJE d hd0 hdT hη
  have H := anchorNormalize_reanchor_map p q e hJ hJV hJW hpV0 hpVT hqW0 hqWT he
  rw [←Hν,←Hη] at H
  simpa only [Measure.restrict_restrict' hD,Measure.restrict_restrict' hE] using H

end PrimeDegreePackets
end
end

end OAI