import OAI.MathematicalPhysics.Boltzmann.Collision.CollisionWeakMarginals
import OAI.MathematicalPhysics.Boltzmann.Collision.VelocityCutoffEntropyError
import OAI.MathematicalPhysics.Boltzmann.Compactness.EntropyUniformIntegrability
import OAI.MathematicalPhysics.Boltzmann.Compactness.NormalizedKernelAction
import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakLinearMomentLimit
import OAI.MathematicalPhysics.Boltzmann.Compactness.WeakL1Operations

namespace OAI

section

/-! # The first-velocity-moment weight of the normalized pair is integrable -/
noncomputable section
open MeasureTheory
open scoped ENNReal
namespace BoltzmannNonuniqueness.Compactness
open PeriodicApproximation
variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ]

def pairVelocityWeight (z : X × (Velocity × Velocity)) : ℝ := 1+‖z.2.1‖+‖z.2.2‖

def weightedNormalizedPair (f : X × Velocity → ℝ) (z : X × (Velocity × Velocity)) : ℝ :=
  pairVelocityWeight z*normalizedPair volume f z

theorem pairVelocityWeight_measurable : Measurable (pairVelocityWeight (X := X)) := by
  unfold pairVelocityWeight
  fun_prop

theorem weightedNormalizedPair_measurable {f : X × Velocity → ℝ} (hfm : Measurable f) :
    Measurable (weightedNormalizedPair f) :=
  pairVelocityWeight_measurable.mul
    (normalizedTensor_measurable (fiberMass_measurable (ν := volume) hfm) hfm hfm)

theorem normalizedTensor_integrable_swap {d : X → ℝ} {f g : X × Velocity → ℝ}
    (hd : Measurable d) (hf : Measurable f) (hg : Measurable g)
    (hi : Integrable (normalizedTensor d g f) (μ.prod (volume.prod volume))) :
    Integrable (normalizedTensor d f g) (μ.prod (volume.prod volume)) := by
  apply memLp_one_iff_integrable.mp
  change eLpNorm (normalizedTensor d f g) 1 (μ.prod (volume.prod volume)) < ∞
  rw [normalizedTensor_norm_swap hd hf hg]
  exact memLp_one_iff_integrable.mpr hi

theorem weightedNormalizedPair_integrable {f : X × Velocity → ℝ}
    (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p)
    (hi : Integrable (entropyGauge f) (μ.prod volume)) :
    Integrable (weightedNormalizedPair f) (μ.prod (volume.prod volume)) := by
  have hfi := integrable_of_entropyGauge hfm hf hi
  have hli := linearMoment_integrable hfm hf hi
  have hdm := fiberMass_measurable (ν := volume) hfm
  have hdn (x : X) : 0 ≤ fiberMass volume f x := integral_nonneg (fun v => hf (x,v))
  have hlm := linearMoment_measurable hfm
  have hln (p : X × Velocity) : 0 ≤ linearMoment f p := mul_nonneg (by positivity) (hf p)
  have hr := normalizedTensor_integrable hdm hdn hfm hlm hf hln hfi hli
    (ae_of_all _ (fun _ => le_rfl))
  have hl := normalizedTensor_integrable_swap hdm hlm hfm hr
  have hp := normalizedPair_integrable hfm hf hfi
  apply ((hl.add hr).sub hp).congr
  filter_upwards [] with z
  dsimp only [Pi.sub_apply,Pi.add_apply,weightedNormalizedPair,pairVelocityWeight,normalizedPair,normalizedTensor,linearMoment]
  ring

end BoltzmannNonuniqueness.Compactness

end

end

section

/-! # Entropy controls the complete mass-normalized velocity pair -/
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal
namespace BoltzmannNonuniqueness.Compactness
open PeriodicApproximation

variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ]

private theorem bounded_nonnegative_product_div {a b A B r : ℝ}
    (ha : 0 ≤ a) (hb : 0 ≤ b) (hA : a ≤ A) (hB : b ≤ B)
    (hA0 : 0 ≤ A) (hB0 : 0 ≤ B) (hr : 0 ≤ r) :
    |a*b/(1+r)| ≤ A*B := by
  rw [abs_of_nonneg (div_nonneg (mul_nonneg ha hb) (by linarith))]
  apply (div_le_iff₀ (by linarith : 0 < 1+r)).mpr
  exact (mul_le_mul hA hB hb hA0).trans (by nlinarith [mul_nonneg (mul_nonneg hA0 hB0) hr])

