lean/OAI/Combinatorics/HalvingLines/Labels.lean

import OAI.Combinatorics.HalvingLines.Directions

namespace OAI

open Filter Topology

namespace PlanarHalving.RankCoordinates
open Set
open scoped unitInterval

structure Family (m : ℕ) where
  graph : Fin m → ℝ → ℝ
  continuous : ∀ j, Continuous (graph j)
  convex : ∀ j, ConvexOn ℝ univ (graph j)
  scale : ℝ
  scale_pos : 0 < scale

noncomputable def Family.value {m : ℕ} [NeZero m] (F : Family m) (p : Point) : I :=
  ⟨smoothed F.graph F.scale p, (smoothed_mem (NeZero.pos m) F.graph F.scale p).1.le,
    (smoothed_mem (NeZero.pos m) F.graph F.scale p).2.le⟩

lemma Family.continuous_value {m : ℕ} [NeZero m] (F : Family m) : Continuous F.value :=
  (continuous_smoothed F.graph F.scale F.continuous).subtype_mk _

noncomputable def Family.flat (m : ℕ) : Family m where
  graph := fun _ _ => 0
  continuous := fun _ => continuous_const
  convex := fun _ => convexOn_const _ (convex_univ)
  scale := 1
  scale_pos := zero_lt_one

end PlanarHalving.RankCoordinates
namespace PlanarHalving.Batches
open Set PlaneGraph RankCoordinates TimeWindows
open scoped unitInterval
variable {n R k a : ℕ} {P : Fin n → Point}

noncomputable def System.rankFamily (S : @System n R k a P) [NeZero n] [NeZero a] [NeZero R]
    (hP : Generic P) (J : Window) : Family (a*n) := by
  classical
  by_cases hJ : 0 < length R J
  · let h := S.window_coordinate hP (start R J) (length R J)
      (by rw [start_add_length]; exact stop_le R J) hJ
    let G := h.choose
    exact ⟨G.graph,G.continuous,G.convex,h.choose_spec.choose,h.choose_spec.choose_spec.1⟩
  · exact Family.flat _

lemma System.rankFamily_spec (S : @System n R k a P) [NeZero n] [NeZero a] [NeZero R]
    (hP : Generic P) (J : Window) (hJ : 0 < length R J) :
    ∃ G : (S.timeWindow J).FullGraphs (S.drawing.exteriorCrossings (S.timeWindow J).edges),
      (S.rankFamily hP J).graph=G.graph ∧
      ∀ z ∈ S.drawing.exteriorCrossings (S.timeWindow J).edges,
        |(S.rankFamily hP J).value z-(slot G.graph z : ℝ)/(a*n)| ≤ 2/(a*n) := by
  classical
  unfold System.rankFamily
  rw [dite_eq_left hJ]
  exact ⟨_,rfl,(S.window_coordinate hP _ _ _ hJ).choose_spec.choose_spec.2⟩

abbrev Labels := Window → I

noncomputable instance labelsMetric : MetricSpace Labels := PiCountable.metricSpace

noncomputable def System.labels (S : @System n R k a P) [NeZero n] [NeZero a] [NeZero R]
    (hP : Generic P) (p : Point) : Labels := fun J => (S.rankFamily hP J).value p

lemma System.continuous_labels (S : @System n R k a P) [NeZero n] [NeZero a] [NeZero R]
    (hP : Generic P) : Continuous (S.labels hP) :=
  continuous_pi (fun J => (S.rankFamily hP J).continuous_value)

lemma System.coordinate_oscillation (S : @System n R k a P) [NeZero n] [NeZero a] [NeZero R]
    (hP : Generic P) (J : Window) :
    ∑ e : ↥S.edges, Metric.ediam ((fun p => S.labels hP p J) '' segment ℝ (P e.val.1) (P e.val.2))
      ≤ 2*a*n := by
  have hh := S.rank_oscillation (Nat.mul_pos (NeZero.pos a) (NeZero.pos n))
    (S.rankFamily hP J).graph (S.rankFamily hP J).convex (S.rankFamily hP J).scale_pos
  convert hh using 1
  apply Finset.sum_congr rfl
  intro e _
  exact (Isometry.ediam_image (isometry_subtype_coe : Isometry (Subtype.val : I → ℝ)) _).symm.trans
    (by rw [Set.image_image]; rfl)

