lean/OAI/Dynamics/TriangleBilliards/Localization.lean

import OAI.Dynamics.TriangleBilliards.SecondDerivatives

namespace OAI

universe uA

open MeasureTheory Set
open scoped ENNReal symmDiff
noncomputable section
open MeasureTheory Set Filter Function Metric
open scoped Topology Convolution ContDiff
noncomputable section
open MeasureTheory Set
open scoped ENNReal
noncomputable section
open MeasureTheory Set Filter BoundedContinuousFunction
open scoped ENNReal Topology ComplexConjugate
noncomputable section
open MeasureTheory Set Filter
open scoped Topology ComplexConjugate
noncomputable section
open MeasureTheory Filter
open scoped ComplexConjugate
noncomputable section
open MeasureTheory Filter Set
open scoped Topology ComplexConjugate
noncomputable section
open Filter Finset Set
open scoped Topology BigOperators
noncomputable section
open MeasureTheory Filter Set
open scoped Topology ContDiff NNReal

open MeasureTheory Filter Set
open scoped Topology ComplexConjugate
noncomputable section
namespace TriangularBilliards.Analysis
variable {A : Type uA} [MeasurableSpace A] {μ : Measure A}

def restrictL2 (E : Set A) (hE : MeasurableSet E) : Lp ℂ 2 μ →L[ℂ] Lp ℂ 2 μ :=
  LinearMap.mkContinuous
    { toFun := fun u => ((Lp.memLp u).indicator hE).toLp (E.indicator u)
      map_add' := fun u v => by
        apply Lp.ext
        filter_upwards [((Lp.memLp (u+v)).indicator hE).coeFn_toLp,
          ((Lp.memLp u).indicator hE).coeFn_toLp,
          ((Lp.memLp v).indicator hE).coeFn_toLp,
          Lp.coeFn_add u v,
          Lp.coeFn_add (((Lp.memLp u).indicator hE).toLp _) (((Lp.memLp v).indicator hE).toLp _)]
          with z h0 h1 h2 h3 h4
        simp only [Pi.add_apply] at h3 h4
        rw [h0, h4, h1, h2]
        by_cases hz : z ∈ E
        · simp only [indicator_of_mem hz]; exact h3
        · simp only [indicator_of_notMem hz, add_zero]
      map_smul' := fun c u => by
        apply Lp.ext
        filter_upwards [((Lp.memLp (c • u)).indicator hE).coeFn_toLp,
          ((Lp.memLp u).indicator hE).coeFn_toLp, Lp.coeFn_smul c u,
          Lp.coeFn_smul c (((Lp.memLp u).indicator hE).toLp _)] with z h0 h1 h2 h3
        simp only [Pi.smul_apply] at h2 h3
        change _ = (c • (((Lp.memLp u).indicator hE).toLp _)) z
        rw [h0, h3, h1]
        by_cases hz : z ∈ E
        · simp only [indicator_of_mem hz]; exact h2
        · simp only [indicator_of_notMem hz, smul_zero] }
    1 (fun u => by
      simp only [one_mul]
      change ‖((Lp.memLp u).indicator hE).toLp _‖ ≤ ‖u‖
      apply Lp.norm_le_norm_of_ae_le
      filter_upwards [((Lp.memLp u).indicator hE).coeFn_toLp] with z hz
      rw [hz]
      exact norm_indicator_le_norm_self _ _)

lemma restrictL2_coe (E : Set A) (hE : MeasurableSet E) (u : Lp ℂ 2 μ) :
    (restrictL2 E hE u : A → ℂ) =ᵐ[μ] E.indicator u :=
  ((Lp.memLp u).indicator hE).coeFn_toLp

lemma restrictL2_selfadjoint (E : Set A) (hE : MeasurableSet E) (u v : Lp ℂ 2 μ) :
    inner ℂ (restrictL2 E hE u) v = inner ℂ u (restrictL2 E hE v) := by
  rw [L2.inner_def, L2.inner_def]
  apply integral_congr_ae
  filter_upwards [restrictL2_coe E hE u, restrictL2_coe E hE v] with z hu hv
  rw [hu, hv]
  by_cases hz : z ∈ E
  · simp only [indicator_of_mem hz]
  · simp only [indicator_of_notMem hz, inner_zero_left, inner_zero_right]