theorem normalized_entropyTruncation_uniformIntegrable (R : ℝ)
    {f : ℕ → X × Velocity → ℝ}
    (hfm : ∀ n, Measurable (f n)) (hf : ∀ n z, 0 ≤ f n z) :
    UniformIntegrable (fun n => normalizedTensor (fiberMass volume (f n))
      (entropyTruncation R (f n)) (entropyTruncation R (f n))) 1
      (μ.prod (volume.prod volume)) := by
  let a : Velocity → ℝ := (Metric.closedBall (0:Velocity) R).indicator (fun _ => Real.exp R)
  have hai : Integrable a := (integrableOn_const
    (isCompact_closedBall (0:Velocity) R).measure_lt_top.ne).integrable_indicator
    Metric.isClosed_closedBall.measurableSet
  have ha0 v : 0 ≤ a v := indicator_nonneg (fun _ _ => (Real.exp_pos R).le) v
  have hub (n : ℕ) (p : X × Velocity) : entropyTruncation R (f n) p ≤ a p.2 := by
    by_cases hp : p.2 ∈ Metric.closedBall 0 R
    · rw [show a p.2 = Real.exp R from indicator_of_mem hp _]
      exact (entropyTruncation_bounds R (hf n) p).2
    · have hv : R < ‖p.2‖ := by simpa only [Metric.mem_closedBall,dist_zero_right,not_le] using hp
      rw [entropyTruncation_support R (f n) p hv,show a p.2 = 0 from indicator_of_notMem hp _]
  let b : X × (Velocity × Velocity) → ℝ := fun z => a z.2.1*a z.2.2
  have hbi : Integrable b (μ.prod (volume.prod volume)) := (hai.mul_prod hai).comp_snd μ
  have hbui := uniformIntegrable_const (ι := ℕ) (by norm_num : (1:ℝ≥0∞) ≤ 1)
    (by norm_num) (memLp_one_iff_integrable.mpr hbi)
  have hm n : Measurable (normalizedTensor (fiberMass volume (f n))
      (entropyTruncation R (f n)) (entropyTruncation R (f n))) :=
    normalizedTensor_measurable (fiberMass_measurable (hfm n))
      (entropyTruncation_measurable R (hfm n)) (entropyTruncation_measurable R (hfm n))
  have hdom (n : ℕ) (z : X × (Velocity × Velocity)) :
      ‖normalizedTensor (fiberMass volume (f n))
        (entropyTruncation R (f n)) (entropyTruncation R (f n)) z‖ ≤ b z := by
    change |entropyTruncation R (f n) (z.1,z.2.1)*entropyTruncation R (f n) (z.1,z.2.2)/
      (1+fiberMass volume (f n) z.1)| ≤ a z.2.1*a z.2.2
    exact bounded_nonnegative_product_div (entropyTruncation_bounds R (hf n) _).1
      (entropyTruncation_bounds R (hf n) _).1 (hub n _) (hub n _) (ha0 _) (ha0 _)
      (integral_nonneg (fun v => hf n (z.1,v)))
  have hmono (n : ℕ) (s : Set (X × (Velocity × Velocity))) :
      eLpNorm (normalizedTensor (fiberMass volume (f n))
        (entropyTruncation R (f n)) (entropyTruncation R (f n))) 1
        ((μ.prod (volume.prod volume)).restrict s) ≤ eLpNorm b 1 ((μ.prod (volume.prod volume)).restrict s) :=
    eLpNorm_mono_real (hm n).aestronglyMeasurable (hdom n)
  refine ⟨unifIntegrable_iff.mpr ?_,?_⟩
  · intro ε hε
    obtain ⟨δ,hδ,hδb⟩ := unifIntegrable_iff.mp hbui.1 ε hε
    exact ⟨δ,hδ,fun n s hs => (hmono n s).trans (hδb n s hs)⟩
  · obtain ⟨K,hK⟩ := hbui.2
    refine ⟨K,fun n => ?_⟩
    simpa only [Measure.restrict_univ] using (hmono n univ).trans
      (by simpa only [Measure.restrict_univ] using hK n)