end PlanarHalving.Batches
namespace PlanarHalving.CompactLabels
open Set Filter MeasureTheory
open scoped Topology ENNReal NNReal PiCountable unitInterval
variable {ι : Type*} [Encodable ι]

lemma ediam_le_finite {X : Type*} (z : X → (ι → I)) (A : Set X) (K : Finset ι) :
    Metric.ediam (z '' A) ≤ (∑ i ∈ K, Metric.ediam ((fun x => z x i) '' A))+
      ∑' i : {j // j ∉ K}, (2 : ℝ≥0∞)⁻¹ ^ Encodable.encode (i : ι) := by
  apply Metric.ediam_le
  rintro _ ⟨x,hx,rfl⟩ _ ⟨y,hy,rfl⟩
  calc
    edist (z x) (z y) = ∑' i : ι, min ((2 : ℝ≥0∞)⁻¹ ^ Encodable.encode i) (edist (z x i) (z y i)) := rfl
    _ = (∑ i ∈ K, min ((2 : ℝ≥0∞)⁻¹ ^ Encodable.encode i) (edist (z x i) (z y i)))+
        ∑' i : {j // j ∉ K}, min ((2 : ℝ≥0∞)⁻¹ ^ Encodable.encode (i : ι)) (edist (z x i) (z y i)) :=
      (ENNReal.sum_add_tsum_compl ..).symm
    _ ≤ _ := by
      gcongr
      · exact (min_le_right ..).trans (Metric.edist_le_ediam_of_mem ⟨x,hx,rfl⟩ ⟨y,hy,rfl⟩)
      · exact min_le_left ..