lemma restrictL2_fixed (E : Set A) (hE : MeasurableSet E) (u : Lp ℂ 2 μ)
    (hu : ∀ᵐ z ∂μ, z ∉ E → u z = 0) : restrictL2 E hE u = u := by
  apply Lp.ext
  filter_upwards [restrictL2_coe E hE u, hu] with z hz hzz
  rw [hz]
  by_cases hm : z ∈ E
  · exact indicator_of_mem hm _
  · simp only [indicator_of_notMem hm, hzz hm]

lemma restrictL2_commute (E : Set A) (hE : MeasurableSet E)
    (ρ : A → A) (hρ : MeasurePreserving ρ μ μ) (he : ∀ z, ρ z ∈ E ↔ z ∈ E)
    (u : Lp ℂ 2 μ) :
    restrictL2 E hE (Lp.compMeasurePreserving ρ hρ u) =
      Lp.compMeasurePreserving ρ hρ (restrictL2 E hE u) := by
  apply Lp.ext
  filter_upwards [restrictL2_coe E hE (Lp.compMeasurePreserving ρ hρ u),
    Lp.coeFn_compMeasurePreserving u hρ,
    Lp.coeFn_compMeasurePreserving (restrictL2 E hE u) hρ,
    hρ.quasiMeasurePreserving.ae (restrictL2_coe E hE u)] with z h0 h1 h2 h3
  rw [h0, h2]
  change _ = restrictL2 E hE u (ρ z)
  rw [h3]
  by_cases hz : z ∈ E
  · rw [indicator_of_mem hz, indicator_of_mem ((he z).mpr hz)]
    exact h1
  · rw [indicator_of_notMem hz, indicator_of_notMem (fun h => hz ((he z).mp h))]

lemma restrictL2_norm (E : Set A) (hE : MeasurableSet E) (u : Lp ℂ 2 μ) :
    ‖restrictL2 E hE u‖ ≤ ‖u‖ := by
  apply Lp.norm_le_norm_of_ae_le
  filter_upwards [restrictL2_coe E hE u] with z hz
  rw [hz]
  exact norm_indicator_le_norm_self _ _

end TriangularBilliards.Analysis

namespace TriangularBilliards
open Analysis MeasureTheory Filter Set
open scoped ContDiff NNReal
local instance : Fact (0 < 2 * Real.pi) := ⟨by positivity⟩

lemma spatialRestriction_commute (Q : Triangle) (E : Set ℂ) (hE : MeasurableSet E)
    (θ : AddCircle (2 * Real.pi)) (u : Lp ℂ 2 (doubleMeasure Q)) :
    restrictL2 {z : DoublePhase | z.1.1 ∈ E} (hE.preimage measurable_fst.fst)
        ((angularCircleAction Q).act θ u) =
      (angularCircleAction Q).act θ
        (restrictL2 {z : DoublePhase | z.1.1 ∈ E} (hE.preimage measurable_fst.fst) u) := by
  exact restrictL2_commute _ _ (doubleRotate θ.toCircle)
    (measurePreserving_doubleRotate Q θ.toCircle) (fun _ => Iff.rfl) u