theorem normalizedPair_uniformIntegrable {f : ℕ → X × Velocity → ℝ} {C : ℝ}
    (hfm : ∀ n, Measurable (f n)) (hf : ∀ n z, 0 ≤ f n z)
    (hi : ∀ n, Integrable (entropyGauge (f n)) (μ.prod volume))
    (hb : ∀ n, (∫ z, entropyGauge (f n) z ∂μ.prod volume) ≤ C) :
    UniformIntegrable (fun n => normalizedPair volume (f n)) 1 (μ.prod (volume.prod volume)) := by
  let u := fun (j n : ℕ) => entropyTruncation ((j:ℝ)+1) (f n)
  apply uniformIntegrable_of_approximation
    (g := fun j n => normalizedTensor (fiberMass volume (f n)) (u j n) (u j n))
  · exact fun j => normalized_entropyTruncation_uniformIntegrable ((j:ℝ)+1) hfm hf
  · intro ε hε
    obtain ⟨j,hj⟩ := exists_entropyTruncation_radius (2*C) hε
    refine ⟨j,fun n => ?_⟩
    have hR : 1 ≤ (j:ℝ)+1 := by have := Nat.cast_nonneg (α := ℝ) j; linarith
    have he := normalizedPair_truncation_error (hfm n)
      (entropyTruncation_measurable ((j:ℝ)+1) (hfm n)) (hf n)
      (fun p => (entropyTruncation_bounds ((j:ℝ)+1) (hf n) p).1)
      (fun p => by
        unfold entropyTruncation
        split_ifs
        · exact le_rfl
        · exact hf n p)
      (integrable_of_entropyGauge (hfm n) (hf n) (hi n))
      (entropyTruncation_integrable ((j:ℝ)+1) (hfm n) (hf n))
    calc
      _ ≤ 2*eLpNorm (fun z => f n z-u j n z) 1 (μ.prod volume) := he
      _ ≤ 2*ENNReal.ofReal (C/((j:ℝ)+1)) := mul_le_mul' le_rfl
        (entropyTruncation_L1_bound hR (hfm n) (hf n) (hi n) (hb n))
      _ = ENNReal.ofReal ((2*C)/((j:ℝ)+1)) := by
        rw [show (2:ℝ≥0∞) = ENNReal.ofReal (2:ℝ) by norm_num,← ENNReal.ofReal_mul (by norm_num)]
        congr 1
        ring
      _ ≤ ε := hj

end BoltzmannNonuniqueness.Compactness

end

end

section

/-! # Uniform velocity-tail control of the moment-weighted normalized pair -/
noncomputable section
open MeasureTheory Set
open scoped ENNReal
namespace BoltzmannNonuniqueness.Compactness
open PeriodicApproximation
variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ]

def pairVelocityCut (R : ℝ) (f : X × Velocity → ℝ) (z : X × (Velocity × Velocity)) : ℝ :=
  if ‖z.2.1‖ ≤ R ∧ ‖z.2.2‖ ≤ R then weightedNormalizedPair f z else 0

theorem pairVelocityCut_measurable (R : ℝ) {f : X × Velocity → ℝ} (hfm : Measurable f) :
    Measurable (pairVelocityCut R f) :=
  (weightedNormalizedPair_measurable hfm).ite
    ((measurableSet_le (measurable_snd.fst.norm) measurable_const).inter
      (measurableSet_le (measurable_snd.snd.norm) measurable_const)) measurable_const

private theorem tail_coeff_bound {R a b : ℝ} (hR : 0 ≤ R) (_ha : 0 ≤ a) (_hb : 0 ≤ b) :
    (if a ≤ R ∧ b ≤ R then 0 else 1+a+b) ≤
      2*((if a ≤ R then 0 else 1+a)+(if b ≤ R then 0 else 1+b)) := by
  by_cases har : a ≤ R <;> by_cases hbr : b ≤ R <;>
    simp only [har,hbr,and_self,ite_true,ite_false,false_and,and_false,
      zero_add,add_zero] <;> (try linarith)

omit [MeasurableSpace X] in
private theorem tail_density_nonneg (R : ℝ) {f : X × Velocity → ℝ}
    (hf : ∀ p, 0 ≤ f p) (p : X × Velocity) :
    0 ≤ linearMoment f p-velocityLinearCut R f p := by
  dsimp only [velocityLinearCut]
  split_ifs
  · simp only [sub_self,le_refl]
  · simp only [sub_zero,linearMoment]
    exact mul_nonneg (by positivity) (hf p)

