import Mathlib

namespace OAI

noncomputable section

open scoped ComplexConjugate
open scoped BigOperators
open scoped BigOperators BoundedContinuousFunction
open Filter Topology
open MeasureTheory Filter
open scoped ENNReal ComplexConjugate
open MeasureTheory ProbabilityTheory
open scoped ComplexConjugate
open scoped BigOperators
open scoped BigOperators
open Polynomial
open MeasureTheory
open scoped BigOperators
open MeasureTheory
open scoped BigOperators
open MeasureTheory
open MeasureTheory ProbabilityTheory
open scoped BigOperators
open MeasureTheory
open scoped BigOperators ComplexConjugate
open MeasureTheory ProbabilityTheory
open scoped ENNReal BigOperators

open MeasureTheory Filter
open scoped Topology ENNReal NNReal

namespace EuclideanFiveColor.Location

abbrev Ambient := WithLp 2 (ℝ × ℂ)

def lift (z : ℂ) : Ambient := WithLp.toLp 2 (1, z)

@[simp] theorem lift_fst (z : ℂ) : (lift z).fst = 1 := rfl
@[simp] theorem lift_snd (z : ℂ) : (lift z).snd = z := rfl

theorem lift_ne_zero (z : ℂ) : lift z ≠ 0 := by
  intro h
  have := congrArg WithLp.fst h
  simp at this

theorem norm_lift (z : ℂ) : ‖lift z‖ = Real.sqrt (1 + ‖z‖ ^ 2) := by
  simp [WithLp.prod_norm_eq_of_L2]

theorem lift_sub (z w : ℂ) : lift z - lift w = WithLp.toLp 2 (0, z - w) := by
  apply WithLp.ofLp_injective 2
  simp [lift]

theorem norm_lift_sub (z w : ℂ) : ‖lift z - lift w‖ = ‖z - w‖ := by
  rw [lift_sub, WithLp.norm_toLp_snd]

theorem lift_affine (z w : ℂ) (a b : ℝ) (hab : a + b = 1) :
    lift (a • z + b • w) = a • lift z + b • lift w := by
  apply WithLp.ofLp_injective 2
  apply Prod.ext
  · simpa using hab.symm
  · rfl

