lean/OAI/Combinatorics/MatchingCount/Graphs/Related.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.PathActivity

namespace OAI

namespace MatchingFPRAS.Enlargement

open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry
open Finset

variable {V E : Type*} [Fintype V] [LinearOrder V] [Fintype E] [LinearOrder E]

lemma edge_activity_le_realBottleneck (u v : E → V) (huv : ∀ e, u e ≠ v e)
    (p : ℕ) (hp : 1 ≤ p) (B Hu Hv lam : E → ℝ) (e : E) (i : Fin (4*p+1)) :
    pathActivity p B Hu Hv lam e i ≤ realBottleneck u v p B Hu Hv lam
      (atVertex u v (4*p) e i.castSucc) (atVertex u v (4*p) e i.succ) := by
  apply interval_le_bottleneck u v (4*p) (by omega) huv (pathActivity p B Hu Hv lam) e
    i.castSucc i.succ (by simp)
  intro k hk hk'
  have he : k=i := Fin.ext (by simp only [Fin.val_castSucc,Fin.val_succ] at hk hk'; omega)
  subst k
  exact le_rfl

theorem realBottleneck_noncentral_edge (u v : E → V) (huv : ∀ e, u e ≠ v e)
    (p : ℕ) (hp : 1 ≤ p) (B Hu Hv lam : E → ℝ) (hB : ∀ e, 1 ≤ B e)
    (hHu : ∀ e, 0 ≤ Hu e) (hHv : ∀ e, 0 ≤ Hv e) (hlam : ∀ e, lam e ≤ B e)
    (e : E) (i : Fin (4*p+1)) (hi : i.val ≠ 2*p) :
    realBottleneck u v p B Hu Hv lam (atVertex u v (4*p) e i.castSucc)
      (atVertex u v (4*p) e i.succ) = pathActivity p B Hu Hv lam e i := by
  apply le_antisymm _ (edge_activity_le_realBottleneck u v huv p hp B Hu Hv lam e i)
  rcases lt_or_gt_of_ne hi with hi | hi
  · let j : Fin (4*p) := ⟨i.val,by omega⟩
    have hv : atVertex u v (4*p) e i.succ=Sum.inr (e,j) :=
      (atVertex_eq_inr_iff u v (4*p) e e i.succ j).mpr ⟨rfl,rfl⟩
    rw [hv,realBottleneck,bottleneck_comm]
    have hc := realBottleneck_internal_cap u v p hp B Hu Hv lam hB hHu hHv hlam e j
      (atVertex u v (4*p) e i.castSucc)
    simpa [realBottleneck,pathActivity,internalStrength,show j.val<2*p from hi,
      profile_left p (B e) (Hu e) (Hv e) (lam e) i hi,j] using hc
  · let j : Fin (4*p) := ⟨i.val-1,by have := i.isLt; omega⟩
    have hv : atVertex u v (4*p) e i.castSucc=Sum.inr (e,j) :=
      (atVertex_eq_inr_iff u v (4*p) e e i.castSucc j).mpr ⟨rfl,by dsimp [j]; omega⟩
    rw [hv]
    have hc := realBottleneck_internal_cap u v p hp B Hu Hv lam hB hHu hHv hlam e j
      (atVertex u v (4*p) e i.succ)
    have hj : ¬ j.val < 2*p := by dsimp [j]; omega
    have he : j.val+1=i.val := by dsimp [j]; omega
    simpa only [pathActivity,profile_right p (B e) (Hu e) (Hv e) (lam e) i hi,
      internalStrength,ite_eq_right hj,he] using hc

variable {V : Type*} [Fintype V] [LinearOrder V]

theorem realBottleneck_central_edge (w : V → V → ℝ) (p : ℕ) (hp : 1 ≤ p)
    (Hu Hv : LogicalEdge V → ℝ) (hHu : ∀ e, 0 ≤ Hu e) (hHv : ∀ e, 0 ≤ Hv e)
    (hinner : ∀ e, max (bottleneck w (source e) (target e)) (Hu e/2^(p-1)) =
      bottleneck w (source e) (target e)) (e : LogicalEdge V) :
    realBottleneck source target p (fun e => bottleneck w (source e) (target e))
      Hu Hv (logicalActivity w)
      (atVertex source target (4*p) e ⟨2*p,by omega⟩)
      (atVertex source target (4*p) e ⟨2*p+1,by omega⟩) =
      bottleneck w (source e) (target e) := by
  let B := fun e : LogicalEdge V => bottleneck w (source e) (target e)
  let j : Fin (4*p) := ⟨2*p-1,by omega⟩
  let k : Fin (4*p) := ⟨2*p,by omega⟩
  have hj : j.val < 2*p := by dsimp [j]; omega
  have hk : ¬ k.val < 2*p := by simp [k]
  have hjk : j≠k := by intro h; have := congrArg Fin.val h; dsimp [j,k] at this; omega
  have hjv : atVertex source target (4*p) e ⟨2*p,by omega⟩ = Sum.inr (e,j) :=
    (atVertex_eq_inr_iff _ _ _ _ _ _ _).mpr ⟨rfl,by dsimp [j]; omega⟩
  have hkv : atVertex source target (4*p) e ⟨2*p+1,by omega⟩ = Sum.inr (e,k) :=
    (atVertex_eq_inr_iff _ _ _ _ _ _ _).mpr ⟨rfl,rfl⟩
  rw [hjv,hkv]
  have hsj : internalStrength p (B e) (Hu e) (Hv e) j=B e := by
    rw [internalStrength,ite_eq_left hj]
    have hdiv : j.val/2=p-1 := by dsimp [j]; omega
    rw [hdiv]
    exact hinner e
  apply le_antisymm
  · have hc := realBottleneck_internal_cap source target p hp B Hu Hv (logicalActivity w)
        (fun e => one_le_bottleneck w _ _) hHu hHv
        (fun e => edgeActivity_le_bottleneck w _ _ (source_ne_target e)) e j (Sum.inr (e,k))
    exact (hc.trans_eq hsj)
  · let t := activity source target (4*p) (pathActivity p B Hu Hv (logicalActivity w))
    have hleft : B e ≤ bottleneck t (Sum.inr (e,j)) (Sum.inl (source e)) :=
      (le_internalStrength p (B e) (Hu e) (Hv e) j).trans
        (realBottleneck_left_home source target source_ne_target p hp B Hu Hv (logicalActivity w) hHu e j hj)
    have hright : B e ≤ bottleneck t (Sum.inr (e,k)) (Sum.inl (target e)) :=
      (le_internalStrength p (B e) (Hu e) (Hv e) k).trans
        (realBottleneck_right_home source target source_ne_target p hp B Hu Hv (logicalActivity w) hHv e k hk)
    have hterm : bottleneck t (Sum.inl (source e)) (Sum.inl (target e))=B e :=
      terminal_bottleneck w p hp Hu Hv _ _
    have hx : B e ≤ bottleneck t (Sum.inr (e,j)) (Sum.inl (target e)) := by
      have ht := bottleneck_ultrametric t (Sum.inr (e,j)) (Sum.inl (target e)) (Sum.inl (source e))
        (by simp) (by simp) (by simpa using (source_ne_target e).symm)
      exact ((le_min hleft hterm.ge).trans ht)
    have htri := bottleneck_ultrametric t (Sum.inr (e,j)) (Sum.inr (e,k)) (Sum.inl (target e))
      (by simpa using hjk) (by simp) (by simp)
    rw [bottleneck_comm t (Sum.inl (target e)) (Sum.inr (e,k))] at htri
    exact (le_min hx hright).trans htri

theorem source_effective_profile (w : V → V → ℝ) (p : ℕ) (hp : 1≤p)
    (Hu Hv : LogicalEdge V → ℝ) (hHu : ∀ e, 0≤Hu e) (hHv : ∀ e, 0≤Hv e)
    (hinner : ∀ e, max (bottleneck w (source e) (target e)) (Hu e/2^(p-1)) =
      bottleneck w (source e) (target e)) (e : LogicalEdge V) (i : Fin (4*p+1)) :
    realBottleneck source target p (fun e => bottleneck w (source e) (target e)) Hu Hv
      (logicalActivity w) (atVertex source target (4*p) e i.castSucc)
      (atVertex source target (4*p) e i.succ) =
      profileActivity p (bottleneck w (source e) (target e)) (Hu e) (Hv e)
        (bottleneck w (source e) (target e)) i := by
  by_cases hi : i.val=2*p
  · have he : i=⟨2*p,by omega⟩ := Fin.ext hi
    rw [he,profile_center]
    exact realBottleneck_central_edge w p hp Hu Hv hHu hHv hinner e
  · rw [realBottleneck_noncentral_edge source target source_ne_target p hp _ Hu Hv
      (logicalActivity w) (fun _ => one_le_bottleneck _ _ _) hHu hHv
      (fun e => edgeActivity_le_bottleneck w _ _ (source_ne_target e)) e i hi]
    rcases lt_or_gt_of_ne hi with hi | hi
    · simp only [pathActivity,profile_left _ _ _ _ _ _ hi]
    · simp only [pathActivity,profile_right _ _ _ _ _ _ hi]

omit [Fintype V] [LinearOrder V] in
theorem effective_profile_incident_near {E : Type*} (u v : E → V)
    (p : ℕ) (hp : 1≤p) (B : E → ℝ) (H : V → ℝ)
    (hB : ∀ e, 0≤B e) (hH : ∀ x, 0≤H x)
    (hdom : ∀ e, B e≤H (u e) ∧ B e≤H (v e))
    (hinnerL : ∀ e, max (B e) (H (u e)/2^(p-1))=B e)
    (hinnerR : ∀ e, max (B e) (H (v e)/2^(p-1))=B e)
    (x : Vertex V E (4*p)) (e f : E) (i j : Fin (4*p+1))
    (he : x=atVertex u v (4*p) e i.castSucc ∨ x=atVertex u v (4*p) e i.succ)
    (hf : x=atVertex u v (4*p) f j.castSucc ∨ x=atVertex u v (4*p) f j.succ) :
    profileActivity p (B e) (H (u e)) (H (v e)) (B e) i ≤
      2*profileActivity p (B f) (H (u f)) (H (v f)) (B f) j := by
  cases x with
  | inl x =>
    have ht (g : E) (k : Fin (4*p+1))
        (hg : Sum.inl x=atVertex u v (4*p) g k.castSucc ∨ Sum.inl x=atVertex u v (4*p) g k.succ) :
        profileActivity p (B g) (H (u g)) (H (v g)) (B g) k=H x := by
      rcases hg with hg | hg
      · obtain ⟨hk,hx⟩ := (first_vertex_terminal u v (4*p) g k x).mp hg.symm
        rw [profile_left _ _ _ _ _ _ (by omega),hk]
        simp only [Nat.zero_div,pow_zero,div_one,max_eq_right (hdom g).1]
        exact congrArg H hx
      · obtain ⟨hk,hx⟩ := (second_vertex_terminal u v (4*p) g k x).mp hg.symm
        rw [profile_right _ _ _ _ _ _ (by omega),hk]
        simp only [Nat.sub_self,Nat.zero_div,pow_zero,div_one,max_eq_right (hdom g).2]
        exact congrArg H hx
    rw [ht e i he,ht f j hf]
    linarith [hH x]
  | inr z =>
    rcases z with ⟨g,k⟩
    have hi : e=g ∧ (i.val=k.val ∨ i.val=k.val+1) := by
      rcases he with he | he
      · have hh := (atVertex_eq_inr_iff u v (4*p) e g i.castSucc k).mp he.symm
        exact ⟨hh.1,Or.inr hh.2⟩
      · have hh := (atVertex_eq_inr_iff u v (4*p) e g i.succ k).mp he.symm
        exact ⟨hh.1,Or.inl (by simpa using hh.2)⟩
    have hj : f=g ∧ (j.val=k.val ∨ j.val=k.val+1) := by
      rcases hf with hf | hf
      · have hh := (atVertex_eq_inr_iff u v (4*p) f g j.castSucc k).mp hf.symm
        exact ⟨hh.1,Or.inr hh.2⟩
      · have hh := (atVertex_eq_inr_iff u v (4*p) f g j.succ k).mp hf.symm
        exact ⟨hh.1,Or.inl (by simpa using hh.2)⟩
    obtain ⟨rfl,hi⟩ := hi
    obtain ⟨rfl,hj⟩ := hj
    have hnear := profile_adjacent_near p hp (B f) (H (u f)) (H (v f))
      (hB f) (hH _) (hH _) (hinnerL f) (hinnerR f) k
    rcases hi with hi | hi <;> rcases hj with hj | hj
    · have heq : i=j := Fin.ext (hi.trans hj.symm)
      rw [heq]
      have hn := (hB f).trans (profile_lower p (B f) (H (u f)) (H (v f)) (B f) le_rfl j)
      linarith
    · have hi' : i=k.castSucc := Fin.ext hi
      have hj' : j=k.succ := Fin.ext hj
      simpa [hi',hj'] using hnear.1
    · have hi' : i=k.succ := Fin.ext hi
      have hj' : j=k.castSucc := Fin.ext hj
      simpa [hi',hj'] using hnear.2
    · have heq : i=j := Fin.ext (hi.trans hj.symm)
      rw [heq]
      have hn := (hB f).trans (profile_lower p (B f) (H (u f)) (H (v f)) (B f) le_rfl j)
      linarith

end MatchingFPRAS.Enlargement

namespace MatchingFPRAS.Hierarchy

theorem acyclic_of_unique_lower {L : Type*} (G : SimpleGraph L) (rank : L → ℕ)
    (hdiff : ∀ {a b}, G.Adj a b → rank a ≠ rank b)
    (hparent : ∀ a b c, G.Adj a b → G.Adj a c → rank b < rank a → rank c < rank a → b=c) :
    G.IsAcyclic := by
  classical
  intro a p hp
  obtain ⟨b,hb,hmax⟩ := p.support.toFinset.exists_max_image rank
    ⟨a,by simp⟩
  have hb' : b ∈ p.support := List.mem_toFinset.mp hb
  let q := p.rotate b hb'
  have hq : q.IsCycle := hp.rotate hb'
  have hqs : q.snd ∈ p.support := (p.mem_support_rotate_iff b hb').mp (q.getVert_mem_support 1)
  have hqt : q.penultimate ∈ p.support :=
    (p.mem_support_rotate_iff b hb').mp (q.getVert_mem_support (q.length-1))
  have hs : rank q.snd < rank b := lt_of_le_of_ne
    (hmax q.snd (List.mem_toFinset.mpr hqs)) (hdiff (q.adj_snd hq.not_nil)).symm
  have ht : rank q.penultimate < rank b := lt_of_le_of_ne
    (hmax q.penultimate (List.mem_toFinset.mpr hqt)) (hdiff (q.adj_penultimate hq.not_nil))
  exact hq.snd_ne_penultimate (hparent b q.snd q.penultimate (q.adj_snd hq.not_nil)
    (q.adj_penultimate hq.not_nil).symm hs ht)

variable {V : Type*} [Fintype V]

variable (B : V → V → ℝ)

variable (hsym : ∀ a b, B a b = B b a)

variable (htri : ∀ a b c, a ≠ b → a ≠ c → b ≠ c → min (B a c) (B c b) ≤ B a b)

def Related (t : ℝ) (a b : V) : Prop := a=b ∨ t ≤ B a b

omit [Fintype V] in
include hsym in
lemma related_symm (t : ℝ) {a b : V} (h : Related B t a b) : Related B t b a := by
  rcases h with h | h
  · exact Or.inl h.symm
  · exact Or.inr (by rwa [hsym])

omit [Fintype V] in
include htri in
lemma related_trans (t : ℝ) {a b c : V} (hab : Related B t a b) (hbc : Related B t b c) :
    Related B t a c := by
  rcases hab with rfl | hab
  · exact hbc
  rcases hbc with rfl | hbc
  · exact Or.inr hab
  by_cases hac : a=c
  · exact Or.inl hac
  by_cases hab' : a=b
  · subst b; exact Or.inr hbc
  by_cases hbc' : c=b
  · subst c; exact Or.inr hab
  exact Or.inr ((le_min hab hbc).trans (htri a c b hac hab' hbc'))

def thresholdSetoid (t : ℝ) : Setoid V where
  r := Related B t
  iseqv := ⟨fun _ => Or.inl rfl,related_symm B hsym t,related_trans B htri t⟩

abbrev Component (t : ℝ) := Quotient (thresholdSetoid B hsym htri t)

abbrev Label (H : ℕ) := (k : Fin (H+1)) × Component B hsym htri (2^k.val)

def labelAt {H : ℕ} (k : Fin (H+1)) (x : V) : Label B hsym htri H :=
  ⟨k,Quotient.mk _ x⟩

def Mem {H : ℕ} (l : Label B hsym htri H) (x : V) : Prop := Quotient.mk _ x = l.2

omit [Fintype V] in
lemma mem_labelAt {H : ℕ} (k : Fin (H+1)) (x : V) : Mem B hsym htri (labelAt B hsym htri k x) x := rfl

omit [Fintype V] in
lemma mem_class_iff {H : ℕ} (k : Fin (H+1)) (x y : V) :
    Mem B hsym htri (labelAt B hsym htri k x) y ↔ Related B (2^k.val) y x :=
  Quotient.eq

omit [Fintype V] in
lemma exists_mem {H : ℕ} (l : Label B hsym htri H) : ∃ x, Mem B hsym htri l x :=
  Quotient.exists_rep l.2

omit [Fintype V] in
lemma eq_of_level_of_mem {H : ℕ} (a b : Label B hsym htri H) (hlev : a.1=b.1)
    {x : V} (ha : Mem B hsym htri a x) (hb : Mem B hsym htri b x) : a=b := by
  cases a with
  | mk k a =>
    cases b with
    | mk j b =>
      dsimp at hlev
      subst j
      exact congrArg (Sigma.mk k) (ha.symm.trans hb)

omit [Fintype V] in
lemma related_of_mem {H : ℕ} (l : Label B hsym htri H) {x y : V}
    (hx : Mem B hsym htri l x) (hy : Mem B hsym htri l y) : Related B (2^l.1.val) x y :=
  Quotient.exact (hx.trans hy.symm)

omit [Fintype V] in
lemma mem_of_related {H : ℕ} (l : Label B hsym htri H) {x y : V}
    (hx : Mem B hsym htri l x) (hxy : Related B (2^l.1.val) y x) : Mem B hsym htri l y :=
  (Quotient.sound hxy).trans hx

omit [Fintype V] in
lemma related_mono {s t : ℝ} (hst : s ≤ t) {a b : V} (h : Related B t a b) :
    Related B s a b := h.imp id (fun hb => hst.trans hb)

def Parent {H : ℕ} (a b : Label B hsym htri H) : Prop :=
  a.1.val+1=b.1.val ∧ ∃ x, Mem B hsym htri a x ∧ Mem B hsym htri b x

def tree {H : ℕ} : SimpleGraph (Label B hsym htri H) where
  Adj a b := Parent B hsym htri a b ∨ Parent B hsym htri b a
  symm := ⟨fun _ _ h => h.symm⟩
  loopless := ⟨by intro a h; rcases h with h|h <;> have := h.1 <;> omega⟩

omit [Fintype V] in
lemma parent_mem {H : ℕ} {a b : Label B hsym htri H} (h : Parent B hsym htri a b)
    {x : V} (hx : Mem B hsym htri b x) : Mem B hsym htri a x := by
  obtain ⟨hlev,y,hy,hby⟩ := h
  have hpow : (2:ℝ)^a.1.val ≤ 2^b.1.val := pow_le_pow_right₀ (by norm_num) (by omega)
  exact mem_of_related B hsym htri a hy
    (related_mono B hpow (related_of_mem B hsym htri b hx hby))

omit [Fintype V] in
lemma parent_unique {H : ℕ} {a b c : Label B hsym htri H}
    (ha : Parent B hsym htri a c) (hb : Parent B hsym htri b c) : a=b := by
  obtain ⟨x,hx⟩ := exists_mem B hsym htri c
  apply eq_of_level_of_mem B hsym htri a b _
    (parent_mem B hsym htri ha hx) (parent_mem B hsym htri hb hx)
  apply Fin.ext
  have := ha.1
  have := hb.1
  omega

omit [Fintype V] in
theorem tree_acyclic (H : ℕ) : (tree B hsym htri (H := H)).IsAcyclic := by
  apply acyclic_of_unique_lower _ (fun l => l.1.val)
  · intro a b hab
    rcases hab with h | h <;> have := h.1 <;> omega
  · intro a b c hab hac hb hc
    have hp : Parent B hsym htri b a := by
      rcases hab with h | h
      · have := h.1; omega
      · exact h
    have hq : Parent B hsym htri c a := by
      rcases hac with h | h
      · have := h.1; omega
      · exact h
    exact parent_unique B hsym htri hp hq

omit [Fintype V] in
lemma parent_exists {H : ℕ} (a : Label B hsym htri H) (ha : 0<a.1.val) :
    ∃ b, Parent B hsym htri b a := by
  obtain ⟨x,hx⟩ := exists_mem B hsym htri a
  let k : Fin (H+1) := ⟨a.1.val-1,by have := a.1.isLt; omega⟩
  exact ⟨labelAt B hsym htri k x,by dsimp [Parent,k,labelAt]; exact ⟨by omega,x,rfl,hx⟩⟩

variable (hfloor : ∀ a b, 1 ≤ B a b)

omit [Fintype V] in
include hfloor in
lemma level_zero_unique {H : ℕ} (a b : Label B hsym htri H)
    (ha : a.1.val=0) (hb : b.1.val=0) : a=b := by
  obtain ⟨x,hx⟩ := exists_mem B hsym htri a
  obtain ⟨y,hy⟩ := exists_mem B hsym htri b
  apply eq_of_level_of_mem B hsym htri a b (Fin.ext (ha.trans hb.symm)) hx
  apply mem_of_related B hsym htri b hy
  exact Or.inr (by simpa [hb] using hfloor x y)

omit [Fintype V] in
lemma reaches_level_zero {H : ℕ} (a : Label B hsym htri H) :
    ∃ b, b.1.val=0 ∧ (tree B hsym htri).Reachable a b := by
  induction h : a.1.val using Nat.strong_induction_on generalizing a with
  | h n ih =>
    by_cases hn : n=0
    · exact ⟨a,h.trans hn,SimpleGraph.Reachable.refl a⟩
    · obtain ⟨b,hb⟩ := parent_exists B hsym htri a (by omega)
      obtain ⟨c,hc,hbc⟩ := ih b.1.val (by have := hb.1; omega) b rfl
      exact ⟨c,hc,(SimpleGraph.Adj.reachable (show (tree B hsym htri).Adj a b from Or.inr hb)).trans hbc⟩

omit [Fintype V] in
include hfloor in
theorem tree_connected [Nonempty V] (H : ℕ) : (tree B hsym htri (H := H)).Connected := by
  classical
  let : Nonempty (Label B hsym htri H) := ⟨labelAt B hsym htri 0 (Classical.choice inferInstance)⟩
  refine ⟨?_⟩
  intro a b
  obtain ⟨a₀,ha₀,ha⟩ := reaches_level_zero B hsym htri a
  obtain ⟨b₀,hb₀,hb⟩ := reaches_level_zero B hsym htri b
  have he := level_zero_unique B hsym htri hfloor a₀ b₀ ha₀ hb₀
  subst b₀
  exact ha.trans hb.symm

noncomputable instance labelFintype (H : ℕ) : Fintype (Label B hsym htri H) := Fintype.ofFinite _

theorem label_card_le (H : ℕ) : Fintype.card (Label B hsym htri H) ≤ (H+1)*Fintype.card V := by
  classical
  have hs : Function.Surjective (fun z : Fin (H+1) × V => labelAt B hsym htri z.1 z.2) := by
    intro a
    obtain ⟨x,hx⟩ := exists_mem B hsym htri a
    exact ⟨(a.1,x),Sigma.ext rfl (heq_of_eq hx)⟩
  simpa only [Fintype.card_prod,Fintype.card_fin] using Fintype.card_le_of_surjective _ hs

noncomputable def dyadicLevel (H : ℕ) (x : ℝ) : Fin (H+1) := by
  classical
  exact ⟨Nat.findGreatest (fun k => (2:ℝ)^k ≤ x) H,
    Nat.lt_succ_of_le (Nat.findGreatest_le H)⟩

lemma dyadic_lower (H : ℕ) (x : ℝ) (hx : 1 ≤ x) :
    (2:ℝ)^(dyadicLevel H x).val ≤ x := by
  classical
  exact Nat.findGreatest_spec (P := fun k => (2:ℝ)^k ≤ x) (Nat.zero_le H) (by simpa using hx)

lemma dyadic_upper (H : ℕ) (x : ℝ) (hx : x ≤ (2:ℝ)^H) :
    x < (2:ℝ)^((dyadicLevel H x).val+1) := by
  classical
  by_cases he : (dyadicLevel H x).val=H
  · rw [he,pow_succ]
    have : 0 < (2:ℝ)^H := by positivity
    linarith
  · by_contra hn
    have hle : (dyadicLevel H x).val+1 ≤ H := by have := (dyadicLevel H x).isLt; omega
    have hg := Nat.le_findGreatest (P := fun k => (2:ℝ)^k ≤ x) hle (le_of_not_gt hn)
    change (dyadicLevel H x).val+1 ≤ (dyadicLevel H x).val at hg
    omega

lemma dyadic_near (H : ℕ) (x y : ℝ) (hxlo : 1 ≤ x) (hyhi : y ≤ (2:ℝ)^H)
    (hxy : x ≤ 2*y) : (dyadicLevel H x).val ≤ (dyadicLevel H y).val+1 := by
  by_contra hn
  have hpow : (2:ℝ)^((dyadicLevel H y).val+2) ≤ 2^(dyadicLevel H x).val :=
    pow_le_pow_right₀ (by norm_num) (by omega)
  have hx := dyadic_lower H x hxlo
  have hy := dyadic_upper H y hyhi
  rw [show (dyadicLevel H y).val+2=((dyadicLevel H y).val+1)+1 by omega,pow_succ] at hpow
  linarith

lemma dyadic_upper_of_lt (H : ℕ) (x : ℝ) (hx : x < (2:ℝ)^(H+1)) :
    x < (2:ℝ)^((dyadicLevel H x).val+1) := by
  classical
  by_cases he : (dyadicLevel H x).val=H
  · simpa [he] using hx
  · by_contra hn
    have hle : (dyadicLevel H x).val+1 ≤ H := by have := (dyadicLevel H x).isLt; omega
    have hg := Nat.le_findGreatest (P := fun k => (2:ℝ)^k ≤ x) hle (le_of_not_gt hn)
    change (dyadicLevel H x).val+1 ≤ (dyadicLevel H x).val at hg
    omega

lemma dyadic_near_of_lt (H : ℕ) (x y : ℝ) (hxlo : 1≤x) (hyhi : y < (2:ℝ)^(H+1))
    (hxy : x≤2*y) : (dyadicLevel H x).val ≤ (dyadicLevel H y).val+1 := by
  by_contra hn
  have hpow : (2:ℝ)^((dyadicLevel H y).val+2) ≤ 2^(dyadicLevel H x).val :=
    pow_le_pow_right₀ (by norm_num) (by omega)
  have hx := dyadic_lower H x hxlo
  have hy := dyadic_upper_of_lt H y hyhi
  rw [show (dyadicLevel H y).val+2=((dyadicLevel H y).val+1)+1 by omega,pow_succ] at hpow
  linarith

omit [Fintype V] in
lemma common_vertex_adjacent {H : ℕ} (a b : Label B hsym htri H) {x : V}
    (ha : Mem B hsym htri a x) (hb : Mem B hsym htri b x)
    (hab : a.1.val ≤ b.1.val+1) (hba : b.1.val ≤ a.1.val+1) :
    a=b ∨ (tree B hsym htri).Adj a b := by
  rcases lt_trichotomy a.1.val b.1.val with h | h | h
  · exact Or.inr (Or.inl ⟨by omega,x,ha,hb⟩)
  · exact Or.inl (eq_of_level_of_mem B hsym htri a b (Fin.ext h) ha hb)
  · exact Or.inr (Or.inr ⟨by omega,x,hb,ha⟩)

omit [Fintype V] in
lemma memberships_card_le_two {H : ℕ} (S : Finset (Label B hsym htri H)) (x : V)
    (hmem : ∀ a ∈ S, Mem B hsym htri a x)
    (hsep : ∀ a ∈ S, ∀ b ∈ S, a.1.val ≤ b.1.val+1) : S.card ≤ 2 := by
  classical
  by_cases hne : S.Nonempty
  · obtain ⟨a,ha,hmin⟩ := S.exists_min_image (fun a => a.1.val) hne
    have hinj : Set.InjOn (fun a : Label B hsym htri H => a.1.val) S := by
      intro b hb c hc he
      exact eq_of_level_of_mem B hsym htri b c (Fin.ext he) (hmem b hb) (hmem c hc)
    have hsub : S.image (fun a => a.1.val) ⊆ {a.1.val,a.1.val+1} := by
      intro k hk
      obtain ⟨b,hb,rfl⟩ := Finset.mem_image.mp hk
      have h₁ := hmin b hb
      have h₂ := hsep b hb a ha
      simp only [Finset.mem_insert,Finset.mem_singleton]
      omega
    calc
      S.card = (S.image (fun a => a.1.val)).card := (Finset.card_image_of_injOn hinj).symm
      _ ≤ ({a.1.val,a.1.val+1} : Finset ℕ).card := Finset.card_le_card hsub
      _ ≤ 2 := by simp
  · simp [Finset.not_nonempty_iff_eq_empty.mp hne]

variable {E : Type*} [Fintype E] (left right : E → V) (H : ℕ)

def Incident (e : E) (x : V) : Prop := x=left e ∨ x=right e

noncomputable def edgeLabel (e : E) : Label B hsym htri H :=
  labelAt B hsym htri (dyadicLevel H (B (left e) (right e))) (left e)

noncomputable def memberships (x : V) : Finset (Label B hsym htri H) := by
  classical
  exact (Finset.univ.filter (fun e => Incident left right e x)).image
    (edgeLabel B hsym htri left right H)

omit [Fintype V] in
lemma mem_memberships (x : V) (l : Label B hsym htri H) :
    l ∈ memberships B hsym htri left right H x ↔
      ∃ e, Incident left right e x ∧ edgeLabel B hsym htri left right H e=l := by
  classical
  simp [memberships]

omit [Fintype V] [Fintype E] in
include hfloor in
lemma incident_mem_label (e : E) {x : V} (hx : Incident left right e x) :
    Mem B hsym htri (edgeLabel B hsym htri left right H e) x := by
  rcases hx with rfl | rfl
  · rfl
  · apply (mem_class_iff B hsym htri _ _ _).mpr
    exact Or.inr (by rw [hsym]; exact dyadic_lower H _ (hfloor _ _))

omit [Fintype V] in
include hfloor in
lemma membership_mem {x : V} {l : Label B hsym htri H}
    (hl : l ∈ memberships B hsym htri left right H x) : Mem B hsym htri l x := by
  obtain ⟨e,he,rfl⟩ := (mem_memberships B hsym htri left right H x l).mp hl
  exact incident_mem_label B hsym htri hfloor left right H e he

variable (hupper : ∀ e, B (left e) (right e) < (2:ℝ)^(H+1))

variable (hnear : ∀ x e f, Incident left right e x → Incident left right f x →
  B (left e) (right e) ≤ 2*B (left f) (right f))

omit [Fintype V] in
include hfloor hupper hnear in
lemma memberships_level_near {x : V} {a b : Label B hsym htri H}
    (ha : a ∈ memberships B hsym htri left right H x)
    (hb : b ∈ memberships B hsym htri left right H x) : a.1.val ≤ b.1.val+1 := by
  obtain ⟨e,he,rfl⟩ := (mem_memberships B hsym htri left right H x a).mp ha
  obtain ⟨f,hf,rfl⟩ := (mem_memberships B hsym htri left right H x b).mp hb
  exact dyadic_near_of_lt H _ _ (hfloor _ _) (hupper f) (hnear x e f he hf)

omit [Fintype V] in
include hfloor hupper hnear in

theorem memberships_tree_bags (x : V) (a b : Label B hsym htri H)
    (ha : a ∈ memberships B hsym htri left right H x)
    (hb : b ∈ memberships B hsym htri left right H x) :
    a=b ∨ (tree B hsym htri).Adj a b := by
  exact common_vertex_adjacent B hsym htri a b
    (membership_mem B hsym htri hfloor left right H ha)
    (membership_mem B hsym htri hfloor left right H hb)
    (memberships_level_near B hsym htri hfloor left right H hupper hnear ha hb)
    (memberships_level_near B hsym htri hfloor left right H hupper hnear hb ha)

omit [Fintype V] in
include hfloor hupper hnear in
lemma membership_count (x : V) : (memberships B hsym htri left right H x).card ≤ 2 := by
  apply memberships_card_le_two B hsym htri _ x
  · intro a ha; exact membership_mem B hsym htri hfloor left right H ha
  · intro a ha b hb
    exact memberships_level_near B hsym htri hfloor left right H hupper hnear ha hb

omit [Fintype V] in
include hfloor in
lemma common_height_le {x y : V} {l : Label B hsym htri H} (hxy : x≠y)
    (hx : l ∈ memberships B hsym htri left right H x)
    (hy : l ∈ memberships B hsym htri left right H y) : (2:ℝ)^l.1.val ≤ B x y := by
  exact (related_of_mem B hsym htri l
    (membership_mem B hsym htri hfloor left right H hx)
    (membership_mem B hsym htri hfloor left right H hy)).resolve_left hxy

omit [Fintype V] [Fintype E] in
include hupper in
lemma edge_strength_lt_twice_height (e : E) :
    B (left e) (right e) < 2*(2:ℝ)^(edgeLabel B hsym htri left right H e).1.val := by
  simpa [edgeLabel,labelAt,pow_succ,mul_comm] using dyadic_upper_of_lt H _ (hupper e)

omit [Fintype V] in
lemma adjacent_heights {a b : Label B hsym htri H} (hab : (tree B hsym htri).Adj a b) :
    (2:ℝ)^a.1.val ≤ 2*(2:ℝ)^b.1.val ∧ (2:ℝ)^b.1.val ≤ 2*(2:ℝ)^a.1.val := by
  rcases hab with h | h <;> have he := h.1
  · have hpow : (2:ℝ)^b.1.val=2*2^a.1.val := by rw [←he,pow_succ]; ring
    rw [hpow]; constructor <;> nlinarith [pow_pos (by norm_num : (0:ℝ)<2) a.1.val]
  · have hpow : (2:ℝ)^a.1.val=2*2^b.1.val := by rw [←he,pow_succ]; ring
    rw [hpow]; constructor <;> nlinarith [pow_pos (by norm_num : (0:ℝ)<2) b.1.val]

end MatchingFPRAS.Hierarchy

end OAI