omit [MeasurableSpace X] in
theorem pairVelocityCut_pointwise_error {R : ℝ} (hR : 0 ≤ R) {f : X × Velocity → ℝ}
    (hf : ∀ p, 0 ≤ f p) (z : X × (Velocity × Velocity)) :
    |weightedNormalizedPair f z-pairVelocityCut R f z| ≤
      2*(normalizedTensor (fiberMass volume f)
          (fun p => linearMoment f p-velocityLinearCut R f p) f z+
        normalizedTensor (fiberMass volume f) f
          (fun p => linearMoment f p-velocityLinearCut R f p) z) := by
  have hd : 0 < 1+fiberMass volume f z.1 := by
    have hm : 0 ≤ fiberMass volume f z.1 := integral_nonneg (fun v => hf (z.1,v))
    linarith
  have hprod : 0 ≤ f (z.1,z.2.1)*f (z.1,z.2.2) := mul_nonneg (hf _) (hf _)
  have hc := mul_le_mul_of_nonneg_right (tail_coeff_bound hR (norm_nonneg z.2.1) (norm_nonneg z.2.2)) hprod
  have hdiv := div_le_div_of_nonneg_right hc hd.le
  by_cases hv : ‖z.2.1‖ ≤ R <;> by_cases hw : ‖z.2.2‖ ≤ R
  all_goals
    simp only [weightedNormalizedPair,pairVelocityCut,pairVelocityWeight,normalizedPair,
      normalizedTensor,linearMoment,velocityLinearCut,hv,hw,and_self,
      ite_true,ite_false,false_and,and_false,sub_self,sub_zero,zero_mul,mul_zero,zero_div,
      zero_add,add_zero,abs_zero] at hdiv ⊢
  · exact le_refl _
  all_goals
    rw [abs_of_nonneg (mul_nonneg (by positivity) (div_nonneg hprod hd.le))]
    convert hdiv using 1 <;> ring

theorem pairVelocityCut_L1_error {R C : ℝ} (hR : 0 < R) {f : X × Velocity → ℝ}
    (hfm : Measurable f) (hf : ∀ p, 0 ≤ f p)
    (hi : Integrable (entropyGauge f) (μ.prod volume))
    (hb : (∫ p, entropyGauge f p ∂μ.prod volume) ≤ C) :
    eLpNorm (fun z => weightedNormalizedPair f z-pairVelocityCut R f z) 1
      (μ.prod (volume.prod volume)) ≤ ENNReal.ofReal (8*C/R) := by
  let d : X × Velocity → ℝ := fun p => linearMoment f p-velocityLinearCut R f p
  have hdm : Measurable d := (linearMoment_measurable hfm).sub (velocityLinearCut_measurable R hfm)
  have hdi : Integrable d (μ.prod volume) :=
    (linearMoment_integrable hfm hf hi).sub (velocityLinearCut_integrable R hfm hf hi)
  have hfi := integrable_of_entropyGauge hfm hf hi
  have hm := fiberMass_measurable (ν := volume) hfm
  have hmn (x : X) : 0 ≤ fiberMass volume f x := integral_nonneg (fun v => hf (x,v))
  have hd0 : ∀ p, 0 ≤ d p := tail_density_nonneg R hf
  have hright := normalizedTensor_L1_le hm hmn hfm hdm hf hd0 hfi hdi (ae_of_all _ (fun _ => le_rfl))
  have hleft : eLpNorm (normalizedTensor (fiberMass volume f) d f) 1 (μ.prod (volume.prod volume)) ≤
      eLpNorm d 1 (μ.prod volume) := by
    rw [normalizedTensor_norm_swap hm hdm hfm]
    exact hright
  have hs_nonneg (z : X × (Velocity × Velocity)) :
      0 ≤ normalizedTensor (fiberMass volume f) d f z+normalizedTensor (fiberMass volume f) f d z := by
    have hden : 0 ≤ 1+fiberMass volume f z.1 := by linarith [hmn z.1]
    exact add_nonneg (div_nonneg (mul_nonneg (hd0 _) (hf _)) hden)
      (div_nonneg (mul_nonneg (hf _) (hd0 _)) hden)
  have hnorm := eLpNorm_le_mul_eLpNorm_of_ae_le_mul (μ := μ.prod (volume.prod volume))
    ((weightedNormalizedPair_measurable hfm).sub (pairVelocityCut_measurable R hfm)).aestronglyMeasurable
    (g := fun z => normalizedTensor (fiberMass volume f) d f z+normalizedTensor (fiberMass volume f) f d z)
    (c := 2) (ae_of_all _ (fun z => by
      rw [Real.norm_eq_abs,Real.norm_of_nonneg (hs_nonneg z)]
      exact pairVelocityCut_pointwise_error hR.le hf z)) 1
  calc
    _ ≤ 2*(eLpNorm (normalizedTensor (fiberMass volume f) d f) 1 (μ.prod (volume.prod volume))+
        eLpNorm (normalizedTensor (fiberMass volume f) f d) 1 (μ.prod (volume.prod volume))) := by
      exact hnorm.trans (by norm_num; exact mul_le_mul' le_rfl (eLpNorm_add_le (by norm_num)))
    _ ≤ 2*(eLpNorm d 1 (μ.prod volume)+eLpNorm d 1 (μ.prod volume)) :=
      mul_le_mul' le_rfl (add_le_add hleft hright)
    _ ≤ 2*(ENNReal.ofReal (2*C/R)+ENNReal.ofReal (2*C/R)) :=
      mul_le_mul' le_rfl (add_le_add (velocityLinearCut_L1_error hR hfm hf hi hb)
        (velocityLinearCut_L1_error hR hfm hf hi hb))
    _ = ENNReal.ofReal (8*C/R) := by
      have hC : 0 ≤ C := (integral_nonneg (entropyGauge_nonneg hf)).trans hb
      rw [← ENNReal.ofReal_add (by positivity) (by positivity),
        show (2:ℝ≥0∞) = ENNReal.ofReal (2:ℝ) by norm_num,
        ← ENNReal.ofReal_mul (by norm_num : (0:ℝ) ≤ 2)]
      congr 1
      ring