lemma finite_tail {ρ : ℝ≥0∞} (hρ : 0 < ρ) :
    ∃ K : Finset ι, ∑' i : {j // j ∉ K}, (2 : ℝ≥0∞)⁻¹ ^ Encodable.encode (i : ι) < ρ/2 := by
  exact ((tendsto_order.1 <| ENNReal.tendsto_tsum_compl_atTop_zero
    (tsum_geometric_encode_lt_top ENNReal.one_half_lt_one).ne).2 _
      <| by simpa using hρ.ne').exists

lemma long_count_bound {X α : Type*} [Fintype α] (z : X → (ι → I)) (A : α → Set X)
    {ρ : ℝ≥0∞} (_hρ : 0 < ρ) (K : Finset ι)
    (hK : ∑' i : {j // j ∉ K}, (2 : ℝ≥0∞)⁻¹ ^ Encodable.encode (i : ι) < ρ/2)
    {B : ℝ≥0∞} (hB : ∀ i, ∑ e : α, Metric.ediam ((fun x => z x i) '' A e) ≤ B) :
    (ρ/2) * ((Finset.univ.filter (fun e : α => ρ ≤ Metric.ediam (z '' A e))).card : ℝ≥0∞)
      ≤ K.card*B := by
  classical
  let E := Finset.univ.filter (fun e : α => ρ ≤ Metric.ediam (z '' A e))
  have he (e : α) (he : e ∈ E) : ρ/2 ≤ ∑ i ∈ K, Metric.ediam ((fun x => z x i) '' A e) := by
    by_contra hh
    have hh' := lt_of_not_ge hh
    have hlt := ENNReal.add_lt_add hh' hK
    rw [ENNReal.add_halves] at hlt
    exact not_lt_of_ge (Finset.mem_filter.mp he).2
      ((ediam_le_finite z (A e) K).trans_lt hlt)
  calc
    _ = ∑ _e ∈ E, ρ/2 := by simp only [Finset.sum_const,nsmul_eq_mul]; rw [mul_comm]
    _ ≤ ∑ e ∈ E, ∑ i ∈ K, Metric.ediam ((fun x => z x i) '' A e) := Finset.sum_le_sum he
    _ ≤ ∑ e : α, ∑ i ∈ K, Metric.ediam ((fun x => z x i) '' A e) :=
      Finset.sum_le_sum_of_subset (Finset.filter_subset ..)
    _ = ∑ i ∈ K, ∑ e : α, Metric.ediam ((fun x => z x i) '' A e) := Finset.sum_comm
    _ ≤ ∑ _i ∈ K, B := Finset.sum_le_sum (fun i _ => hB i)
    _ = K.card*B := by simp

end PlanarHalving.CompactLabels
namespace PlanarHalving.Limits
open MeasureTheory Set Filter
open scoped Topology NNReal

theorem finiteMeasure_subsequence_dependent
    {ι : Type*} [Countable ι] {X : ι → Type*}
    [∀ i, MetricSpace (X i)] [∀ i, CompactSpace (X i)] [∀ i, Nonempty (X i)]
    [∀ i, MeasurableSpace (X i)] [∀ i, BorelSpace (X i)]
    (μ : ℕ → ∀ i, FiniteMeasure (X i)) (C : ι → ℝ≥0)
    (hbound : ∀ n i, (μ n i).mass ≤ C i) :
    ∃ (φ : ℕ → ℕ) (ν : ∀ i, FiniteMeasure (X i)), StrictMono φ ∧
      ∀ i, Tendsto (fun n => μ (φ n) i) atTop (𝓝 (ν i)) := by
  let F : ℕ → ∀ i : ι, (Icc (0 : ℝ≥0) (C i)) × ProbabilityMeasure (X i) :=
    fun n i => (⟨(μ n i).mass,zero_le,hbound n i⟩,(μ n i).normalize)
  obtain ⟨g,φ,hφ,hg⟩ := CompactSpace.tendsto_subseq F
  refine ⟨φ,fun i => (g i).1.val • (g i).2.toFiniteMeasure,hφ,?_⟩
  intro i
  have hi := (tendsto_pi_nhds.mp hg) i
  have hm := continuous_subtype_val.tendsto _ |>.comp ((continuous_fst.tendsto (g i)).comp hi)
  have hn := (ProbabilityMeasure.toFiniteMeasure_isEmbedding (X i)).continuous.tendsto _ |>.comp
    ((continuous_snd.tendsto (g i)).comp hi)
  have ht := hm.smul hn
  convert ht using 1
  funext n
  exact (μ (φ n) i).self_eq_mass_smul_normalize

end PlanarHalving.Limits
namespace PlanarHalving.TimeWindows
open Set
open scoped unitInterval

def Before (A B : Window) : Prop :=
  UniformPartition.boundary (2^A.1) A.2.succ ≤ UniformPartition.boundary (2^B.1) B.2.castSucc

lemma stop_le_start (R : ℕ) [NeZero R] {A B : Window} (hAB : Before A B) :
    stop R A ≤ start R B := cut_mono _ hAB

end PlanarHalving.TimeWindows
namespace PlanarHalving.Batches
open Set PlaneGraph RankCoordinates TimeWindows MeasureTheory Limits
open scoped unitInterval NNReal ENNReal
variable {n R k a : ℕ} {P : Fin n → Point}

lemma System.timeWindow_disjoint (S : @System n R k a P) [NeZero R] [NeZero a]
    {A B : Window} (hAB : Before A B) :
    Disjoint (S.timeWindow A).edges (S.timeWindow B).edges := by
  classical
  apply Finset.disjoint_left.mpr
  intro e heA heB
  let v : ↥S.edges := ⟨e,S.timeWindow_edges A heA⟩
  have hA := (mem_carrier_iff R A (S.trace v.property).batch).mp ((S.timeWindow_mem A v).mp heA)
  have hB := (mem_carrier_iff R B (S.trace v.property).batch).mp ((S.timeWindow_mem B v).mp heB)
  have hh := stop_le_start R hAB
  omega

lemma System.timeWindow_graph_gap (S : @System n R k a P) [NeZero R] [NeZero n] [NeZero a]
    {A B : Window} (hAB : Before A B) {F H : Finset Point}
    (G : (S.timeWindow A).FullGraphs F) (G' : (S.timeWindow B).FullGraphs H) :
    G.upper < G'.lower := by
  apply G.upper_lt.trans_le
  apply le_trans _ G'.lower_lt.le
  change S.slope ⟨start R A+length R A, _⟩ ≤ S.slope ⟨start R B+0,_⟩
  apply S.increasing.monotone
  change start R A+length R A ≤ start R B+0
  rw [start_add_length,Nat.add_zero]
  exact stop_le_start R hAB

noncomputable def System.windowCrossings (S : @System n R k a P) [NeZero R] (A B : Window) :
    Finset ((Fin n × Fin n) × (Fin n × Fin n)) := by
  classical
  exact S.drawing.crossings.filter (fun w =>
    (w.1 ∈ (S.timeWindow A).edges ∧ w.2 ∈ (S.timeWindow B).edges) ∨
    (w.2 ∈ (S.timeWindow A).edges ∧ w.1 ∈ (S.timeWindow B).edges))

lemma System.windowCrossings_sub (S : @System n R k a P) [NeZero R] (A B : Window) :
    S.windowCrossings A B ⊆ S.drawing.crossings := Finset.filter_subset ..

noncomputable def System.windowCrossPoint (S : @System n R k a P) [NeZero R] (A B : Window)
    (w : ↥(S.windowCrossings A B)) : Point :=
  S.drawing.crossingPoint ⟨w.val,S.windowCrossings_sub A B w.property⟩

lemma System.windowCrossPoint_injective (S : @System n R k a P) [NeZero R]
    (hP : Generic P) (A B : Window) : Function.Injective (S.windowCrossPoint A B) := by
  intro w v h
  apply Subtype.ext
  exact congrArg (fun v : ↥S.drawing.crossings => v.val)
    (S.drawing.crossingPoint_injective (S.drawing.noMultiple_of_generic hP) h)

lemma System.windowCrossPoint_exterior (S : @System n R k a P) [NeZero R] [NeZero a]
    {A B : Window} (hAB : Before A B) (w : ↥(S.windowCrossings A B)) :
    S.windowCrossPoint A B w ∈ S.drawing.exteriorCrossings (S.timeWindow A).edges ∧
    S.windowCrossPoint A B w ∈ S.drawing.exteriorCrossings (S.timeWindow B).edges := by
  classical
  let v : ↥S.drawing.crossings := ⟨w.val,S.windowCrossings_sub A B w.property⟩
  have hw := (Finset.mem_filter.mp w.property).2
  have hd := Finset.disjoint_left.mp (S.timeWindow_disjoint hAB)
  have hA : (v.val.1 ∈ (S.timeWindow A).edges ∧ v.val.2 ∉ (S.timeWindow A).edges) ∨
      (v.val.2 ∈ (S.timeWindow A).edges ∧ v.val.1 ∉ (S.timeWindow A).edges) := by
    rcases hw with hw | hw
    · exact Or.inl ⟨hw.1,fun hh => hd hh hw.2⟩
    · exact Or.inr ⟨hw.1,fun hh => hd hh hw.2⟩
  have hB : (v.val.1 ∈ (S.timeWindow B).edges ∧ v.val.2 ∉ (S.timeWindow B).edges) ∨
      (v.val.2 ∈ (S.timeWindow B).edges ∧ v.val.1 ∉ (S.timeWindow B).edges) := by
    rcases hw with hw | hw
    · exact Or.inr ⟨hw.2,hd hw.1⟩
    · exact Or.inl ⟨hw.2,hd hw.1⟩
  exact ⟨Finset.mem_image.mpr ⟨v,by simp only [Finset.mem_filter,Finset.mem_univ,true_and]; exact hA,rfl⟩,
    Finset.mem_image.mpr ⟨v,by simp only [Finset.mem_filter,Finset.mem_univ,true_and]; exact hB,rfl⟩⟩

lemma System.windowCrossPoint_graph (S : @System n R k a P) [NeZero R] [NeZero n] [NeZero a]
    {A B : Window} (w : ↥(S.windowCrossings A B))
    {F H : Finset Point} (G : (S.timeWindow A).FullGraphs F) (G' : (S.timeWindow B).FullGraphs H) :
    (∃ i, G.graph i (S.windowCrossPoint A B w).1 = (S.windowCrossPoint A B w).2) ∧
    ∃ j, G'.graph j (S.windowCrossPoint A B w).1 = (S.windowCrossPoint A B w).2 := by
  classical
  let v : ↥S.drawing.crossings := ⟨w.val,S.windowCrossings_sub A B w.property⟩
  have hm := S.drawing.crossingPoint_mem v
  have hw := (Finset.mem_filter.mp w.property).2
  rcases hw with hw | hw
  · exact ⟨⟨_,G.edge _ hw.1 _ (openSegment_subset_segment ℝ _ _ hm.1)⟩,
      ⟨_,G'.edge _ hw.2 _ (openSegment_subset_segment ℝ _ _ hm.2)⟩⟩
  · exact ⟨⟨_,G.edge _ hw.1 _ (openSegment_subset_segment ℝ _ _ hm.2)⟩,
      ⟨_,G'.edge _ hw.2 _ (openSegment_subset_segment ℝ _ _ hm.1)⟩⟩

theorem System.window_crossing_slots (S : @System n R k a P) [NeZero R] [NeZero n] [NeZero a]
    (hP : Generic P) {A B : Window} (hAB : Before A B)
    (hA : 0 < length R A) (hB : 0 < length R B) :
    ∃ slots : ↥(S.windowCrossings A B) → Fin (a*n) × Fin (a*n),
      Function.Injective slots ∧ ∀ w,
        dist (S.labels hP (S.windowCrossPoint A B w) A,S.labels hP (S.windowCrossPoint A B w) B)
          (UniformPartition.gridPoint (a*n) (slots w)) ≤ 2/(a*n : ℕ) := by
  classical
  obtain ⟨G,hG,hGE⟩ := S.rankFamily_spec hP A hA
  obtain ⟨H,hH,hHE⟩ := S.rankFamily_spec hP B hB
  let pt := S.windowCrossPoint A B
  have hinc (w : ↥(S.windowCrossings A B)) := S.windowCrossPoint_graph w G H
  let slots : ↥(S.windowCrossings A B) → Fin (a*n) × Fin (a*n) := fun w =>
    (⟨slot G.graph (pt w),by simpa using slot_lt_card G.graph (hinc w).1⟩,
      ⟨slot H.graph (pt w),by simpa using slot_lt_card H.graph (hinc w).2⟩)
  refine ⟨slots,?_,?_⟩
  · intro u v huv
    apply S.windowCrossPoint_injective hP A B
    apply pair_slots_injOn G.graph H.graph G.slopes H.slopes (S.timeWindow_graph_gap hAB G H)
      (range pt) (by rintro _ ⟨w,rfl⟩; exact hinc w) (mem_range_self u) (mem_range_self v)
    exact congrArg (fun p : Fin (a*n) × Fin (a*n) => (p.1.val,p.2.val)) huv
  · intro w
    rw [Prod.dist_eq,max_le_iff]
    have hext := S.windowCrossPoint_exterior hAB w
    constructor
    · change |(S.rankFamily hP A).value (pt w)-(slot G.graph (pt w) : ℝ)/(a*n : ℕ)| ≤ _
      simpa only [Nat.cast_mul] using hGE _ hext.1
    · change |(S.rankFamily hP B).value (pt w)-(slot H.graph (pt w) : ℝ)/(a*n : ℕ)| ≤ _
      simpa only [Nat.cast_mul] using hHE _ hext.2

end PlanarHalving.Batches
namespace PlanarHalving.Batches
open MeasureTheory Set Limits TimeWindows PlaneGraph
open scoped NNReal ENNReal unitInterval
variable {n R k a : ℕ} {P : Fin n → Point}

lemma System.vertexMeasure_mass_le (S : @System n R k a P) [NeZero n]
    {X : Type*} [MeasurableSpace X] (z : Fin n → X) : (S.vertexMeasure z).mass ≤ 1 := by
  rw [System.vertexMeasure,mass_weightedAtoms]
  have hcard : Fintype.card ↥S.vertices ≤ n := by simpa using S.vertices.card_le_univ
  calc
    _ ≤ (n : ℝ≥0)⁻¹ * n := mul_le_mul_of_nonneg_left (by exact_mod_cast hcard) zero_le
    _ = 1 := inv_mul_cancel₀ (Nat.cast_ne_zero.mpr (NeZero.ne n))

noncomputable def System.windowCrossMeasure (S : @System n R k a P) [NeZero R]
    (A B : Window) {X : Type*} [MeasurableSpace X] (z : Point → X) : FiniteMeasure X :=
  weightedAtoms (((a*n : ℕ) : ℝ≥0)^2)⁻¹ (fun w => z (S.windowCrossPoint A B w))

lemma System.windowCrossMeasure_mass_le (S : @System n R k a P) [NeZero R] [NeZero n] [NeZero a]
    (hP : Generic P) (A B : Window) {X : Type*} [MeasurableSpace X] (z : Point → X) :
    (S.windowCrossMeasure A B z).mass ≤ 2 := by
  rw [System.windowCrossMeasure,mass_weightedAtoms,Fintype.card_coe]
  have hc : (S.windowCrossings A B).card ≤ 2*(a*n)^2 := by
    calc
      _ ≤ S.drawing.crossings.card := Finset.card_le_card (S.windowCrossings_sub A B)
      _ ≤ 2*a^2*S.vertices.card^2 := S.crossing_cap hP.1 (Generic.x_injective hP)
          (S.drawing.noMultiple_of_generic hP)
      _ ≤ 2*a^2*n^2 := by gcongr; exact S.vertices.card_le_univ.trans (by simp)
      _ = 2*(a*n)^2 := by ring
  have hM : (((a*n : ℕ) : ℝ≥0)^2) ≠ 0 :=
    pow_ne_zero _ (Nat.cast_ne_zero.mpr (Nat.mul_ne_zero (NeZero.ne a) (NeZero.ne n)))
  calc
    _ ≤ (((a*n : ℕ) : ℝ≥0)^2)⁻¹ * (2*((a*n : ℕ) : ℝ≥0)^2) := by
      gcongr
      exact_mod_cast hc
    _ = 2 := by rw [mul_left_comm,inv_mul_cancel₀ hM,mul_one]

end PlanarHalving.Batches
namespace PlanarHalving.RankLimits
open Batches TimeWindows Limits MeasureTheory Set Filter
open scoped Topology NNReal ENNReal unitInterval PiCountable

structure Configuration where
  n : ℕ
  R : ℕ
  k : ℕ
  a : ℕ
  n_pos : 0 < n
  R_pos : 0 < R
  a_pos : 0 < a
  point : Fin n → Point
  generic : Generic point
  system : @System n R k a point

instance (F : Configuration) : NeZero F.n := ⟨ne_of_gt F.n_pos⟩
instance (F : Configuration) : NeZero F.R := ⟨ne_of_gt F.R_pos⟩
instance (F : Configuration) : NeZero F.a := ⟨ne_of_gt F.a_pos⟩

noncomputable def Configuration.label (F : Configuration) : Point → Labels := F.system.labels F.generic

lemma Configuration.continuous_label (F : Configuration) : Continuous F.label :=
  F.system.continuous_labels F.generic

noncomputable def Configuration.points (F : Configuration) : FiniteMeasure Labels :=
  weightedAtoms (F.n : ℝ≥0)⁻¹ (F.label ∘ F.point)
noncomputable def Configuration.vertices (F : Configuration) (J : Window) : FiniteMeasure Labels :=
  (F.system.timeWindow J).vertexMeasure (F.label ∘ F.point)
noncomputable def Configuration.edgeTime (F : Configuration) : FiniteMeasure (Labels×I) :=
  F.system.labelTimeMeasure (F.label ∘ F.point)
noncomputable def Configuration.crossings (F : Configuration) (A B : Window) : FiniteMeasure Labels :=
  F.system.windowCrossMeasure A B F.label
noncomputable def Configuration.timeRestrict (F : Configuration) (J : Window) : FiniteMeasure (Labels×I) :=
  ⟨(F.edgeTime : Measure (Labels×I)).restrict (Prod.snd ⁻¹' carrier J),inferInstance⟩

lemma Configuration.points_mass (F : Configuration) : F.points.mass=1 := by
  rw [Configuration.points,mass_weightedAtoms,Fintype.card_fin]
  exact inv_mul_cancel₀ (Nat.cast_ne_zero.mpr (NeZero.ne F.n))
lemma Configuration.vertices_mass_le (F : Configuration) (J : Window) : (F.vertices J).mass ≤ 1 :=
  (F.system.timeWindow J).vertexMeasure_mass_le _
lemma Configuration.edgeTime_mass (F : Configuration) : F.edgeTime.mass=1 := F.system.labelTimeMeasure_mass _
lemma Configuration.crossings_mass_le (F : Configuration) (A B : Window) : (F.crossings A B).mass ≤ 2 :=
  F.system.windowCrossMeasure_mass_le F.generic A B _
lemma Configuration.timeRestrict_mass_le (F : Configuration) (J : Window) : (F.timeRestrict J).mass ≤ 1 := by
  rw [← F.edgeTime_mass]
  apply ENNReal.coe_le_coe.mp
  simp only [FiniteMeasure.ennreal_mass]
  change (F.edgeTime : Measure (Labels×I)).restrict (Prod.snd ⁻¹' carrier J) univ ≤
    (F.edgeTime : Measure (Labels×I)) univ
  exact Measure.restrict_le_self _

end PlanarHalving.RankLimits

end OAI