theorem not_sameRay_smul_lift {z w : ℂ} (hzw : z ≠ w)
    {a b : ℝ} (ha : 0 < a) (hb : 0 < b) :
    ¬ SameRay ℝ (a • lift z) (b • lift w) := by
  intro h
  have haz : a • lift z ≠ 0 := smul_ne_zero ha.ne' (lift_ne_zero z)
  have hbw : b • lift w ≠ 0 := smul_ne_zero hb.ne' (lift_ne_zero w)
  obtain ⟨r, hr, he⟩ := h.exists_pos_left haz hbw
  have hfst := congrArg WithLp.fst he
  have hsnd := congrArg WithLp.snd he
  simp only [WithLp.smul_fst, lift_fst, smul_eq_mul, mul_one] at hfst
  simp only [WithLp.smul_snd, lift_snd, smul_smul, hfst] at hsnd
  exact hzw ((smul_right_injective ℂ hb.ne') hsnd)

theorem strictConvex_norm_lift : StrictConvexOn ℝ Set.univ (fun z : ℂ => ‖lift z‖) := by
  refine ⟨convex_univ, ?_⟩
  intro z _ w _ hzw a b ha hb hab
  change ‖lift (a • z + b • w)‖ < a • ‖lift z‖ + b • ‖lift w‖
  rw [lift_affine z w a b hab]
  have := norm_add_lt_of_not_sameRay (not_sameRay_smul_lift hzw ha hb)
  simpa only [norm_smul, Real.norm_eq_abs, abs_of_pos ha, abs_of_pos hb,
    smul_eq_mul] using this

noncomputable def kernel (s t : ℂ) : ℝ := ‖lift (s - t)‖ - ‖lift (-t)‖

noncomputable def objective (μ : Measure ℂ) (s : ℂ) : ℝ := ∫ t, kernel s t ∂μ

theorem kernel_formula (s t : ℂ) : kernel s t =
    Real.sqrt (1 + ‖s - t‖ ^ 2) - Real.sqrt (1 + ‖t‖ ^ 2) := by
  simp [kernel, norm_lift]

theorem continuous_kernel (s : ℂ) : Continuous (kernel s) := by
  simp only [funext (kernel_formula s)]
  fun_prop

theorem kernel_bound (s t : ℂ) : |kernel s t| ≤ ‖s‖ := by
  have h := abs_norm_sub_norm_le (lift (s - t)) (lift (-t))
  simpa [kernel, norm_lift_sub] using h

theorem kernel_diff_bound (s s' t : ℂ) : |kernel s t - kernel s' t| ≤ ‖s - s'‖ := by
  have h := abs_norm_sub_norm_le (lift (s - t)) (lift (s' - t))
  simpa [kernel, norm_lift_sub, sub_sub_sub_cancel_right] using h

theorem integrable_kernel (μ : Measure ℂ) [IsFiniteMeasure μ] (s : ℂ) :
    Integrable (kernel s) μ := by
  apply (integrable_const ‖s‖).mono' (continuous_kernel s).aestronglyMeasurable
  exact Eventually.of_forall fun t => by simpa using kernel_bound s t

theorem objective_zero (μ : Measure ℂ) : objective μ 0 = 0 := by
  simp [objective, kernel]

theorem objective_lipschitz (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    LipschitzWith 1 (objective μ) := by
  apply LipschitzWith.of_dist_le_mul
  intro s s'
  rw [Real.dist_eq, objective, objective, ← integral_sub (integrable_kernel μ s)
    (integrable_kernel μ s')]
  calc
    |∫ t, kernel s t - kernel s' t ∂μ| ≤ ∫ t, |kernel s t - kernel s' t| ∂μ :=
      abs_integral_le_integral_abs
    _ ≤ ∫ _ : ℂ, ‖s - s'‖ ∂μ := by
      apply integral_mono ((integrable_kernel μ s).sub (integrable_kernel μ s')).abs
        (integrable_const _)
      exact fun t => kernel_diff_bound s s' t
    _ = (1 : ℝ≥0) * dist s s' := by simp [dist_eq_norm]

theorem continuous_objective (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    Continuous (objective μ) := (objective_lipschitz μ).continuous

theorem kernel_strict_convex (t : ℂ) : StrictConvexOn ℝ Set.univ (fun s => kernel s t) := by
  refine ⟨convex_univ, ?_⟩
  intro z _ w _ hzw a b ha hb hab
  have hn : z - t ≠ w - t := sub_left_injective.ne hzw
  have h := strictConvex_norm_lift.2 (Set.mem_univ (z - t))
    (Set.mem_univ (w - t)) hn ha hb hab
  have ht : a • t + b • t = t := by rw [← add_smul, hab, one_smul]
  have he : a • (z - t) + b • (w - t) = a • z + b • w - t := by
    calc
      _ = a • z + b • w - (a • t + b • t) := by
        simp only [smul_sub]
        abel
      _ = _ := by rw [ht]
  dsimp only at h
  rw [he] at h
  dsimp only [kernel]
  simp only [smul_eq_mul] at h ⊢
  have hc : a * ‖lift (-t)‖ + b * ‖lift (-t)‖ = ‖lift (-t)‖ := by
    rw [← add_mul, hab, one_mul]
  nlinarith only [h, hc]

theorem objective_strict_convex (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    StrictConvexOn ℝ Set.univ (objective μ) := by
  refine ⟨convex_univ, ?_⟩
  intro z hz w hw hzw a b ha hb hab
  have hk (t : ℂ) := (kernel_strict_convex t).2 hz hw hzw ha hb hab
  have hf := integrable_kernel μ (a • z + b • w)
  have hg := ((integrable_kernel μ z).smul a).add ((integrable_kernel μ w).smul b)
  change (∫ t, kernel (a • z + b • w) t ∂μ) <
    a • (∫ t, kernel z t ∂μ) + b • (∫ t, kernel w t ∂μ)
  rw [← integral_smul, ← integral_smul, ← integral_add]
  · refine lt_of_le_of_ne (integral_mono hf hg fun t => (hk t).le) ?_
    intro he
    have heq := (integral_eq_iff_of_ae_le hf hg
      (Eventually.of_forall fun t => (hk t).le)).mp he
    obtain ⟨t, ht⟩ := heq.exists
    exact (hk t).ne ht
  · exact (integrable_kernel μ z).smul a
  · exact (integrable_kernel μ w).smul b

theorem norm_lift_le (z : ℂ) : ‖lift z‖ ≤ ‖z‖ + 1 := by
  calc
    ‖lift z‖ ≤ ‖lift z - lift 0‖ + ‖lift 0‖ := norm_le_norm_sub_add _ _
    _ = ‖z‖ + 1 := by simp [norm_lift_sub, norm_lift]

theorem kernel_lower (s t : ℂ) : ‖s‖ - 2 * ‖t‖ - 1 ≤ kernel s t := by
  have hst : ‖s - t‖ ≤ ‖lift (s - t)‖ := WithLp.norm_snd_le ℝ (lift (s - t))
  have hs : ‖s‖ ≤ ‖s - t‖ + ‖t‖ := norm_le_norm_sub_add _ _
  have ht := norm_lift_le (-t)
  simp only [norm_neg] at ht
  dsimp only [kernel]
  linarith

theorem exists_ball_mass (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    ∃ n : ℕ, (1 / 2 : ℝ) < μ.real (Metric.closedBall 0 (n : ℝ)) := by
  by_contra! h
  have hm (n : ℕ) : μ (Metric.closedBall 0 (n : ℝ)) ≤ (1 / 2 : ℝ≥0∞) := by
    apply (ENNReal.toReal_le_toReal (measure_ne_top _ _) (by norm_num)).mp
    simpa [measureReal_def] using h n
  have hc : (⋃ n : ℕ, Metric.closedBall (0 : ℂ) (n : ℝ)) = Set.univ := by
    apply Set.eq_univ_of_forall
    intro z
    obtain ⟨n, hn⟩ := exists_nat_gt ‖z‖
    exact Set.mem_iUnion.mpr ⟨n, by simpa [Metric.mem_closedBall] using hn.le⟩
  have hmono : Monotone (fun n : ℕ => Metric.closedBall (0 : ℂ) (n : ℝ)) := by
    intro i j hij
    exact Metric.closedBall_subset_closedBall (Nat.cast_le.mpr hij)
  have he : μ (⋃ n : ℕ, Metric.closedBall (0 : ℂ) (n : ℝ)) ≤ (1 / 2 : ℝ≥0∞) := by
    rw [hmono.measure_iUnion]
    exact iSup_le hm
  rw [hc, measure_univ] at he
  norm_num at he

theorem objective_lower (μ : Measure ℂ) [IsProbabilityMeasure μ] (R : ℝ) (s : ℂ) :
    (2 * μ.real (Metric.closedBall 0 R) - 1) * ‖s‖ -
        μ.real (Metric.closedBall 0 R) * (2 * R + 1) ≤ objective μ s := by
  classical
  let B := Metric.closedBall (0 : ℂ) R
  let v := 2 * ‖s‖ - (2 * R + 1)
  have hB : MeasurableSet B := Metric.isClosed_closedBall.measurableSet
  have hi : Integrable (B.indicator (fun _ : ℂ => v)) μ :=
    (integrable_const v).indicator hB
  have hp (t : ℂ) : -‖s‖ + B.indicator (fun _ : ℂ => v) t ≤ kernel s t := by
    by_cases ht : t ∈ B
    · rw [Set.indicator_of_mem ht]
      have ht' : ‖t‖ ≤ R := by simpa [B, Metric.mem_closedBall] using ht
      have hlo := kernel_lower s t
      dsimp only [v]
      linarith
    · rw [Set.indicator_of_notMem ht, add_zero]
      exact (abs_le.mp (kernel_bound s t)).1
  calc
    _ = ∫ t : ℂ, -‖s‖ + B.indicator (fun _ : ℂ => v) t ∂μ := by
      rw [integral_add (integrable_const _) hi, integral_const,
        integral_indicator_const v hB]
      simp only [probReal_univ, smul_eq_mul]
      dsimp only [v, B]
      ring
    _ ≤ _ := integral_mono ((integrable_const _).add hi) (integrable_kernel μ s) hp

theorem linear_norm_coercive (a b : ℝ) (ha : 0 < a) :
    Tendsto (fun z : ℂ => a * ‖z‖ + b) (cocompact ℂ) atTop := by
  have ht : Tendsto (fun z : ℂ => a * ‖z‖) (cocompact ℂ) atTop :=
    Filter.Tendsto.const_mul_atTop ha (tendsto_norm_cocompact_atTop (E := ℂ))
  exact tendsto_atTop_add_const_right (cocompact ℂ) b ht

theorem objective_coercive (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    Tendsto (objective μ) (cocompact ℂ) atTop := by
  obtain ⟨n, hn⟩ := exists_ball_mass μ
  have hp : 0 < 2 * μ.real (Metric.closedBall 0 (n : ℝ)) - 1 := by linarith
  have ht := linear_norm_coercive (2 * μ.real (Metric.closedBall 0 (n : ℝ)) - 1)
    (-(μ.real (Metric.closedBall 0 (n : ℝ)) * (2 * (n : ℝ) + 1))) hp
  apply tendsto_atTop_mono (objective_lower μ (n : ℝ))
  simpa only [sub_eq_add_neg] using ht

theorem exists_unique_minimizer (μ : Measure ℂ) [IsProbabilityMeasure μ] :
    ∃! s, ∀ t, objective μ s ≤ objective μ t := by
  obtain ⟨s, hs⟩ := (continuous_objective μ).exists_forall_le (objective_coercive μ)
  refine ⟨s, hs, ?_⟩
  intro t ht
  exact (objective_strict_convex μ).eq_of_isMinOn (fun x _ => ht x)
    (fun x _ => hs x) (Set.mem_univ t) (Set.mem_univ s)

noncomputable def center (μ : ProbabilityMeasure ℂ) : ℂ :=
  (exists_unique_minimizer (μ : Measure ℂ)).choose

theorem center_minimizes (μ : ProbabilityMeasure ℂ) (s : ℂ) :
    objective (μ : Measure ℂ) (center μ) ≤ objective (μ : Measure ℂ) s :=
  (exists_unique_minimizer (μ : Measure ℂ)).choose_spec.1 s

theorem center_unique (μ : ProbabilityMeasure ℂ) {z : ℂ}
    (hz : ∀ t, objective (μ : Measure ℂ) z ≤ objective (μ : Measure ℂ) t) :
    z = center μ := (exists_unique_minimizer (μ : Measure ℂ)).choose_spec.2 z hz

noncomputable def universalKernel : ProbabilityTheory.Kernel (ProbabilityMeasure ℂ) ℂ :=
  ⟨fun μ => (μ : Measure ℂ), measurable_subtype_coe⟩

theorem measurable_objective (s : ℂ) :
    Measurable (fun μ : ProbabilityMeasure ℂ => objective (μ : Measure ℂ) s) :=
  ((continuous_kernel s).stronglyMeasurable.integral_kernel
    (κ := universalKernel)).measurable

theorem denseSeq_inf_eq_min {X : Type*} [TopologicalSpace X] [TopologicalSpace.SeparableSpace X]
    [Nonempty X] (f : X → ℝ) (hf : Continuous f) (x : X)
    (hx : ∀ y, f x ≤ f y) : (⨅ n, f (TopologicalSpace.denseSeq X n)) = f x := by
  have hb : BddBelow (Set.range (fun n => f (TopologicalSpace.denseSeq X n))) :=
    ⟨f x, by rintro _ ⟨n, rfl⟩; exact hx _⟩
  apply le_antisymm
  · exact (TopologicalSpace.denseRange_denseSeq X).induction_on
      (p := fun y => (⨅ n, f (TopologicalSpace.denseSeq X n)) ≤ f y) x
      (isClosed_le continuous_const hf) (fun n => ciInf_le hb n)
  · exact le_ciInf (fun n => hx _)

noncomputable def minValue (μ : ProbabilityMeasure ℂ) : ℝ :=
  ⨅ n, objective (μ : Measure ℂ) (TopologicalSpace.denseSeq ℂ n)

theorem measurable_minValue : Measurable minValue :=
  Measurable.iInf fun _n => measurable_objective _

theorem minValue_eq (μ : ProbabilityMeasure ℂ) :
    minValue μ = objective (μ : Measure ℂ) (center μ) :=
  denseSeq_inf_eq_min _ (continuous_objective _) _ (center_minimizes μ)

theorem exists_min_on_closed (μ : ProbabilityMeasure ℂ) {C : Set ℂ}
    (hC : IsClosed C) (hCn : C.Nonempty) :
    ∃ z ∈ C, ∀ t ∈ C, objective (μ : Measure ℂ) z ≤ objective (μ : Measure ℂ) t := by
  obtain ⟨x, hx⟩ := hCn
  apply (continuous_objective (μ : Measure ℂ)).continuousOn.exists_isMinOn' hC hx
  apply Filter.Eventually.filter_mono inf_le_left
  exact (objective_coercive (μ : Measure ℂ)).eventually
    (eventually_ge_atTop (objective (μ : Measure ℂ) x))

theorem measurable_center : Measurable center := by
  classical
  apply measurable_of_isClosed
  intro C hC
  by_cases hne : C.Nonempty
  · let : Nonempty C := hne.to_subtype
    let mC (μ : ProbabilityMeasure ℂ) : ℝ :=
      ⨅ n, objective (μ : Measure ℂ) (TopologicalSpace.denseSeq C n).val
    have hmC : Measurable mC := Measurable.iInf fun _n => measurable_objective _
    have he : center ⁻¹' C = {μ | mC μ = minValue μ} := by
      ext μ
      obtain ⟨z, hzC, hz⟩ := exists_min_on_closed μ hC hne
      have hm : mC μ = objective (μ : Measure ℂ) z :=
        denseSeq_inf_eq_min (fun t : C => objective (μ : Measure ℂ) t.val)
          ((continuous_objective _).comp continuous_subtype_val) ⟨z, hzC⟩
          (fun t => hz t.val t.property)
      rw [Set.mem_preimage, Set.mem_ofPred_eq, hm, minValue_eq]
      constructor
      · intro h
        exact le_antisymm (hz _ h) (center_minimizes μ z)
      · intro h
        have hzm : ∀ t, objective (μ : Measure ℂ) z ≤ objective (μ : Measure ℂ) t :=
          fun t => h.trans_le (center_minimizes μ t)
        rwa [center_unique μ hzm] at hzC
    rw [he]
    exact measurableSet_eq_fun hmC measurable_minValue
  · have he : C = ∅ := Set.not_nonempty_iff_eq_empty.mp hne
    simp [he]

theorem kernel_translate (s t v : ℂ) :
    kernel (s + v) (t + v) = kernel s t - kernel (-v) t := by
  have h₁ : s + v - (t + v) = s - t := by abel
  have h₂ : -(t + v) = -v - t := by abel
  simp only [kernel, h₁, h₂]
  ring

theorem objective_translate (μ : ProbabilityMeasure ℂ) (s v : ℂ) :
    objective (Measure.map (fun t => t + v) (μ : Measure ℂ)) (s + v) =
      objective (μ : Measure ℂ) s - objective (μ : Measure ℂ) (-v) := by
  have hm : AEMeasurable (fun t : ℂ => t + v) (μ : Measure ℂ) :=
    (continuous_id.add_const v).aemeasurable
  rw [objective, integral_map hm (continuous_kernel _).aestronglyMeasurable]
  simp only [kernel_translate]
  exact integral_sub (integrable_kernel _ _) (integrable_kernel _ _)

theorem center_translate (μ : ProbabilityMeasure ℂ) (v : ℂ) :
    center (μ.map (fun point => point + v)) = center μ + v := by
  apply Eq.symm
  apply center_unique
  intro t
  have he : t = (t - v) + v := by abel
  change objective (Measure.map (fun t : ℂ => t + v) (μ : Measure ℂ)) (center μ + v) ≤
    objective (Measure.map (fun t : ℂ => t + v) (μ : Measure ℂ)) t
  rw [objective_translate, he, objective_translate]
  exact sub_le_sub_right (center_minimizes μ (t - v)) _

theorem kernel_orthogonal (O : ℂ ≃ₗᵢ[ℝ] ℂ) (s t : ℂ) :
    kernel (O s) (O t) = kernel s t := by
  simp only [kernel_formula, ← O.map_sub, O.norm_map]

theorem objective_orthogonal (μ : ProbabilityMeasure ℂ) (O : ℂ ≃ₗᵢ[ℝ] ℂ) (s : ℂ) :
    objective (Measure.map O (μ : Measure ℂ)) (O s) = objective (μ : Measure ℂ) s := by
  rw [objective, integral_map O.continuous.aemeasurable
    (continuous_kernel _).aestronglyMeasurable]
  simp only [kernel_orthogonal, objective]

theorem center_orthogonal (μ : ProbabilityMeasure ℂ) (O : ℂ ≃ₗᵢ[ℝ] ℂ) :
    center (μ.map O) = O (center μ) := by
  apply Eq.symm
  apply center_unique
  intro t
  obtain ⟨s, rfl⟩ := O.surjective t
  rw [ProbabilityMeasure.toMeasure_map, objective_orthogonal, objective_orthogonal]
  exact center_minimizes μ s

end EuclideanFiveColor.Location

namespace EuclideanFiveColor.CosetCenter
open ProbabilityTheory

variable {G : Type*} [CommGroup G] [MeasurableSpace G]

structure Embedding (G : Type*) [CommGroup G] [MeasurableSpace G] where
  hom : Multiplicative ℂ →* G
  measurableEmbedding : MeasurableEmbedding (fun z : ℂ => hom (Multiplicative.ofAdd z))

namespace Embedding

variable (e : Embedding G)

def j (z : ℂ) : G := e.hom (Multiplicative.ofAdd z)

@[simp] theorem j_zero : e.j 0 = 1 := e.hom.map_one
@[simp] theorem j_add (z w : ℂ) : e.j (z + w) = e.j z * e.j w := e.hom.map_mul _ _
@[simp] theorem j_neg (z : ℂ) : e.j (-z) = (e.j z)⁻¹ := e.hom.map_inv _
@[simp] theorem j_sub (z w : ℂ) : e.j (z - w) = e.j z / e.j w := e.hom.map_div _ _

theorem j_injective : Function.Injective e.j := e.measurableEmbedding.injective

theorem measurable_j : Measurable e.j := e.measurableEmbedding.measurable

def ordinary : Subgroup G := e.hom.range

theorem mem_ordinary_iff (x : G) : x ∈ e.ordinary ↔ ∃ z : ℂ, e.j z = x := Iff.rfl

theorem range_j : Set.range e.j = (e.ordinary : Set G) := rfl

theorem measurableSet_ordinary : MeasurableSet (e.ordinary : Set G) :=
  e.measurableEmbedding.measurableSet_range

noncomputable def coordinate : G → ℂ := Function.extend e.j id (fun _ => 0)

theorem measurable_coordinate : Measurable e.coordinate :=
  e.measurableEmbedding.measurable_extend measurable_id measurable_const

@[simp] theorem coordinate_j (z : ℂ) : e.coordinate (e.j z) = z :=
  e.j_injective.extend_apply id (fun _ => 0) z

theorem j_coordinate {x : G} (hx : x ∈ e.ordinary) : e.j (e.coordinate x) = x := by
  obtain ⟨z, rfl⟩ := (e.mem_ordinary_iff x).mp hx
  simp

variable [MeasurableMul₂ G] [MeasurableInv G]

def coset (z : G) : Set G := {d | d / z ∈ e.ordinary}

theorem measurableSet_coset (z : G) : MeasurableSet (e.coset z) :=
  e.measurableSet_ordinary.preimage (measurable_id.div_const z)

noncomputable def frequencyMeasure (μ : Measure G) (z : G) : Measure ℂ :=
  (μ.restrict (e.coset z)).map (fun d => e.coordinate (d / z))

theorem frequencyMeasure_apply (μ : Measure G) (z : G) {s : Set ℂ}
    (hs : MeasurableSet s) :
    e.frequencyMeasure μ z s = μ {d | d / z ∈ e.ordinary ∧ e.coordinate (d / z) ∈ s} := by
  rw [frequencyMeasure, Measure.map_apply
    (show Measurable (fun d : G => e.coordinate (d / z)) from
      e.measurable_coordinate.comp (measurable_id.div_const z)) hs,
    Measure.restrict_apply (show MeasurableSet ((fun d : G => e.coordinate (d / z)) ⁻¹' s) from
      (e.measurable_coordinate.comp (measurable_id.div_const z)) hs)]
  congr 1
  ext d
  simp only [Set.mem_inter_iff, Set.mem_preimage, Set.mem_ofPred_eq, coset]
  exact and_comm

@[simp] theorem frequencyMeasure_univ (μ : Measure G) (z : G) :
    e.frequencyMeasure μ z Set.univ = μ (e.coset z) := by
  rw [e.frequencyMeasure_apply μ z MeasurableSet.univ]
  congr 1
  ext d
  simp [coset]

noncomputable def parameterKernel : Kernel (ProbabilityMeasure G × G) G :=
  ⟨fun p => (p.1 : Measure G), measurable_subtype_coe.comp measurable_fst⟩

instance parameterKernel_markov : IsMarkovKernel (parameterKernel (G := G)) :=
  ⟨fun p => by change IsProbabilityMeasure (p.1 : Measure G); infer_instance⟩

theorem measurable_frequencyMeasure :
    Measurable (fun p : ProbabilityMeasure G × G => e.frequencyMeasure (p.1 : Measure G) p.2) := by
  classical
  apply Measure.measurable_of_measurable_coe
  intro s hs
  have hm : Measurable (fun p : (ProbabilityMeasure G × G) × G =>
      if p.2 / p.1.2 ∈ e.ordinary ∧ e.coordinate (p.2 / p.1.2) ∈ s
      then (1 : ℝ≥0∞) else 0) := by
    apply Measurable.ite _ measurable_const measurable_const
    exact (e.measurableSet_ordinary.preimage
      (measurable_snd.div (measurable_snd.comp measurable_fst))).inter
      (hs.preimage (e.measurable_coordinate.comp
        (measurable_snd.div (measurable_snd.comp measurable_fst))))
  have h := hm.lintegral_kernel_prod_right' (κ := parameterKernel (G := G))
  convert h using 1
  ext p
  rw [e.frequencyMeasure_apply _ _ hs]
  have hset : MeasurableSet {d : G | d / p.2 ∈ e.ordinary ∧
      e.coordinate (d / p.2) ∈ s} :=
    (e.measurableSet_ordinary.preimage (measurable_id.div_const p.2)).inter
      (hs.preimage (e.measurable_coordinate.comp (measurable_id.div_const p.2)))
  rw [show parameterKernel p = (p.1 : Measure G) from rfl]
  simpa only [Set.indicator_apply, Pi.one_apply, Set.mem_ofPred_eq] using
    (lintegral_indicator_one (μ := (p.1 : Measure G)) hset).symm

theorem measurable_mass : Measurable (fun p : ProbabilityMeasure G × G =>
    (p.1 : Measure G) (e.coset p.2)) := by
  have h : Measurable (fun p : ProbabilityMeasure G × G =>
      e.frequencyMeasure (p.1 : Measure G) p.2 Set.univ) :=
    (Measure.measurable_coe MeasurableSet.univ).comp e.measurable_frequencyMeasure
  simp only [frequencyMeasure_univ] at h
  exact h

noncomputable def frequencyLaw (μ : ProbabilityMeasure G) (z : G) : ProbabilityMeasure ℂ :=
  if h : (μ : Measure G) (e.coset z) = 0 then ⟨Measure.dirac 0, inferInstance⟩
  else
    letI : IsProbabilityMeasure ((μ : Measure G)[|e.coset z]) :=
      cond_isProbabilityMeasure h
    ⟨((μ : Measure G)[|e.coset z]).map (fun d => e.coordinate (d / z)),
      inferInstance⟩

theorem frequencyLaw_measure (μ : ProbabilityMeasure G) (z : G) :
    (e.frequencyLaw μ z : Measure ℂ) =
      if (μ : Measure G) (e.coset z) = 0 then Measure.dirac 0 else
      ((μ : Measure G) (e.coset z))⁻¹ • e.frequencyMeasure μ z := by
  split_ifs with h
  · simp [frequencyLaw, h]
  · simp [frequencyLaw, h, ProbabilityTheory.cond, frequencyMeasure]
    exact Measure.map_smul ((μ : Measure G) (e.coset z))⁻¹
      (e.measurable_coordinate.comp (measurable_id.div_const z)).aemeasurable

theorem measurable_frequencyLaw :
    Measurable (fun p : ProbabilityMeasure G × G => e.frequencyLaw p.1 p.2) := by
  have hm : Measurable (fun p : ProbabilityMeasure G × G =>
      (e.frequencyLaw p.1 p.2 : Measure ℂ)) := by
    simp_rw [frequencyLaw_measure]
    apply Measurable.ite (e.measurable_mass (measurableSet_singleton 0)) measurable_const
    apply Measure.measurable_of_measurable_coe
    intro s hs
    simp only [Measure.smul_apply, smul_eq_mul]
    exact e.measurable_mass.inv.mul ((Measure.measurable_coe hs).comp e.measurable_frequencyMeasure)
  exact hm.subtype_mk

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem coset_mul_j (z : G) (v : ℂ) : e.coset (z * e.j v) = e.coset z := by
  ext d
  have hj : e.j v ∈ e.ordinary := ⟨_, rfl⟩
  constructor
  · intro h
    change d / z ∈ e.ordinary
    convert e.ordinary.mul_mem h hj using 1
    simp [div_eq_mul_inv, mul_comm, mul_left_comm]
  · intro h
    change d / (z * e.j v) ∈ e.ordinary
    convert e.ordinary.div_mem h hj using 1
    simp [div_eq_mul_inv, mul_assoc, mul_comm]

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem coordinate_div_j {d : G} (hd : d ∈ e.ordinary) (v : ℂ) :
    e.coordinate (d / e.j v) = e.coordinate d - v := by
  rw [← e.j_coordinate hd, ← e.j_sub, e.coordinate_j, e.coordinate_j]

theorem frequencyMeasure_shift (μ : Measure G) (z : G) (v : ℂ) :
    e.frequencyMeasure μ (z * e.j v) =
      (e.frequencyMeasure μ z).map (fun t => t + -v) := by
  rw [frequencyMeasure, frequencyMeasure, e.coset_mul_j,
    Measure.map_map (show Measurable (fun t : ℂ => t + -v) from
      measurable_id.add_const (-v))
      (show Measurable (fun d : G => e.coordinate (d / z)) from
        e.measurable_coordinate.comp (measurable_id.div_const z))]
  apply Measure.map_congr
  filter_upwards [ae_restrict_mem (e.measurableSet_coset z)] with d hd
  change e.coordinate (d / (z * e.j v)) = e.coordinate (d / z) + -v
  rw [div_mul_eq_div_div, e.coordinate_div_j hd, sub_eq_add_neg]

theorem frequencyLaw_shift (μ : ProbabilityMeasure G) (z : G) (v : ℂ)
    (h : (μ : Measure G) (e.coset z) ≠ 0) :
    e.frequencyLaw μ (z * e.j v) =
      (e.frequencyLaw μ z).map (fun point => point + -v) := by
  apply Subtype.ext
  change (e.frequencyLaw μ (z * e.j v) : Measure ℂ) =
    Measure.map (fun t => t + -v) (e.frequencyLaw μ z : Measure ℂ)
  rw [e.frequencyLaw_measure, e.frequencyLaw_measure, e.coset_mul_j]
  simp only [ite_eq_right h]
  rw [Measure.map_smul ((μ : Measure G) (e.coset z))⁻¹
    (f := fun point : ℂ => point + -v) (continuous_id.add_const (-v)).aemeasurable,
    ← e.frequencyMeasure_shift]

noncomputable def center (μ : ProbabilityMeasure G) (z : G) : G :=
  z * e.j (Location.center (e.frequencyLaw μ z))

theorem measurable_center :
    Measurable (fun p : ProbabilityMeasure G × G => e.center p.1 p.2) :=
  measurable_snd.mul (e.measurable_j.comp
    (Location.measurable_center.comp e.measurable_frequencyLaw))

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem center_mem_coset (μ : ProbabilityMeasure G) (z : G) :
    e.center μ z ∈ e.coset z := by
  change z * e.j _ / z ∈ e.ordinary
  rw [mul_div_cancel_left]
  exact ⟨_, rfl⟩

theorem center_mul_j (μ : ProbabilityMeasure G) (z : G) (v : ℂ)
    (h : (μ : Measure G) (e.coset z) ≠ 0) :
    e.center μ (z * e.j v) = e.center μ z := by
  rw [center, e.frequencyLaw_shift μ z v h, Location.center_translate, e.j_add,
    e.j_neg, center]
  simp [mul_assoc, mul_comm]

theorem center_eq_of_mem_coset (μ : ProbabilityMeasure G) {z z' : G}
    (hz : (μ : Measure G) (e.coset z) ≠ 0) (hz' : z' ∈ e.coset z) :
    e.center μ z' = e.center μ z := by
  obtain ⟨v, hv⟩ := (e.mem_ordinary_iff (z' / z)).mp hz'
  have he : z' = z * e.j v := by rw [hv]; simp [div_eq_mul_inv]
  rw [he]
  exact e.center_mul_j μ z v hz

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem quotient_center (μ : ProbabilityMeasure G) (z : G) :
    (QuotientGroup.mk (e.center μ z) : G ⧸ e.ordinary) = QuotientGroup.mk z :=
  QuotientGroup.eq_iff_div_mem.mpr (e.center_mem_coset μ z)

theorem center_eq_iff (μ : ProbabilityMeasure G) {z z' : G}
    (hz : (μ : Measure G) (e.coset z) ≠ 0) :
    e.center μ z' = e.center μ z ↔ z' ∈ e.coset z := by
  constructor
  · intro h
    change z' / z ∈ e.ordinary
    apply QuotientGroup.eq_iff_div_mem.mp
    rw [← e.quotient_center μ z', ← e.quotient_center μ z, h]
  · exact e.center_eq_of_mem_coset μ hz

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem center_mem_ordinary_iff (μ : ProbabilityMeasure G) (z : G) :
    e.center μ z ∈ e.ordinary ↔ z ∈ e.ordinary := by
  rw [← QuotientGroup.eq_one_iff, e.quotient_center, QuotientGroup.eq_one_iff]

theorem preimage_center_singleton (μ : ProbabilityMeasure G) {z : G}
    (hz : (μ : Measure G) (e.coset z) ≠ 0) :
    (e.center μ) ⁻¹' {e.center μ z} = e.coset z := by
  ext z'
  exact e.center_eq_iff μ hz

theorem measurable_center_fixed (μ : ProbabilityMeasure G) : Measurable (e.center μ) :=
  e.measurable_center.comp (measurable_const.prodMk measurable_id)

variable (T : G ≃* G) (O : ℂ ≃ₗᵢ[ℝ] ℂ)
  (hT : Measurable T) (he : ∀ t : ℂ, T (e.j t) = e.j (O t))

include he

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem equiv_mem_ordinary_iff (d : G) : T d ∈ e.ordinary ↔ d ∈ e.ordinary := by
  constructor
  · rintro ⟨t, ht⟩
    refine ⟨Multiplicative.ofAdd (O.symm (Multiplicative.toAdd t)), ?_⟩
    change e.j (O.symm _) = d
    apply T.injective
    rw [he, O.apply_symm_apply]
    exact ht
  · rintro ⟨t, rfl⟩
    exact (e.mem_ordinary_iff _).mpr ⟨O (Multiplicative.toAdd t), (he _).symm⟩

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem preimage_coset_equiv (z : G) : T ⁻¹' e.coset (T z) = e.coset z := by
  ext d
  change T d / T z ∈ e.ordinary ↔ d / z ∈ e.ordinary
  rw [← T.map_div]
  exact e.equiv_mem_ordinary_iff T O he _

omit [MeasurableMul₂ G] [MeasurableInv G] in
theorem coordinate_equiv {d : G} (hd : d ∈ e.ordinary) :
    e.coordinate (T d) = O (e.coordinate d) := by
  obtain ⟨t, rfl⟩ := (e.mem_ordinary_iff d).mp hd
  rw [he, e.coordinate_j, e.coordinate_j]

include hT in
theorem frequencyMeasure_equiv (μ : Measure G) (z : G) :
    e.frequencyMeasure (μ.map T) (T z) = (e.frequencyMeasure μ z).map O := by
  rw [frequencyMeasure, Measure.restrict_map hT (e.measurableSet_coset _),
    e.preimage_coset_equiv T O he,
    Measure.map_map (show Measurable (fun d : G => e.coordinate (d / T z)) from
      e.measurable_coordinate.comp (measurable_id.div_const (T z))) hT,
    frequencyMeasure,
    Measure.map_map O.continuous.measurable
      (show Measurable (fun d : G => e.coordinate (d / z)) from
        e.measurable_coordinate.comp (measurable_id.div_const z))]
  apply Measure.map_congr
  filter_upwards [ae_restrict_mem (e.measurableSet_coset z)] with d hd
  change e.coordinate (T d / T z) = O (e.coordinate (d / z))
  rw [← T.map_div]
  exact e.coordinate_equiv T O he hd

include hT in
theorem frequencyLaw_equiv (μ : ProbabilityMeasure G) (z : G)
    (hz : (μ : Measure G) (e.coset z) ≠ 0) :
    e.frequencyLaw (μ.map T) (T z) =
      (e.frequencyLaw μ z).map O := by
  apply Subtype.ext
  change (e.frequencyLaw (μ.map T) (T z) : Measure ℂ) =
    Measure.map O (e.frequencyLaw μ z : Measure ℂ)
  rw [e.frequencyLaw_measure, e.frequencyLaw_measure, ProbabilityMeasure.toMeasure_map,
    Measure.map_apply hT (e.measurableSet_coset _), e.preimage_coset_equiv T O he,
    ]
  simp only [ite_eq_right hz]
  rw [Measure.map_smul _ O.continuous.aemeasurable,
    e.frequencyMeasure_equiv T O hT he]

include hT in
theorem center_equivariant (μ : ProbabilityMeasure G) (z : G)
    (hz : (μ : Measure G) (e.coset z) ≠ 0) :
    e.center (μ.map T) (T z) = T (e.center μ z) := by
  rw [center, e.frequencyLaw_equiv T O hT he μ z hz, Location.center_orthogonal,
    center, T.map_mul, he]

end Embedding
end EuclideanFiveColor.CosetCenter

end

end OAI