end BoltzmannNonuniqueness.Compactness

end

end

section

/-! # Passing the first-velocity-moment weight through normalized-pair convergence -/
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal Topology
namespace BoltzmannNonuniqueness.Compactness
open PeriodicApproximation
variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ]

private def boundedPairWeight (R : ℝ) (z : X × (Velocity × Velocity)) : ℝ :=
  if ‖z.2.1‖ ≤ R ∧ ‖z.2.2‖ ≤ R then pairVelocityWeight z else 0

private theorem boundedPairWeight_measurable (R : ℝ) :
    Measurable (boundedPairWeight (X := X) R) :=
  pairVelocityWeight_measurable.ite
    ((measurableSet_le (measurable_snd.fst.norm) measurable_const).inter
      (measurableSet_le (measurable_snd.snd.norm) measurable_const)) measurable_const

omit [MeasurableSpace X] in
private theorem boundedPairWeight_bound {R : ℝ} (hR : 0 ≤ R) (z : X × (Velocity × Velocity)) :
    |boundedPairWeight R z| ≤ 1+2*R := by
  dsimp only [boundedPairWeight]
  split_ifs with hz
  · rw [abs_of_nonneg (show 0 ≤ pairVelocityWeight z by dsimp [pairVelocityWeight]; positivity)]
    dsimp only [pairVelocityWeight]
    linarith [hz.1,hz.2]
  · simp only [abs_zero]
    linarith

omit [MeasurableSpace X] in
private theorem pairVelocityCut_eq_mul (R : ℝ) (f : X × Velocity → ℝ) :
    pairVelocityCut R f = fun z => boundedPairWeight R z*normalizedPair volume f z := by
  funext z
  dsimp only [pairVelocityCut,boundedPairWeight,weightedNormalizedPair]
  split_ifs <;> simp only [zero_mul]

