lean/OAI/Analysis/HardSphere/Allocation/PhysicalAssembly.lean

import Mathlib
import OAI.Analysis.HardSphere.Allocation.PhysicalReference
import OAI.Analysis.HardSphere.Geometry.SiteGroups

namespace OAI

section

noncomputable section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal BigOperators

namespace HardSphere.Comparison

lemma finite_allocation_joint {E A : Type*} [MeasurableSpace E]
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
    (μ : Measure E) [SFinite μ] (κ : Kernel E A) [IsSFiniteKernel κ] :
    (∑ a, (μ.withDensity (fun e ↦ κ e {a})).map (fun e ↦ (e,a))) = μ.compProd κ := by
  classical
  ext B hB
  rw [Measure.finsetSum_apply, Measure.compProd_apply hB]
  let F : A → E → ℝ≥0∞ := fun a ↦
    ((fun e ↦ (e,a)) ⁻¹' B).indicator (fun e ↦ κ e {a})
  have hF (a : A) : Measurable (F a) :=
    (κ.measurable_coe (measurableSet_singleton a)).indicator
      (hB.preimage measurable_prodMk_right)
  trans ∑ a, ∫⁻ e, F a e ∂μ
  · apply Finset.sum_congr rfl
    intro a _
    rw [Measure.map_apply measurable_prodMk_right hB,
      withDensity_apply _ (hB.preimage measurable_prodMk_right)]
    exact (lintegral_indicator (hB.preimage measurable_prodMk_right) _).symm
  rw [← lintegral_finsetSum _ (fun a _ ↦ hF a)]
  apply lintegral_congr
  intro e
  rw [← lintegral_indicator_one (hB.preimage measurable_prodMk_left), lintegral_fintype]
  apply Finset.sum_congr rfl
  intro a _
  by_cases h : (e,a) ∈ B <;> simp [F, h]

lemma recorded_density_sum {E J : Type*} [MeasurableSpace E]
    [Fintype J] [MeasurableSpace J] [MeasurableSingletonClass J]
    (μ : Measure E) (r : E → J) (hr : Measurable r)
    (f : J → E → ℝ≥0∞) (hf : ∀ j, Measurable (f j)) :
    (∑ j, (μ.withDensity (f j)).restrict {e | r e = j}) =
      μ.withDensity (fun e ↦ f (r e) e) := by
  classical
  have hset (j : J) : MeasurableSet {e | r e = j} :=
    measurableSet_eq_fun hr measurable_const
  have h := withDensity_tsum (μ := μ)
    (fun j ↦ (hf j).indicator (hset j))
  rw [Measure.sum_fintype] at h
  have heq : (∑' j, {e | r e = j}.indicator (f j)) = (fun e ↦ f (r e) e) := by
    funext e
    rw [tsum_fintype, Finset.sum_apply]
    simp [Set.indicator]
  rw [heq] at h
  rw [h]
  apply Finset.sum_congr rfl
  intro j _
  rw [restrict_withDensity (hset j), withDensity_indicator (hset j)]

lemma allocated_flag_joint {E Y J A : Type*}
    [MeasurableSpace E] [MeasurableSpace Y]
    [Fintype J] [MeasurableSpace J] [MeasurableSingletonClass J]
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
    (μ : Measure E) [SFinite μ] (ν : Measure Y) [SFinite ν]
    (κ : Kernel (E × J) A) [IsSFiniteKernel κ]
    (r : E × Y → J) (hr : Measurable r)
    {B : Set (E × Y)} (hB : MeasurableSet B) :
    (∑ b, ∑ a, (((μ.withDensity (fun e ↦ κ (e,b) {a})).prod ν).restrict
      (B ∩ {z | r z = b})).map (fun z ↦ (z,a))) =
      ((μ.prod ν).restrict B).compProd
        (κ.comap (fun z ↦ (z.1,r z)) (measurable_fst.prodMk hr)) := by
  classical
  let μB := (μ.prod ν).restrict B
  have hm (b : J) (a : A) : Measurable (fun e : E ↦ κ (e,b) {a}) :=
    (κ.measurable_coe (measurableSet_singleton a)).comp measurable_prodMk_right
  have hs (b : J) : MeasurableSet {z : E × Y | r z = b} :=
    measurableSet_eq_fun hr measurable_const
  have hd (a : A) :
      (∑ b, ((μ.withDensity fun e ↦ κ (e,b) {a}).prod ν).restrict
        (B ∩ {z | r z = b})) = μB.withDensity (fun z ↦ κ (z.1,r z) {a}) := by
    trans ∑ b, (μB.withDensity (fun z ↦ κ (z.1,b) {a})).restrict {z | r z = b}
    · apply Finset.sum_congr rfl
      intro b _
      rw [prod_withDensity_left (hm b a), restrict_withDensity (hB.inter (hs b)),
        restrict_withDensity (hs b)]
      congr 1
      simp only [μB, Measure.restrict_restrict (hs b), Set.inter_comm]
    · exact recorded_density_sum μB r hr _ (fun b ↦ (hm b a).comp measurable_fst)
  rw [Finset.sum_comm]
  trans ∑ a, (μB.withDensity (fun z ↦ κ (z.1,r z) {a})).map (fun z ↦ (z,a))
  · apply Finset.sum_congr rfl
    intro a _
    rw [← Measure.map_finset_sum' measurable_prodMk_right.aemeasurable, hd a]
  · exact finite_allocation_joint μB
      (κ.comap (fun z ↦ (z.1,r z)) (measurable_fst.prodMk hr))

lemma map_retained_compProd {E F A : Type*} [MeasurableSpace E]
    [MeasurableSpace F] [MeasurableSpace A]
    (μ : Measure E) [SFinite μ] (f : E → F) (hf : Measurable f)
    (κ : Kernel F A) [IsSFiniteKernel κ] :
    (μ.compProd (κ.comap f hf)).map (fun z ↦ (f z.1,z.2)) =
      (μ.map f).compProd κ := by
  ext B hB
  have hmap : Measurable (fun z : E × A ↦ (f z.1,z.2)) :=
    (hf.comp measurable_fst).prodMk measurable_snd
  rw [Measure.map_apply hmap hB, Measure.compProd_apply (hB.preimage hmap),
    Measure.compProd_apply hB,
    lintegral_map (κ.measurable_kernel_prodMk_left hB) hf]
  rfl

end HardSphere.Comparison

namespace HardSphere.Comparison
variable {E I A : Type*} [MeasurableSpace E] [Fintype I]
variable {X : I → Type*} [∀ i, MeasurableSpace (X i)]
attribute [local instance] Classical.propDecidable

lemma allocated_exposure_joint [Fintype A] [MeasurableSpace A]
    [MeasurableSingletonClass A]
    (μ : Measure E) [SFinite μ] (ν : ∀ i, Measure (X i))
    [∀ i, IsProbabilityMeasure (ν i)]
    (flag : ∀ i, E × X i → Bool) (hflag : ∀ i, Measurable (flag i))
    (κ : Kernel (E × (I → Bool)) A) [IsMarkovKernel κ] (p : A → I → Prop)
    {B : Set (E × (∀ i, X i))} (hB : MeasurableSet B) :
    (∑ b, ∑ a, ((exposedLaw (allocationBase μ κ b a) ν (p a)
        (B ∩ flagEvent flag b)).compProd
      (fiberNormalize (Kernel.const _ (Measure.pi fun i : {i // p a i} ↦ ν i))
        (blockEvent (p a) (B ∩ flagEvent flag b)))).map
          (fun z ↦ (blockGlue (p a) z, a))) =
      ((μ.prod (Measure.pi ν)).restrict B).compProd
        (κ.comap (fun z ↦ (z.1, fun i ↦ flag i (z.1,z.2 i)))
          (measurable_fst.prodMk (Measurable.of_eval (fun i ↦
            (hflag i).comp (measurable_fst.prodMk
              ((measurable_pi_apply i).comp measurable_snd)))))) := by
  have (b : I → Bool) (a : A) :
      SFinite (exposedLaw (allocationBase μ κ b a) ν (p a) (B ∩ flagEvent flag b)) := by
    unfold exposedLaw
    infer_instance
  trans ∑ b, ∑ a, (((allocationBase μ κ b a).prod (Measure.pi ν)).restrict
    (B ∩ flagEvent flag b)).map (fun z ↦ (z,a))
  · apply Finset.sum_congr rfl
    intro b _
    apply Finset.sum_congr rfl
    intro a _
    have h := congrArg (fun m ↦ m.map (fun z : E × (∀ i, X i) ↦ (z,a)))
      (exposed_block_reconstruct (allocationBase μ κ b a) ν (p a)
        (hB.inter (flagEvent_measurable flag hflag b)))
    simpa only [Measure.map_map measurable_prodMk_right (blockGlue_measurable (p a)),
      Function.comp_def] using h
  · simpa only [allocationBase, flagEvent, funext_iff] using
      allocated_flag_joint μ (Measure.pi ν) κ
        (fun z i ↦ flag i (z.1,z.2 i))
        (Measurable.of_eval (fun i ↦ (hflag i).comp
          (measurable_fst.prodMk ((measurable_pi_apply i).comp measurable_snd)))) hB

lemma allocationBase_ae_support {E J A : Type*} [MeasurableSpace E]
    [MeasurableSpace J] [Fintype J] [MeasurableSpace A] [Fintype A]
    [MeasurableSingletonClass A] (μ : Measure E) (κ : Kernel (E × J) A)
    (b : J) (a : A) (P : E → A → Prop)
    (hP : ∀ e, ∀ᵐ a' ∂κ (e,b), P e a') :
    ∀ᵐ e ∂allocationBase μ κ b a, P e a := by
  apply (ae_withDensity_iff ((κ.measurable_coe (measurableSet_singleton a)).comp
    (measurable_id.prodMk measurable_const))).mpr
  apply ae_of_all
  intro e hn
  by_contra h
  apply hn
  exact measure_mono_null (by simpa only [singleton_subset_iff, mem_ofPred_eq] using h)
    (ae_iff.mp (hP e))

lemma exposed_endpoint_ae {E I : Type*} [MeasurableSpace E] [Fintype I]
    {X : I → Type*} [∀ i, MeasurableSpace (X i)]
    (μ : Measure E) [SFinite μ] (ν : ∀ i, Measure (X i))
    [∀ i, IsProbabilityMeasure (ν i)] (p : I → Prop) [DecidablePred p]
    (B : Set (E × (∀ i, X i))) {P : E → Prop} (hP : ∀ᵐ e ∂μ, P e) :
    ∀ᵐ w ∂exposedLaw μ ν p B, P w.1 := by
  apply (withDensity_absolutelyContinuous _ _).ae_le
  exact Measure.quasiMeasurePreserving_fst.ae hP

end HardSphere.Comparison

namespace HardSphere.Groups
open Wiener Bridge Sampling Comparison CellOrbital GaussianPacking
attribute [local instance] Classical.propDecidable

lemma recorded_allocation_is_physical {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K)
    (μ : Measure (BridgeEndpoints N L))
    (m q : ℕ) (r R C S s₀ t : ℝ) (u : Time) :
    ∀ᵐ z ∂μ.prod (Measure.pi fun _ : Fin N ↦ Bridge.law),
      gridAllocationKernel hL q
        (z.1, fun i ↦ eligibilityFlag (K:=K) m r R C S s₀ t u i (z.1,z.2 i)) =
      physicalAllocationKernel (K:=K) m q r R C S s₀ u (labelBridgePath N L t z) := by
  have he : ∀ᵐ z ∂μ.prod (Measure.pi fun _ : Fin N ↦ Bridge.law),
      labelBridgePath N L t z 0 = z.1.2 ∧
      labelBridgePath N L t z 1 = bridgeEnd N L t z.1 := by
    apply (Measure.ae_prod_iff_ae_ae
      ((measurableSet_eq_fun ((continuous_eval_const (0:Time)).measurable.comp
          (labelBridgePath_measurable N L t)) measurable_fst.snd).inter
        (measurableSet_eq_fun ((continuous_eval_const (1:Time)).measurable.comp
          (labelBridgePath_measurable N L t))
          ((bridgeEnd_continuous N L t).measurable.comp measurable_fst)))).mpr
    exact ae_of_all _ (exposed_endpoints t)
  filter_upwards [he] with z hz
  rw [gridAllocationKernel_apply, physicalAllocationKernel, Kernel.comap_apply]
  change Measure.pi _ = Measure.pi _
  congr 1
  funext v
  rw [recordedList_eq hL hK m r R C S s₀ t u v z.1 z.2 hz.1 hz.2]

lemma genuine_ground_allocated_joint {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K)
    (ψ : Jet N L) (m q : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (p : GridAllocation N K q → Fin N → Prop) :
    (∑ b, ∑ a, ((exposedLaw
        (allocationBase (endpointWeightedBase ψ t) (gridAllocationKernel hL q) b a)
        (fun _ : Fin N ↦ Bridge.law) (p a)
        (labelInteraction N L r t ∩
          flagEvent (eligibilityFlag (K:=K) m r R C S s₀ t u) b)).compProd
      (fiberNormalize (Kernel.const _ (Measure.pi fun _ : {i // p a i} ↦ Bridge.law))
        (blockEvent (p a) (labelInteraction N L r t ∩
          flagEvent (eligibilityFlag (K:=K) m r R C S s₀ t u) b)))).map
        (fun z ↦ (labelBridgePath N L t (blockGlue (p a) z),a))) =
      (groundPathLaw N L r t ψ).compProd
        (physicalAllocationKernel (K:=K) m q r R C S s₀ u) := by
  let flag := eligibilityFlag (N:=N) (K:=K) (L:=L) m r R C S s₀ t u
  have hflag : ∀ i, Measurable (flag i) :=
    fun i ↦ eligibilityFlag_measurable m r R C S s₀ t u i
  let base := ((endpointWeightedBase ψ t).prod
    (Measure.pi fun _ : Fin N ↦ Bridge.law)).restrict (labelInteraction N L r t)
  have hf : Measurable (fun z : (BridgeEndpoints N L × (Fin N → Bridge.Noise)) ×
      GridAllocation N K q ↦ (labelBridgePath N L t z.1,z.2)) :=
    ((labelBridgePath_measurable N L t).comp measurable_fst).prodMk measurable_snd
  have h := congrArg (fun μ ↦ μ.map
    (fun z : (BridgeEndpoints N L × (Fin N → Bridge.Noise)) × GridAllocation N K q ↦
      (labelBridgePath N L t z.1,z.2)))
    (allocated_exposure_joint (endpointWeightedBase ψ t)
      (fun _ : Fin N ↦ Bridge.law) flag hflag (gridAllocationKernel hL q) p
      (labelInteraction_measurable N L r t))
  simp only [Measure.map_finset_sum' hf.aemeasurable,
    Measure.map_map hf ((blockGlue_measurable _).prodMk measurable_const),
    Function.comp_def] at h
  have hκ : ∀ᵐ z ∂base,
      ((gridAllocationKernel hL q).comap
        (fun z ↦ (z.1, fun i ↦ flag i (z.1,z.2 i)))
        (measurable_fst.prodMk (Measurable.of_eval (fun i ↦
          (hflag i).comp (measurable_fst.prodMk
            ((measurable_pi_apply i).comp measurable_snd)))))) z =
      ((physicalAllocationKernel (K:=K) m q r R C S s₀ u).comap
        (labelBridgePath N L t) (labelBridgePath_measurable N L t)) z := by
    simpa only [Kernel.comap_apply] using
      (ae_restrict_of_ae (s:=labelInteraction N L r t)
        (recorded_allocation_is_physical hL hK
          (endpointWeightedBase ψ t) m q r R C S s₀ t u))
  rw [Measure.compProd_congr hκ] at h
  rw [map_retained_compProd base (labelBridgePath N L t)
    (labelBridgePath_measurable N L t)
    (physicalAllocationKernel (K:=K) m q r R C S s₀ u)] at h
  rw [show base.map (labelBridgePath N L t) = groundPathLaw N L r t ψ from
    genuine_ground_label_bridge ψ r t] at h
  convert h using 1
  congr 2
  exact Subsingleton.elim _ _

lemma allocated_selected_flags {N K M G : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (μ : Measure (BridgeEndpoints N L)) [SFinite μ]
    (g : Fin G) (b : Fin N → Bool) (a : GridAllocation N K (G*M))
    (B : Set (BridgeEndpoints N L × (Fin N → Bridge.Noise))) :
    ∀ᵐ _ ∂exposedLaw (allocationBase μ (gridAllocationKernel hL (G*M)) b a)
      (fun _ : Fin N ↦ Bridge.law) (fun i ↦ i ∈ groupUnion g a) B,
        ∀ i ∈ groupUnion g a, b i = true := by
  apply exposed_endpoint_ae
    (allocationBase μ (gridAllocationKernel hL (G*M)) b a)
    (fun _ : Fin N ↦ Bridge.law) (fun i ↦ i ∈ groupUnion g a) B
    (P:=fun _ ↦ ∀ i ∈ groupUnion g a, b i = true)
  filter_upwards [allocationBase_ae_support μ (gridAllocationKernel hL (G*M)) b a
    (fun e a' ↦ ∀ v, a' v ∈ (allocationPMF (recordedList hL v (e,b)) (G*M)).support)
    (fun e ↦ gridAllocation_support_ae hL (G*M) (e,b))] with e he
  intro i hi
  obtain ⟨v, _, hiv⟩ := Finset.mem_biUnion.mp hi
  exact (Finset.mem_filter.mp (groupAt_mem_list hL (e,b) a he g v hiv)).2.2

lemma true_flag_endpoint {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K)
    (m : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (i : Fin N) (e : BridgeEndpoints N L) (β : Bridge.Noise)
    (hb : eligibilityFlag (K:=K) m r R C S s₀ t u i (e,β) = true) :
    EndpointEligible (gridHome hL (e.2 i)) s₀ e.2 (bridgeEnd N L t e) i := by
  have ho : ownEligible (K:=K) m r R C S s₀ t u i (e,β) :=
    of_decide_eq_true hb
  obtain ⟨v, hv, _⟩ := ho
  rwa [(gridHome_eq_iff hL hK _ _).mpr hv.1]

lemma exposed_selected_endpoints {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K)
    (μ : Measure (BridgeEndpoints N L)) [SFinite μ]
    (m : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (p : Fin N → Prop) (b : Fin N → Bool)
    (hb : ∀ i : {i // p i}, b i = true) :
    ∀ᵐ w ∂exposedLaw μ (fun _ : Fin N ↦ Bridge.law) p
      (labelInteraction N L r t ∩
        flagEvent (eligibilityFlag (K:=K) m r R C S s₀ t u) b),
      ∀ i : {i // p i}, EndpointEligible (gridHome hL (w.1.2 i))
        s₀ w.1.2 (bridgeEnd N L t w.1) i := by
  filter_upwards [exposed_block_positive μ (fun _ : Fin N ↦ Bridge.law) p
    ((labelInteraction_measurable N L r t).inter
      (flagEvent_measurable _ (fun i ↦ eligibilityFlag_measurable m r R C S s₀ t u i) b))]
    with w hw
  obtain ⟨β,hβ⟩ := nonempty_of_measure_ne_zero hw.ne'
  intro i
  apply true_flag_endpoint hL hK m r R C S s₀ t u i w.1 (β i)
  have hflag := hβ.2 i
  simpa only [blockGlue_fst, blockGlue_inside, hb i] using hflag

def exposedAnchorLift {N K : ℕ} {L : Length} (hL : L.val = (K : ℝ))
    (e : BridgeEndpoints N L) (i : Fin N) : Point :=
  nearestLift L (labelStartLift e i) (gridCenter L (gridHome hL (e.2 i)))

lemma exposedAnchorLift_project {N K : ℕ} {L : Length} (hL : L.val = (K : ℝ))
    (e : BridgeEndpoints N L) (i : Fin N) :
    projectPoint L (exposedAnchorLift hL e i) = gridCenter L (gridHome hL (e.2 i)) :=
  nearestLift_project ..

lemma exposedAnchorLift_near {N K : ℕ} {L : Length} (hL : L.val = (K : ℝ))
    (hK : 1 ≤ K) (e : BridgeEndpoints N L) (i : Fin N) :
    ‖labelStartLift e i - exposedAnchorLift hL e i‖ ≤ 3 := by
  rw [norm_sub_rev]
  change ‖nearestLift L (labelStartLift e i) _ - labelStartLift e i‖ ≤ 3
  refine (nearestLift_bound L _ _ (R:=1) ?_).trans (by norm_num)
  have he : projectPoint L (labelStartLift e i) = e.2 i := by
    exact congrFun (project_representative N L e.2) i
  rw [he]
  simpa only [torusDistance, dist_comm] using centeredCell_distance (gridHome_mem hL hK (e.2 i))

def ExposedPhysicalIdentity {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (m : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (p : Fin N → Prop) (b : Fin N → Bool)
    (w : BridgeEndpoints N L × ({i // ¬p i} → Bridge.Noise)) : Prop :=
(conditionedMeasure (Measure.pi fun _ : {i // p i} ↦ Bridge.law)
  {β | blockGlue p (w,β) ∈ labelInteraction N L r (2*t) ∩
    flagEvent (eligibilityFlag (K:=K) m r R C S s₀ (2*t) u) b}).map
  (fun β (i : {i // p i}) ↦
    leg (2*t) (labelStartLift w.1 i) (labelEndLift (2*t) w.1 i) (β i)) =
conditionedMeasure (Measure.pi fun i : {i // p i} ↦
  individualReference t (labelStartLift w.1 i) (labelEndLift (2*t) w.1 i)
    (permittedPath m r R C S u (labelStartLift w.1 i) (labelEndLift (2*t) w.1 i)
      (exposedAnchorLift hL w.1 i) (frozenPaths (2*t) w.1 p w.2)))
  (physicalMutual (L:=L) r)

lemma canonical_physical_reference {N K : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K) (h50 : 50 < L.val)
    (μ : Measure (BridgeEndpoints N L)) [SFinite μ]
    (m : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (p : Fin N → Prop) (b : Fin N → Bool) (hb : ∀i : {i // p i}, b i = true) :
    ∀ᵐ w ∂exposedLaw μ (fun _ : Fin N ↦ Bridge.law) p
      (labelInteraction N L r (2*t) ∩
        flagEvent (eligibilityFlag (K:=K) m r R C S s₀ (2*t) u) b),
      ExposedPhysicalIdentity hL m r R C S s₀ t u p b w := by
  unfold ExposedPhysicalIdentity
  filter_upwards [physical_recorded_reference hL hK h50 μ m r R C S s₀ t u p b hb,
    exposed_selected_endpoints hL hK μ m r R C S s₀ (2*t) u p b hb] with w hw he
  exact hw (fun i ↦ gridHome hL (w.1.2 i)) (fun i ↦ exposedAnchorLift hL w.1 i)
    (fun i ↦ exposedAnchorLift_project hL w.1 i)
    (fun i ↦ exposedAnchorLift_near hL hK w.1 i) he

theorem actual_allocated_physical_reference {N K M G : ℕ} {L : Length}
    (hL : L.val = (K : ℝ)) (hK : 1 ≤ K) (h50 : 50 < L.val)
    (μ : Measure (BridgeEndpoints N L)) [SFinite μ]
    (m : ℕ) (r R C S s₀ t : ℝ) (u : Time)
    (g : Fin G) (b : Fin N → Bool) (a : GridAllocation N K (G*M)) :
    let p := fun i ↦ i ∈ groupUnion g a
    ∀ᵐ w ∂exposedLaw (allocationBase μ (gridAllocationKernel hL (G*M)) b a)
      (fun _ : Fin N ↦ Bridge.law) p
      (labelInteraction N L r (2*t) ∩
        flagEvent (eligibilityFlag (K:=K) m r R C S s₀ (2*t) u) b),
      ExposedPhysicalIdentity hL m r R C S s₀ t u p b w := by
  dsimp only
  let p := fun i ↦ i ∈ groupUnion g a
  let base := allocationBase μ (gridAllocationKernel hL (G*M)) b a
  by_cases hb : ∀ i : {i // p i}, b i = true
  · have h := canonical_physical_reference hL hK h50 base m r R C S s₀ t u p b hb
    have hd : (fun i ↦ Classical.propDecidable (p i)) =
        (fun i ↦ Finset.decidableMem i (groupUnion g a)) := Subsingleton.elim _ _
    rw [hd] at h
    exact h
  · filter_upwards [allocated_selected_flags hL μ g b a
      (labelInteraction N L r (2*t) ∩
        flagEvent (eligibilityFlag (K:=K) m r R C S s₀ (2*t) u) b)] with w hw
    exact (hb (fun i ↦ hw i i.property)).elim

end HardSphere.Groups
end
end

end OAI