/-- The localized energy bound on the actual smooth core. Every generator
and Fourier projection here is that of the actual billiard double. -/
lemma seam_localized_energy {Q : Triangle} {f : DoublePhase → ℂ}
    (hs : SeamCompatible Q f) (hm : Measurable f)
    (hd : ∀ v b, ContDiff ℝ ∞ (fun x => f ((x,v),b)))
    {C D : ℝ≥0}
    (hC : ∀ x v b, ‖fderiv ℝ (fun y => f ((y,v),b)) x‖ ≤ C)
    (hD : ∀ x v b, ‖fderiv ℝ (fderiv ℝ (fun y => f ((y,v),b))) x‖ ≤ D)
    (hf : MemLp f 2 (doubleMeasure Q))
    (E : Set ℂ) (hE : MeasurableSet E)
    (hX : ∀ᵐ z ∂doubleMeasure Q, z.1.1 ∉ E → xDerivative f z = 0) (j : ℤ) :
    let hx := xDerivative_memLp_of_gradient_bound Q hm
      (fun v b => (hd v b).differentiable (by simp)) hC
    let hy := yDerivative_memLp_of_gradient_bound Q hm
      (fun v b => (hd v b).differentiable (by simp)) hC
    let R := restrictL2 (μ := doubleMeasure Q) {z : DoublePhase | z.1.1 ∈ E} (hE.preimage measurable_fst.fst)
    ∃ dx dy : Lp ℂ 2 (doubleMeasure Q),
      (geodesicHilbertFlow Q).HasGenerator ((angularCircleAction Q).projection j (hf.toLp _)) dx ∧
      (transverseHilbertFlow Q).HasGenerator ((angularCircleAction Q).projection j (hf.toLp _)) dy ∧
      ‖dx‖ ^ 2 ≤ 4 * ‖hx.toLp _‖ * ‖R (hy.toLp _)‖ ∧
      ‖dy‖ ^ 2 ≤ 4 * ‖hx.toLp _‖ * ‖R (hy.toLp _)‖ := by
  dsimp only
  let hx := xDerivative_memLp_of_gradient_bound Q hm
    (fun v b => (hd v b).differentiable (by simp)) hC
  let hy := yDerivative_memLp_of_gradient_bound Q hm
    (fun v b => (hd v b).differentiable (by simp)) hC
  let R := restrictL2 (μ := doubleMeasure Q) {z : DoublePhase | z.1.1 ∈ E} (hE.preimage measurable_fst.fst)
  let a := (1/2 : ℂ) • (hx.toLp _ - Complex.I • hy.toLp _)
  let b := (1/2 : ℂ) • (hx.toLp _ + Complex.I • hy.toLp _)
  have hab : a + b = hx.toLp _ := by dsimp [a,b]; module
  have hsub : a - b = (-Complex.I) • hy.toLp _ := by dsimp [a,b]; module
  have hRx : R (hx.toLp _) = hx.toLp _ := by
    apply restrictL2_fixed
    filter_upwards [hx.coeFn_toLp,hX] with z hz hh
    simpa only [hz, mem_ofPred_eq] using hh
  have hn (k : ℤ) : ‖(angularCircleAction Q).projection (k+2) a‖ =
      ‖(angularCircleAction Q).projection k b‖ := by
    have hh := seam_projected_CR_norms_of_bounded_jets hs hm hd hC hD hf (k+1)
    have hi : k + 1 + 1 = k + 2 := by omega
    simpa only [hi, add_sub_cancel_right] using hh
  have hh := (angularCircleAction Q).localized_CR_energy a b j R
    (spatialRestriction_commute Q E hE) (restrictL2_selfadjoint _ _)
    (by rw [hab]; exact hRx) hn
  have hRsub : ‖R (a-b)‖ = ‖R (hy.toLp _)‖ := by
    rw [hsub, map_smul, norm_smul, norm_neg, Complex.norm_I, one_mul]
  rw [hab, hRsub] at hh
  have hcr := seam_rotationalCR hs (fun v b => (hd v b).differentiable (by simp)) hC hf hx hy
  have hg := hcr.projection j
  have heq : ‖(angularCircleAction Q).projection (j+1) a‖ =
      ‖(angularCircleAction Q).projection (j-1) b‖ :=
    seam_projected_CR_norms_of_bounded_jets hs hm hd hC hD hf j
  let da := (angularCircleAction Q).projection (j+1) a
  let db := (angularCircleAction Q).projection (j-1) b
  refine ⟨da+db, Complex.I • (da-db), hg.1, hg.2, ?_, ?_⟩
  · have hl : ‖da+db‖ ≤ 2 * ‖da‖ := by
      calc _ ≤ ‖da‖ + ‖db‖ := norm_add_le _ _
           _ = _ := by rw [← heq]; ring
    calc
      _ ≤ (2*‖da‖)^2 := by gcongr
      _ = 4*‖da‖^2 := by ring
      _ ≤ _ := by linarith [hh]
  · have hl : ‖Complex.I • (da-db)‖ ≤ 2 * ‖da‖ := by
      rw [norm_smul, Complex.norm_I, one_mul]
      calc _ ≤ ‖da‖ + ‖db‖ := norm_sub_le _ _
           _ = _ := by rw [← heq]; ring
    calc
      _ ≤ (2*‖da‖)^2 := by gcongr
      _ = 4*‖da‖^2 := by ring
      _ ≤ _ := by linarith [hh]

end TriangularBilliards