theorem weak_weightedNormalizedPair
    {f : ℕ → X × Velocity → ℝ} {g : X × Velocity → ℝ} {C : ℝ}
    (hfm : ∀ n, Measurable (f n)) (hf : ∀ n p, 0 ≤ f n p)
    (hfi : ∀ n, Integrable (entropyGauge (f n)) (μ.prod volume))
    (hfb : ∀ n, (∫ p, entropyGauge (f n) p ∂μ.prod volume) ≤ C)
    (hgm : Measurable g) (hg : ∀ p, 0 ≤ g p)
    (hgi : Integrable (entropyGauge g) (μ.prod volume))
    (hgb : (∫ p, entropyGauge g p ∂μ.prod volume) ≤ C)
    (h : Published.WeakL1Converges (μ.prod (volume.prod volume))
      (fun n => normalizedPair volume (f n)) (normalizedPair volume g)) :
    Published.WeakL1Converges (μ.prod (volume.prod volume))
      (fun n => weightedNormalizedPair (f n)) (weightedNormalizedPair g) := by
  let R : ℕ → ℝ := fun j => (j:ℝ)+1
  have hR j : 0 < R j := by dsimp [R]; positivity
  have hC : 0 ≤ C := (integral_nonneg (entropyGauge_nonneg hg)).trans hgb
  have hcut j : Published.WeakL1Converges (μ.prod (volume.prod volume))
      (fun n => pairVelocityCut (R j) (f n)) (pairVelocityCut (R j) g) := by
    have hw := h.bounded_mul (boundedPairWeight_measurable (R j)) (1+2*R j)
      (boundedPairWeight_bound (hR j).le)
    simpa only [pairVelocityCut_eq_mul] using hw
  have hcuti j n : Integrable (pairVelocityCut (R j) (f n)) (μ.prod (volume.prod volume)) := by
    have hw := weightedNormalizedPair_integrable (hfm n) (hf n) (hfi n)
    have hs : MeasurableSet {z : X × (Velocity × Velocity) | ‖z.2.1‖ ≤ R j ∧ ‖z.2.2‖ ≤ R j} :=
      (measurableSet_le (measurable_snd.fst.norm) measurable_const).inter
        (measurableSet_le (measurable_snd.snd.norm) measurable_const)
    apply (hw.indicator hs).congr
    filter_upwards [] with z
    by_cases hz : ‖z.2.1‖ ≤ R j ∧ ‖z.2.2‖ ≤ R j <;> simp [pairVelocityCut,Set.indicator,hz]
  apply Published.WeakL1Converges.of_L1_approximations
    (fun n => weightedNormalizedPair_integrable (hfm n) (hf n) (hfi n))
    (weightedNormalizedPair_measurable hgm) (weightedNormalizedPair_integrable hgm hg hgi)
    hcuti hcut (δ := fun j => 8*C/R j) (fun j => by positivity)
  · exact tendsto_const_nhds.div_atTop
      (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds)
  · exact fun j n => pairVelocityCut_L1_error (hR j) (hfm n) (hf n) (hfi n) (hfb n)
  · intro j
    change eLpNorm (pairVelocityCut (R j) g-weightedNormalizedPair g) 1 _ ≤ _
    rw [eLpNorm_sub_comm]
    exact pairVelocityCut_L1_error (hR j) hgm hg hgi hgb

end BoltzmannNonuniqueness.Compactness

end

end

section

/-! # Velocity tightness of the actual mass-normalized pairs -/
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal
namespace BoltzmannNonuniqueness.Compactness
open PeriodicApproximation

variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ]

theorem normalizedPair_entropy_error {f : X × Velocity → ℝ} {R C : ℝ}
    (hR : 1 ≤ R) (hfm : Measurable f) (hf : ∀ z, 0 ≤ f z)
    (hi : Integrable (entropyGauge f) (μ.prod volume))
    (hb : (∫ z, entropyGauge f z ∂μ.prod volume) ≤ C) :
    eLpNorm (fun z => normalizedPair volume f z-
      normalizedTensor (fiberMass volume f) (entropyTruncation R f) (entropyTruncation R f) z)
      1 (μ.prod (volume.prod volume)) ≤ ENNReal.ofReal (2*C/R) := by
  have huf p : entropyTruncation R f p ≤ f p := by
    unfold entropyTruncation
    split_ifs
    · exact le_rfl
    · exact hf p
  have he := normalizedPair_truncation_error hfm (entropyTruncation_measurable R hfm) hf
    (fun p => (entropyTruncation_bounds R hf p).1) huf (integrable_of_entropyGauge hfm hf hi)
    (entropyTruncation_integrable R hfm hf)
  refine he.trans ((mul_le_mul' le_rfl (entropyTruncation_L1_bound hR hfm hf hi hb)).trans_eq ?_)
  rw [show (2:ℝ≥0∞) = ENNReal.ofReal (2:ℝ) by norm_num,← ENNReal.ofReal_mul (by norm_num)]
  congr 1
  ring

omit [MeasurableSpace X] in
private theorem truncated_pair_support (R : ℝ) (f : X × Velocity → ℝ)
    (z : X × (Velocity × Velocity))
    (hz : z ∉ Set.univ ×ˢ (Metric.closedBall (0:Velocity) R ×ˢ Metric.closedBall (0:Velocity) R)) :
    normalizedTensor (fiberMass volume f) (entropyTruncation R f) (entropyTruncation R f) z = 0 := by
  change entropyTruncation R f (z.1,z.2.1)*entropyTruncation R f (z.1,z.2.2)/
    (1+fiberMass volume f z.1) = 0
  by_cases hv : ‖z.2.1‖ ≤ R
  · have hw : R < ‖z.2.2‖ := by
      by_contra! hn
      exact hz ⟨mem_univ _,by simpa only [Metric.mem_closedBall,dist_zero_right] using hv,
        by simpa only [Metric.mem_closedBall,dist_zero_right] using hn⟩
    rw [entropyTruncation_support R f (z.1,z.2.2) hw,mul_zero,zero_div]
  · rw [entropyTruncation_support R f (z.1,z.2.1) (lt_of_not_ge hv),zero_mul,zero_div]

theorem normalizedPair_unifTight {f : ℕ → X × Velocity → ℝ} {C : ℝ}
    (hfm : ∀ n, Measurable (f n)) (hf : ∀ n z, 0 ≤ f n z)
    (hi : ∀ n, Integrable (entropyGauge (f n)) (μ.prod volume))
    (hb : ∀ n, (∫ z, entropyGauge (f n) z ∂μ.prod volume) ≤ C) :
    UnifTight (fun n => normalizedPair volume (f n)) 1 (μ.prod (volume.prod volume)) := by
  intro ε hε
  obtain ⟨j,hj⟩ := exists_entropyTruncation_radius (2*C) hε
  let R : ℝ := (j:ℝ)+1
  let b : Set Velocity := Metric.closedBall 0 R
  let s : Set (X × (Velocity × Velocity)) := univ ×ˢ (b ×ˢ b)
  have hR : 1 ≤ R := by dsimp [R]; have := Nat.cast_nonneg (α := ℝ) j; linarith
  have hs : MeasurableSet s := MeasurableSet.univ.prod
    (Metric.isClosed_closedBall.measurableSet.prod Metric.isClosed_closedBall.measurableSet)
  refine ⟨s,?_,fun n => ?_⟩
  · dsimp only [s]
    rw [Measure.prod_prod,Measure.prod_prod]
    have hbfin : volume b ≠ ⊤ := (isCompact_closedBall (0:Velocity) R).measure_lt_top.ne
    exact ENNReal.mul_ne_top (measure_ne_top μ univ) (ENNReal.mul_ne_top hbfin hbfin)
  · let u := entropyTruncation R (f n)
    have hzero z (hz : z ∉ s) : normalizedTensor (fiberMass volume (f n)) u u z = 0 :=
      truncated_pair_support R (f n) z hz
    have hdom z : ‖sᶜ.indicator (normalizedPair volume (f n)) z‖ ≤
        ‖normalizedPair volume (f n) z-normalizedTensor (fiberMass volume (f n)) u u z‖ := by
      by_cases hz : z ∈ s
      · rw [indicator_of_notMem (notMem_compl_iff.mpr hz),norm_zero]
        exact norm_nonneg _
      · rw [indicator_of_mem (mem_compl hz),hzero z hz,sub_zero]
    have hm := normalizedTensor_measurable (fiberMass_measurable (ν := volume) (hfm n)) (hfm n) (hfm n)
    exact (eLpNorm_mono (hm.indicator hs.compl).aestronglyMeasurable hdom).trans
      ((normalizedPair_entropy_error hR (hfm n) (hf n) (hi n) (hb n)).trans hj)

end BoltzmannNonuniqueness.Compactness

end

end

section

/-! # Actual pre- and post-collision rates normalized by the spatial mass -/
noncomputable section
open MeasureTheory
namespace BoltzmannNonuniqueness.CollisionCompactness
open Compactness
variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ]

def massNormalizedPreRate (f : X × Velocity → ℝ) (z : (X × (Velocity × Velocity)) × Sphere) : ℝ :=
  preRate f z/(1+fiberMass volume f z.1.1)

def massNormalizedPostRate (f : X × Velocity → ℝ) (z : (X × (Velocity × Velocity)) × Sphere) : ℝ :=
  postRate f z/(1+fiberMass volume f z.1.1)

omit [MeasurableSpace X] in
theorem massNormalizedPreRate_eq (f : X × Velocity → ℝ) (z : (X × (Velocity × Velocity)) × Sphere) :
    massNormalizedPreRate f z = normalizedKernel z*weightedNormalizedPair f z.1 := by
  rw [massNormalizedPreRate,preRate_eq_normalized]
  dsimp only [pairDensity,weightedNormalizedPair,pairVelocityWeight,normalizedPair,normalizedTensor]
  ring

omit [MeasurableSpace X] in
theorem massNormalizedPreRate_eq_fun (f : X × Velocity → ℝ) :
    massNormalizedPreRate f = fun z => normalizedKernel z*weightedNormalizedPair f z.1 :=
  funext (massNormalizedPreRate_eq f)

omit [MeasurableSpace X] in
theorem massNormalizedPostRate_eq (f : X × Velocity → ℝ) :
    massNormalizedPostRate f = massNormalizedPreRate f ∘ scatterTriple := rfl

theorem massNormalizedPreRate_measurable {f : X × Velocity → ℝ} (hfm : Measurable f) :
    Measurable (massNormalizedPreRate f) := by
  rw [massNormalizedPreRate_eq_fun]
  exact normalizedKernel_measurable.mul ((weightedNormalizedPair_measurable hfm).comp measurable_fst)

theorem massNormalizedPostRate_measurable {f : X × Velocity → ℝ} (hfm : Measurable f) :
    Measurable (massNormalizedPostRate f) :=
  (massNormalizedPreRate_measurable hfm).comp scatterTriple_measurable

omit [SFinite μ] in
theorem massNormalizedPreRate_integrable {f : X × Velocity → ℝ} (_hfm : Measurable f)
    (hi : Integrable (weightedNormalizedPair f) (μ.prod (volume : Measure (Velocity × Velocity)))) :
    Integrable (massNormalizedPreRate f) ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea) := by
  have h := (hi.comp_fst sphereArea).bdd_mul normalizedKernel_measurable.aestronglyMeasurable
    (ae_of_all _ normalizedKernel_bound)
  simpa only [massNormalizedPreRate_eq_fun] using h