namespace TriangularBilliards
open MeasureTheory Set
namespace Triangle
lemma clearance_sublevel (Q : Triangle) (R : ℝ) :
    {x | Q.clearance x ≤ R} = ⋃ i : Fin 3, Metric.closedBall (Q.vertex i) R := by
  ext x
  constructor
  · intro hx
    obtain ⟨y, ⟨i, rfl⟩, hi⟩ := (finite_range Q.vertex).isCompact.exists_infDist_eq_dist
      (range_nonempty Q.vertex) x
    exact mem_iUnion.mpr ⟨i, by simpa only [Metric.mem_closedBall, ← hi, clearance, mem_ofPred_eq] using hx⟩
  · intro hx
    obtain ⟨i, hi⟩ := mem_iUnion.mp hx
    exact le_trans (Metric.infDist_le_dist_of_mem (mem_range_self i)) hi

lemma clearance_sublevel_measurable (Q : Triangle) (R : ℝ) :
    MeasurableSet {x | Q.clearance x ≤ R} :=
  measurableSet_le Q.clearance_lipschitz.continuous.measurable measurable_const

lemma clearance_area_bound (Q : Triangle) (R : ℝ) :
    volume {x | Q.clearance x ≤ R} ≤
      3 * (ENNReal.ofReal R) ^ 2 * (NNReal.pi : ℝ≥0∞) := by
  rw [Q.clearance_sublevel]
  calc
    volume (⋃ i : Fin 3, Metric.closedBall (Q.vertex i) R) ≤
      ∑' i : Fin 3, volume (Metric.closedBall (Q.vertex i) R) := measure_iUnion_le _
    _ = 3 * (ENNReal.ofReal R) ^ 2 * (NNReal.pi : ℝ≥0∞) := by
      simp only [Complex.volume_closedBall, tsum_fintype, Finset.sum_const,
        Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
      ring

end Triangle

/-- The small-tip neighborhood on the actual oriented double. -/
def unsafeSet (Q : Triangle) (R : ℝ) : Set DoublePhase :=
  {z | Q.clearance z.1.1 ≤ R}

lemma unsafeSet_measurable (Q : Triangle) (R : ℝ) : MeasurableSet (unsafeSet Q R) :=
  (Q.clearance_sublevel_measurable R).preimage measurable_fst.fst

lemma unsafeSet_measure_bound (Q : Triangle) (R : ℝ) :
    doubleMeasure Q (unsafeSet Q R) ≤
      (volume Q.table)⁻¹ * (3 * (ENNReal.ofReal R) ^ 2 * (NNReal.pi : ℝ≥0∞)) := by
  have he : unsafeSet Q R = ({x : ℂ | Q.clearance x ≤ R} ×ˢ (univ : Set Circle)) ×ˢ
      (univ : Set (ZMod 2)) := by ext z; simp only [unsafeSet, mem_ofPred_eq, mem_prod,
      mem_univ, and_true]
  rw [he, doubleMeasure, Measure.prod_prod, measure_univ, mul_one,
    phaseMeasure, Measure.prod_prod, measure_univ, mul_one, Measure.smul_apply, smul_eq_mul]
  gcongr
  calc
    volume.restrict Q.table {x | Q.clearance x ≤ R} ≤ volume {x | Q.clearance x ≤ R} :=
      Measure.restrict_apply_le _ _
    _ ≤ _ := Q.clearance_area_bound R

end TriangularBilliards

namespace TriangularBilliards.Analysis
open MeasureTheory Filter Set
variable {A : Type uA} [MeasurableSpace A] {μ : Measure A}
lemma restrictL2_norm_of_bounded (E : Set A) (hE : MeasurableSet E) (hμE : μ E ≠ ⊤)
    {u : Lp ℂ 2 μ} {H : ℝ} (hH : 0 ≤ H) (hu : ∀ᵐ z ∂μ, ‖u z‖ ≤ H) :
    ‖restrictL2 E hE u‖ ≤ H * (μ E).toReal ^ (1/2 : ℝ) := by
  calc
    _ ≤ ‖indicatorConstLp 2 hE hμE (H : ℂ)‖ := by
      apply Lp.norm_le_norm_of_ae_le
      filter_upwards [hu,restrictL2_coe E hE u,
        indicatorConstLp_coeFn (p := 2) (hs := hE) (hμs := hμE) (c := (H : ℂ))] with z hz he hc
      rw [he,hc]
      by_cases h : z ∈ E
      · simpa only [indicator_of_mem h, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hH] using hz
      · simp only [indicator_of_notMem h, le_refl]
    _ = _ := by rw [norm_indicatorConstLp (by norm_num : (2 : ℝ≥0∞) ≠ 0)
        (by norm_num : (2 : ℝ≥0∞) ≠ ⊤)]
                simp [Complex.norm_real, abs_of_nonneg hH, Measure.real]

end TriangularBilliards.Analysis

namespace TriangularBilliards
open Analysis SpatialSmoothing MeasureTheory Filter Set
open scoped Topology ContDiff NNReal
local instance : Fact (0 < 2 * Real.pi) := ⟨by positivity⟩

lemma vertexCutoff_fderiv_zero_of_large (Q : Triangle) {R : ℝ} (hR : 0 < R) {x : ℂ}
    (hx : 2 * R < Q.clearance x) : fderiv ℝ (vertexCutoff Q R) x = 0 := by
  have he : vertexCutoff Q R =ᶠ[𝓝 x] fun _ => (1 : ℝ) := by
    filter_upwards [((isOpen_lt continuous_const Q.clearance_lipschitz.continuous).mem_nhds hx)] with y hy
    exact vertexCutoff_one Q hR hy.le
  rw [he.fderiv_eq, fderiv_const_apply]

lemma supportedSmoothing_invariant_x_zero (Q : Triangle) {ε R A : ℝ}
    (hε : 0 < ε) (hR : Q.safetyFactor * ε < R)
    (hsmall : 2 * R * Q.coordinateBound < 1) (hA : 2 * R + ε ≤ A)
    {f : DoublePhase → ℂ} (hm : StronglyMeasurable f)
    (hf : MemLp f 2 (doubleMeasure Q))
    (hfi : (geodesicHilbertFlow Q).HasGenerator (hf.toLp f) 0)
    {H : ℝ} (hH : ∀ z, ‖f z‖ ≤ H) :
    ∀ᵐ z ∂doubleMeasure Q, z ∉ unsafeSet Q A →
      xDerivative (supportedSmoothing Q ε R f) z = 0 := by
  have hRp : 0 < R := (mul_pos Q.safetyFactor_pos hε).trans hR
  filter_upwards [invariant_smoothing_direction_zero Q hε hR hsmall hA hm hf hfi hH] with z hz hza
  have hb : A < Q.clearance z.1.1 := lt_of_not_ge hza
  have hc : 2 * R < Q.clearance z.1.1 := by linarith
  rw [supportedSmoothing_xDerivative Q hε R hm hH,
    supportedSmoothingGradient, vertexCutoff_fderiv_zero_of_large Q hRp hc,
    vertexCutoff_one Q hRp hc.le, one_smul, ContinuousLinearMap.zero_smulRight, add_zero]
  exact hz hb.le

lemma unsafeSet_real_measure_bound (Q : Triangle) {R : ℝ} (hR : 0 ≤ R) :
    (doubleMeasure Q (unsafeSet Q R)).toReal ≤
      ((volume Q.table).toReal)⁻¹ * (3 * R ^ 2 * Real.pi) := by
  have ht : (volume Q.table)⁻¹ * (3 * (ENNReal.ofReal R)^2 * (NNReal.pi : ℝ≥0∞)) ≠ ⊤ := by
    exact ENNReal.mul_ne_top (ENNReal.inv_ne_top.mpr Q.area_pos.ne') (by finiteness)
  have hh := ENNReal.toReal_mono ht (unsafeSet_measure_bound Q R)
  simpa only [ENNReal.toReal_mul, ENNReal.toReal_inv, ENNReal.toReal_pow,
    ENNReal.toReal_ofNat, ENNReal.toReal_ofReal hR, ENNReal.coe_toReal, NNReal.coe_real_pi] using hh

/-- Generic localized gradient control on an actual smooth seam field, with
its exact tip-neighborhood measure retained. -/
lemma seam_tip_energy {Q : Triangle} {f : DoublePhase → ℂ}
    (hs : SeamCompatible Q f) (hm : Measurable f)
    (hd : ∀ v b, ContDiff ℝ ∞ (fun x => f ((x,v),b)))
    {C D : ℝ≥0}
    (hC : ∀ x v b, ‖fderiv ℝ (fun y => f ((y,v),b)) x‖ ≤ C)
    (hD : ∀ x v b, ‖fderiv ℝ (fderiv ℝ (fun y => f ((y,v),b))) x‖ ≤ D)
    (hf : MemLp f 2 (doubleMeasure Q)) (A : ℝ)
    (hX : ∀ᵐ z ∂doubleMeasure Q, z ∉ unsafeSet Q A → xDerivative f z = 0) (j : ℤ) :
    ∃ dx dy : Lp ℂ 2 (doubleMeasure Q),
      (geodesicHilbertFlow Q).HasGenerator ((angularCircleAction Q).projection j (hf.toLp _)) dx ∧
      (transverseHilbertFlow Q).HasGenerator ((angularCircleAction Q).projection j (hf.toLp _)) dy ∧
      ‖dx‖ ^ 2 ≤ 4 * (C : ℝ)^2 * (doubleMeasure Q (unsafeSet Q A)).toReal ∧
      ‖dy‖ ^ 2 ≤ 4 * (C : ℝ)^2 * (doubleMeasure Q (unsafeSet Q A)).toReal := by
  let hx := xDerivative_memLp_of_gradient_bound Q hm
    (fun v b => (hd v b).differentiable (by simp)) hC
  let hy := yDerivative_memLp_of_gradient_bound Q hm
    (fun v b => (hd v b).differentiable (by simp)) hC
  let R := restrictL2 (μ := doubleMeasure Q) (unsafeSet Q A) (unsafeSet_measurable Q A)
  have hxb : ∀ᵐ z ∂doubleMeasure Q, ‖hx.toLp _ z‖ ≤ (C : ℝ) := by
    filter_upwards [hx.coeFn_toLp] with z hz
    rw [hz]
    exact (ContinuousLinearMap.le_opNorm _ _).trans (by
      rw [Circle.norm_coe, mul_one]; exact hC z.1.1 z.1.2 z.2)
  have hyb : ∀ᵐ z ∂doubleMeasure Q, ‖hy.toLp _ z‖ ≤ (C : ℝ) := by
    filter_upwards [hy.coeFn_toLp] with z hz
    rw [hz]
    exact (ContinuousLinearMap.le_opNorm _ _).trans (by
      rw [norm_transverseVelocity, mul_one]; exact hC z.1.1 z.1.2 z.2)
  have hrx : R (hx.toLp _) = hx.toLp _ := by
    apply restrictL2_fixed
    filter_upwards [hx.coeFn_toLp,hX] with z hz hh
    simpa only [hz] using hh
  have hxn : ‖hx.toLp _‖ ≤ (C : ℝ) * (doubleMeasure Q (unsafeSet Q A)).toReal ^ (1/2 : ℝ) := by
    rw [← hrx]
    exact restrictL2_norm_of_bounded _ _ (measure_ne_top _ _) C.coe_nonneg hxb
  have hyn := restrictL2_norm_of_bounded (unsafeSet Q A) (unsafeSet_measurable Q A)
    (measure_ne_top _ _) C.coe_nonneg hyb
  obtain ⟨dx,dy,hgx,hgy,hbx,hby⟩ := seam_localized_energy hs hm hd hC hD hf
    {x | Q.clearance x ≤ A} (Q.clearance_sublevel_measurable A) hX j
  have hmass : ((doubleMeasure Q (unsafeSet Q A)).toReal ^ (1/2 : ℝ))^2 =
      (doubleMeasure Q (unsafeSet Q A)).toReal := by
    rw [← Real.sqrt_eq_rpow, Real.sq_sqrt ENNReal.toReal_nonneg]
  have hb : 4 * ‖hx.toLp _‖ * ‖R (hy.toLp _)‖ ≤
      4 * (C : ℝ)^2 * (doubleMeasure Q (unsafeSet Q A)).toReal := by
    calc
      _ ≤ 4 * ((C : ℝ) * (doubleMeasure Q (unsafeSet Q A)).toReal ^ (1/2 : ℝ)) *
          ((C : ℝ) * (doubleMeasure Q (unsafeSet Q A)).toReal ^ (1/2 : ℝ)) := by
        gcongr
      _ = _ := by nlinarith [hmass]
  exact ⟨dx,dy,hgx,hgy,hbx.trans hb,hby.trans hb⟩

end TriangularBilliards

end
end
end
end
end
end
end
end
end

end OAI