theorem massNormalizedPostRate_integrable {f : X × Velocity → ℝ} (hfm : Measurable f)
    (hi : Integrable (weightedNormalizedPair f) (μ.prod (volume : Measure (Velocity × Velocity)))) :
    Integrable (massNormalizedPostRate f) ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea) :=
  (scatterTriple_measurePreserving μ).integrable_comp_of_integrable (massNormalizedPreRate_integrable hfm hi)

theorem weak_massNormalizedPreRate {f : ℕ → X × Velocity → ℝ} {g : X × Velocity → ℝ}
    (h : Published.WeakL1Converges (μ.prod (volume : Measure (Velocity × Velocity)))
      (fun n => weightedNormalizedPair (f n)) (weightedNormalizedPair g))
    (hfi : ∀ n, Integrable (weightedNormalizedPair (f n)) (μ.prod (volume : Measure (Velocity × Velocity)))) :
    Published.WeakL1Converges ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)
      (fun n => massNormalizedPreRate (f n)) (massNormalizedPreRate g) := by
  have h := (h.prod_constant (ν := sphereArea) hfi).bounded_mul normalizedKernel_measurable
    1 normalizedKernel_bound
  simpa only [massNormalizedPreRate_eq_fun] using h

theorem weak_massNormalizedPostRate {f : ℕ → X × Velocity → ℝ} {g : X × Velocity → ℝ}
    (hfm : ∀ n, Measurable (f n)) (hgm : Measurable g)
    (h : Published.WeakL1Converges (μ.prod (volume : Measure (Velocity × Velocity)))
      (fun n => weightedNormalizedPair (f n)) (weightedNormalizedPair g))
    (hfi : ∀ n, Integrable (weightedNormalizedPair (f n)) (μ.prod (volume : Measure (Velocity × Velocity)))) :
    Published.WeakL1Converges ((μ.prod (volume : Measure (Velocity × Velocity))).prod sphereArea)
      (fun n => massNormalizedPostRate (f n)) (massNormalizedPostRate g) := by
  apply Published.WeakL1Converges.of_comp_measurePreserving (scatterTriple_measurePreserving μ)
    (fun n => massNormalizedPostRate_measurable (hfm n)) (massNormalizedPostRate_measurable hgm)
  have hs (z : (X × (Velocity × Velocity)) × Sphere) := scatterTriple_involutive z
  simpa only [massNormalizedPostRate_eq,Function.comp_def,hs] using weak_massNormalizedPreRate h hfi

end BoltzmannNonuniqueness.CollisionCompactness

end

end

end OAI