Blame for lean/OAI/Combinatorics/CycleDecomposition/CycleLifting.lean

import OAI.Combinatorics.CycleDecomposition.BatchRouting

namespace OAI

universe cycleUniverse1 cycleUniverse2 cycleUniverse3 cycleUniverse4 cycleUniverse5 cycleUniverse6 cycleUniverse7 cycleUniverse8 cycleUniverse9 cycleUniverse10 cycleUniverse11 cycleUniverse12 cycleUniverse13 cycleUniverse14 cycleUniverse15 cycleUniverse16 cycleUniverse17 cycleUniverse18 cycleUniverse19 cycleUniverse20

section
open Filter Asymptotics Real
open scoped Topology
noncomputable section
open MeasureTheory ProbabilityTheory Finset
section
namespace ErdosGallai.Batch
noncomputable section
open Real Filter Asymptotics

lemma routing_length_upper (r h : ℝ) (hr : 2 ≤ r) (hh : 0 < h) (hhr : h ≤ r) :
    (routingLength r h : ℝ) ≤ 108*(r/h)*(logb 2 r)^2 := by
  have hr0 : 0 < r := by linarith
  have hl : 1 ≤ logb 2 r := by
    simpa using Real.logb_le_logb_of_le (by norm_num : (1:ℝ) < 2)
      (by norm_num : (0:ℝ) < 2) hr
  have hR : 1 ≤ r/h := (le_div_iff₀ hh).mpr (by simpa using hhr)
  have hlog : logb 2 (2*r) = 1 + logb 2 r := by
    rw [Real.logb_mul (by norm_num) hr0.ne']
    norm_num
  have hg := Nat.ceil_lt_add_one (show 0 ≤ 8*(r/h)*logb 2 (2*r) by rw [hlog]; positivity)
  have hd := Nat.ceil_lt_add_one (show 0 ≤ logb 2 r by linarith)
  change (routingG r h : ℝ) < 8*(r/h)*logb 2 (2*r)+1 at hg
  change (routingDepth r : ℝ) < logb 2 r + 1 at hd
  rw [hlog] at hg
  have hprod : 1 ≤ (r/h)*logb 2 r := by
    nlinarith [mul_nonneg (sub_nonneg.mpr hR) (sub_nonneg.mpr hl)]
  have hg' : (routingG r h : ℝ) ≤ 18*(r/h)*logb 2 r := by nlinarith
  have hd' : (1 + routingDepth r : ℝ) ≤ 3*logb 2 r := by linarith
  have hm := mul_le_mul hg' hd' (by positivity) (by positivity)
  dsimp [routingLength]
  push_cast
  nlinarith

lemma eventually_logb_le_power (ε : ℝ) (hε : 0 < ε) :
    ∀ᶠ D : ℝ in atTop, logb 2 D ≤ D^ε := by
  have ho := (isLittleO_log_rpow_atTop hε).const_mul_left (1 / log 2)
  filter_upwards [ho.eventuallyLE, eventually_ge_atTop (1:ℝ)] with D hD h1
  simpa [Real.logb, div_eq_mul_inv, mul_comm, Real.norm_eq_abs,
    abs_of_nonneg (Real.log_nonneg h1), abs_of_nonneg (Real.rpow_nonneg (by linarith) ε),
    abs_of_pos (show 0 < (log 2)⁻¹ by positivity),
    abs_of_pos (Real.log_pos (by norm_num : (1:ℝ) < 2))] using hD

lemma eventually_constant_le_power (C ε : ℝ) (hε : 0 < ε) :
    ∀ᶠ D : ℝ in atTop, C ≤ D^ε :=
  (tendsto_rpow_atTop hε).eventually (eventually_ge_atTop C)

lemma eventually_const_mul_power_le (C α β : ℝ) (hab : α < β) :
    ∀ᶠ D : ℝ in atTop, C*D^α ≤ D^β := by
  filter_upwards [eventually_constant_le_power C (β-α) (by linarith),
    eventually_gt_atTop (0:ℝ)] with D hc hD
  calc
    C*D^α ≤ D^(β-α)*D^α := mul_le_mul_of_nonneg_right hc (Real.rpow_nonneg hD.le _)
    _ = D^β := by rw [← Real.rpow_add hD]; congr 1; ring

theorem eventually_routing_length (c β γ δ : ℝ) (hc : 0 < c) (hβ : 0 < β)
    (hδ : 0 < δ) :
    ∀ᶠ D : ℝ in atTop, ∀ r : ℝ, 2 ≤ r → r ≤ D^β → c*D^γ ≤ r →
      (routingLength r (c*D^γ) : ℝ) ≤ D^(β-γ+δ) := by
  filter_upwards [eventually_logb_le_power (δ/4) (by positivity),
    eventually_constant_le_power (108*β^2/c) (δ/2) (by positivity),
    eventually_gt_atTop (1:ℝ)] with D hlog hconst hD r hr hrD hhr
  have hD0 : 0 < D := by linarith
  have hpowγ : 0 < D^γ := Real.rpow_pos_of_pos hD0 _
  have hden : 0 < c*D^γ := mul_pos hc hpowγ
  have hlog0 : 0 ≤ logb 2 r := (Real.logb_pos (by norm_num) (by linarith)).le
  have hlogR : logb 2 r ≤ β*D^(δ/4) := by
    have hh := Real.logb_le_logb_of_le (by norm_num : (1:ℝ) < 2)
      (by linarith : 0 < r) hrD
    rw [Real.logb_rpow_eq_mul_logb_of_pos hD0] at hh
    exact hh.trans (mul_le_mul_of_nonneg_left hlog hβ.le)
  have hratio : r/(c*D^γ) ≤ D^(β-γ)/c := by
    calc
      _ ≤ D^β/(c*D^γ) := div_le_div_of_nonneg_right hrD hden.le
      _ = _ := by rw [Real.rpow_sub hD0]; ring
  have hsq : (logb 2 r)^2 ≤ β^2*D^(δ/2) := by
    calc
      _ ≤ (β*D^(δ/4))^2 := pow_le_pow_left₀ hlog0 hlogR 2
      _ = _ := by rw [mul_pow, ← Real.rpow_mul_natCast hD0.le]; congr 2; ring
  calc
    (routingLength r (c*D^γ) : ℝ) ≤ 108*(r/(c*D^γ))*(logb 2 r)^2 :=
      routing_length_upper r (c*D^γ) hr hden hhr
    _ ≤ 108*(D^(β-γ)/c)*(β^2*D^(δ/2)) := by gcongr
    _ = (108*β^2/c)*D^(β-γ+δ/2) := by rw [Real.rpow_add hD0]; ring
    _ ≤ D^(δ/2)*D^(β-γ+δ/2) :=
      mul_le_mul_of_nonneg_right hconst (Real.rpow_nonneg hD0.le _)
    _ = D^(β-γ+δ) := by rw [← Real.rpow_add hD0]; congr 1; ring

theorem batch_routing_margin : ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀,
    ∀ r : ℝ, D^(9/10:ℝ) ≤ r → r ≤ D^(51/50:ℝ) →
    2 ≤ r ∧ 64*((routingLength r (D^(9/10:ℝ)/4) : ℝ)^2*
      (D^(1/100:ℝ)+D^(3/10:ℝ))+2*D^(3/10:ℝ)) ≤ D^(9/10:ℝ)/4 := by
  have hev : ∀ᶠ D : ℝ in atTop, ∀ r : ℝ, D^(9/10:ℝ) ≤ r → r ≤ D^(51/50:ℝ) →
      2 ≤ r ∧ 64*((routingLength r (D^(9/10:ℝ)/4) : ℝ)^2*
        (D^(1/100:ℝ)+D^(3/10:ℝ))+2*D^(3/10:ℝ)) ≤ D^(9/10:ℝ)/4 := by
    filter_upwards [eventually_routing_length (1/4) (51/50) (9/10) (2/25)
      (by norm_num) (by norm_num) (by norm_num),
      eventually_const_mul_power_le 1024 (7/10) (9/10) (by norm_num),
      eventually_constant_le_power 2 (9/10) (by norm_num),
      eventually_gt_atTop (1:ℝ)] with D hlen hcost htwo hD r hr hrD
    have hD0 : 0 < D := by linarith
    have hr2 : 2 ≤ r := htwo.trans hr
    have hh : (1/4)*D^(9/10:ℝ) ≤ r := by
      have hh0 := Real.rpow_nonneg hD0.le (9/10:ℝ)
      linarith
    have hL := hlen r hr2 hrD hh
    norm_num at hL
    have hL' : (routingLength r (D^(9/10:ℝ)/4) : ℝ) ≤ D^(1/5:ℝ) := by
      convert hL using 1 ; ring_nf
    have hsmall : D^(1/100:ℝ) ≤ D^(3/10:ℝ) := Real.rpow_le_rpow_of_exponent_le hD.le (by norm_num)
    have h37 : D^(3/10:ℝ) ≤ D^(7/10:ℝ) := Real.rpow_le_rpow_of_exponent_le hD.le (by norm_num)
    have hprod : (routingLength r (D^(9/10:ℝ)/4) : ℝ)^2*
        (D^(1/100:ℝ)+D^(3/10:ℝ)) ≤ 2*D^(7/10:ℝ) := by
      calc
        _ ≤ (D^(1/5:ℝ))^2 * (2*D^(3/10:ℝ)) := by gcongr; linarith
        _ = _ := by
          rw [← Real.rpow_mul_natCast hD0.le]
          norm_num
          rw [mul_left_comm, ← Real.rpow_add hD0]
          norm_num
    refine ⟨hr2, ?_⟩
    nlinarith only [hprod, h37, hcost]
  obtain ⟨A,hA⟩ := eventually_atTop.mp hev
  refine ⟨max A 2, lt_of_lt_of_le (by norm_num) (le_max_right _ _), ?_⟩
  intro D hD
  exact hA D ((le_max_left _ _).trans hD)

lemma eventually_reservoir_capacity (c p : ℝ) (hc : 0 < c) (hp : 0 < p) :
    ∀ᶠ D : ℝ in atTop, ∀ r : ℝ, 0 ≤ r → r ≤ D^(51/50:ℝ) →
      (⌈8*r/(p*(c*D^(9/10:ℝ)))⌉₊ : ℝ) ≤ D^(13/100:ℝ) := by
  filter_upwards [eventually_const_mul_power_le (8/(p*c)+1) (3/25) (13/100) (by norm_num),
    eventually_gt_atTop (1:ℝ)] with D hbound hD r hr hrD
  have hD0 : 0 < D := by linarith
  have hden : 0 < p*(c*D^(9/10:ℝ)) := by positivity
  have hone : 1 ≤ D^(3/25:ℝ) := Real.one_le_rpow hD.le (by norm_num)
  have hx : 8*r/(p*(c*D^(9/10:ℝ))) ≤ (8/(p*c))*D^(3/25:ℝ) := by
    calc
      _ ≤ 8*D^(51/50:ℝ)/(p*(c*D^(9/10:ℝ))) := by gcongr
      _ = _ := by
        have heq : D^(3/25:ℝ) = D^(51/50:ℝ)/D^(9/10:ℝ) := by
          rw [← Real.rpow_sub hD0]; norm_num
        rw [heq]; ring
  have hceil := Nat.ceil_lt_add_one (show 0 ≤ 8*r/(p*(c*D^(9/10:ℝ))) by positivity)
  nlinarith only [hx, hceil, hone, hbound]

theorem residue_routing_margin (c p : ℝ) (hc : 0 < c) (hp : 0 < p) :
    ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀, ∀ r rᵢ : ℝ,
      0 ≤ r → r ≤ D^(51/50:ℝ) → 2 ≤ rᵢ → rᵢ ≤ r → D^(37/50:ℝ) ≤ rᵢ →
      64*((routingLength rᵢ (D^(37/50:ℝ)) : ℝ)^2*
        ((⌈8*r/(p*(c*D^(9/10:ℝ)))⌉₊ : ℝ)+1)) ≤ D^(37/50:ℝ) := by
  have hev : ∀ᶠ D : ℝ in atTop, ∀ r rᵢ : ℝ,
      0 ≤ r → r ≤ D^(51/50:ℝ) → 2 ≤ rᵢ → rᵢ ≤ r → D^(37/50:ℝ) ≤ rᵢ →
      64*((routingLength rᵢ (D^(37/50:ℝ)) : ℝ)^2*
        ((⌈8*r/(p*(c*D^(9/10:ℝ)))⌉₊ : ℝ)+1)) ≤ D^(37/50:ℝ) := by
    filter_upwards [eventually_routing_length 1 (51/50) (37/50) (1/100)
      (by norm_num) (by norm_num) (by norm_num),
      eventually_reservoir_capacity c p hc hp,
      eventually_const_mul_power_le 128 (71/100) (37/50) (by norm_num),
      eventually_gt_atTop (1:ℝ)] with D hlen hcap hcost hD r rᵢ hr hrD hri2 hrir htau
    have hD0 : 0 < D := by linarith
    have hL := hlen rᵢ hri2 (hrir.trans hrD) (by simpa using htau)
    norm_num at hL
    have hk := hcap r hr hrD
    have hone : 1 ≤ D^(13/100:ℝ) := Real.one_le_rpow hD.le (by norm_num)
    have hprod : (routingLength rᵢ (D^(37/50:ℝ)) : ℝ)^2*
        ((⌈8*r/(p*(c*D^(9/10:ℝ)))⌉₊ : ℝ)+1) ≤ 2*D^(71/100:ℝ) := by
      calc
        _ ≤ (D^(29/100:ℝ))^2 * (2*D^(13/100:ℝ)) := by gcongr; linarith
        _ = _ := by
          rw [← Real.rpow_mul_natCast hD0.le]
          norm_num
          rw [mul_left_comm, ← Real.rpow_add hD0]
          norm_num
    nlinarith only [hprod, hcost]
  obtain ⟨A,hA⟩ := eventually_atTop.mp hev
  refine ⟨max A 2, lt_of_lt_of_le (by norm_num) (le_max_right _ _), ?_⟩
  intro D hD
  exact hA D ((le_max_left _ _).trans hD)

end
end ErdosGallai.Batch

namespace ErdosGallai.Batch
noncomputable section
open Finset
attribute [local instance] Classical.propDecidable

variable {V : Type} [Fintype V] [DecidableEq V]

def CutExpansionOn (P : SimpleGraph V) [DecidableRel P.Adj] (W : Finset V) (h : ℝ) : Prop :=
  ∀ A : Finset V, A ⊆ W → h * min (A.card : ℝ) ((W \ A).card : ℝ) ≤
    ((P.interedges A (W \ A)).card : ℝ)

lemma subtype_image_compl {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (W : Finset V) (U : Finset (W : Set V)) :
    Uᶜ.image Subtype.val = W \ U.image Subtype.val := by
  ext v
  simp only [Finset.mem_image, Finset.mem_compl, Finset.mem_sdiff]
  constructor
  · rintro ⟨x,hx,rfl⟩
    refine ⟨x.property,?_⟩
    rintro ⟨y,hy,he⟩
    exact hx (Subtype.ext he ▸ hy)
  · rintro ⟨hv,hvU⟩
    refine ⟨⟨v,hv⟩,?_,rfl⟩
    intro hx
    exact hvU ⟨⟨v,hv⟩,hx,rfl⟩

lemma induced_interedges_card (P : SimpleGraph V) [DecidableRel P.Adj]
    (W : Finset V) (U : Finset (W : Set V)) :
    (((P.induce (W : Set V)).interedges U Uᶜ).card : ℝ) =
      ((P.interedges (U.image Subtype.val) (W \ U.image Subtype.val)).card : ℝ) := by
  classical
  let f : ↥(W : Set V) × ↥(W : Set V) → V × V := fun e => (e.1.val,e.2.val)
  have hf : Function.Injective f := by
    intro a b h
    apply Prod.ext <;> apply Subtype.ext
    · exact congrArg Prod.fst h
    · exact congrArg Prod.snd h
  have heq : ((P.induce (W : Set V)).interedges U Uᶜ).image f =
      P.interedges (U.image Subtype.val) (W \ U.image Subtype.val) := by
    rw [← subtype_image_compl W U]
    ext e
    simp only [SimpleGraph.mem_interedges_iff, Finset.mem_image]
    constructor
    · rintro ⟨a,⟨ha,hb,hab⟩,rfl⟩
      exact ⟨⟨a.1,ha,rfl⟩,⟨a.2,hb,rfl⟩,hab⟩
    · rintro ⟨⟨x,hx,hxe⟩,⟨y,hy,hye⟩,he⟩
      refine ⟨(x,y),⟨hx,hy,?_⟩,Prod.ext hxe hye⟩
      change P.Adj x.val y.val
      simpa only [hxe,hye] using he
  rw [← heq, Finset.card_image_of_injective _ hf]

lemma cutExpansion_induce (P : SimpleGraph V) [DecidableRel P.Adj]
    (W : Finset V) (h : ℝ) (hexp : CutExpansionOn P W h) :
    CutExpansion (P.induce (W : Set V)) h := by
  classical
  intro U
  have hsub : U.image Subtype.val ⊆ W := by
    rintro v hv
    obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hv
    exact a.property
  have h := hexp (U.image Subtype.val) hsub
  have he : W \ U.image Subtype.val = Uᶜ.image Subtype.val :=
    (subtype_image_compl W U).symm
  rw [he] at h
  simp only [Finset.card_image_of_injective _ Subtype.val_injective] at h
  rw [induced_interedges_card,he]
  exact h

lemma pathInterior_map {A B : Type} [DecidableEq A] [DecidableEq B]
    {H : SimpleGraph A} {J : SimpleGraph B} (f : H →g J)
    (hf : Function.Injective f) {a b : A} (p : H.Walk a b) :
    pathInterior (p.map f) = (pathInterior p).image f := by
  classical
  simp only [pathInterior, SimpleGraph.Walk.support_map]
  rw [Finset.image_sdiff _ _ hf]
  have hm : (p.support.map f).toFinset = p.support.toFinset.image f := by
    ext v; simp
  rw [hm]
  simp

theorem team_routing_on_set {I T : Type} [Fintype I]
    (G P : SimpleGraph V) [DecidableRel P.Adj] (hPG : P ≤ G)
    (W : Finset V) (h : ℝ) (hh : 0 < h)
    (hexp : CutExpansionOn P W h) (hr : 2 ≤ W.card)
    (x y : I → V) (hx : ∀ i, x i ∈ W) (hy : ∀ i, y i ∈ W)
    (hxy : ∀ i, x i ≠ y i) (team : I → T) (Z : I → Finset V)
    (k b z : ℝ) (hk : 1 ≤ k) (hb : 1 ≤ b) (hz : 0 ≤ z)
    (hload : ∀ v, (endpointLoad univ x y v : ℝ) ≤ k)
    (hteam : ∀ i, ((univ.filter (fun j => team j = team i)).card : ℝ) ≤ b)
    (hZ : ∀ i, ((Z i).card : ℝ) ≤ z)
    (hbudget : 64 * ((routingLength W.card h : ℝ)^2 * (k+b) + z) ≤ h) :
    ∃ q : ∀ i, G.Walk (x i) (y i),
      (∀ i, (q i).IsPath ∧ (q i).length ≤ routingLength W.card h ∧
        (∀ v ∈ (q i).support, v ∈ W) ∧ (q i).edgeSet ⊆ P.edgeSet ∧
        Disjoint (pathInterior (q i)) (Z i)) ∧
      Pairwise (fun i j => Disjoint (q i).edgeSet (q j).edgeSet) ∧
      (∀ i j, i ≠ j → team i = team j →
        Disjoint (pathInterior (q i)) (pathInterior (q j))) := by
  classical
  let X : I → (W : Set V) := fun i => ⟨x i,hx i⟩
  let Y : I → (W : Set V) := fun i => ⟨y i,hy i⟩
  let Z' : I → Finset (W : Set V) := fun i => univ.filter (fun v => v.val ∈ Z i)
  have hl (v : (W : Set V)) : (endpointLoad univ X Y v : ℝ) ≤ k := by
    simpa only [endpointLoad,X,Y,Subtype.ext_iff] using hload v.val
  have hz' : ∀ i, ((Z' i).card : ℝ) ≤ z := by
    intro i
    apply le_trans _ (hZ i)
    have hc : (Z' i).card ≤ (Z i).card := by
      apply Finset.card_le_card_of_injOn Subtype.val
      · intro v hv; exact (Finset.mem_filter.mp hv).2
      · exact Subtype.val_injective.injOn
    exact_mod_cast hc
  obtain ⟨q,hq,hd,ht⟩ := routing (P.induce (W : Set V)) h hh
    (cutExpansion_induce P W h hexp) (by simpa using hr) X Y
    (fun i he => hxy i (congrArg Subtype.val he)) team Z' k b z hk hb hz hl hteam hz'
    (by simpa using hbudget)
  let f : (P.induce (W : Set V)) →g G :=
    { toFun := Subtype.val, map_rel' := fun ha => hPG ha }
  have hf : Function.Injective f := Subtype.val_injective
  have hcard : Fintype.card ↥(W : Set V) = W.card := Fintype.card_coe W
  let Q : ∀ i, G.Walk (x i) (y i) := fun i => (q i).map f
  refine ⟨Q,?_,?_,?_⟩
  · intro i
    refine ⟨(hq i).1.map hf,?_,?_,?_,?_⟩
    · simpa only [Q,SimpleGraph.Walk.length_map,hcard] using (hq i).2.1
    · intro v hv
      have hv' : v ∈ (q i).support.map f := by simpa only [Q,SimpleGraph.Walk.support_map] using hv
      obtain ⟨a,ha,rfl⟩ := List.mem_map.mp hv'
      exact a.property
    · intro e he
      rw [SimpleGraph.Walk.edgeSet_map] at he
      obtain ⟨d,hd,rfl⟩ := he
      induction d using Sym2.ind with
      | _ a b => exact (q i).adj_of_mem_edges hd
    · rw [show Q i = (q i).map f from rfl, pathInterior_map f hf]
      apply Finset.disjoint_left.mpr
      intro v hv hzv
      obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hv
      exact Finset.disjoint_left.mp (hq i).2.2 ha (by simpa [Z',f] using hzv)
  · intro i j hij
    change Disjoint ((q i).map f).edgeSet ((q j).map f).edgeSet
    rw [SimpleGraph.Walk.edgeSet_map,SimpleGraph.Walk.edgeSet_map,
      Set.disjoint_image_iff (Sym2.map.injective hf)]
    apply Set.disjoint_left.mpr
    intro e he he'
    exact Finset.disjoint_left.mp (hd i j hij) (by simpa using he) (by simpa using he')
  · intro i j hij hteam'
    change Disjoint (pathInterior ((q i).map f)) (pathInterior ((q j).map f))
    rw [pathInterior_map f hf,pathInterior_map f hf,Finset.disjoint_image hf]
    exact ht i j hij hteam'

theorem uniform_batch_routing :
    ∃ D₀ : ℝ, 1 < D₀ ∧ ∀ D ≥ D₀,
      ∀ (A : Type) [Fintype A] [DecidableEq A],
      ∀ (G P : SimpleGraph A) [DecidableRel P.Adj], P ≤ G →
      ∀ W : Finset A, CutExpansionOn P W (D^(9/10:ℝ)/4) →
      D^(9/10:ℝ) ≤ (W.card : ℝ) → (W.card : ℝ) ≤ D^(51/50:ℝ) →
      ∀ (I T : Type) [Fintype I] (x y : I → A),
      (∀ i, x i ∈ W) → (∀ i, y i ∈ W) → (∀ i, x i ≠ y i) →
      ∀ (team : I → T) (Z : I → Finset A),
      (∀ v, (endpointLoad univ x y v : ℝ) ≤ D^(1/100:ℝ)) →
      (∀ i, ((univ.filter (fun j => team j = team i)).card : ℝ) ≤ D^(3/10:ℝ)) →
      (∀ i, ((Z i).card : ℝ) ≤ 2*D^(3/10:ℝ)) →
      ∃ q : ∀ i, G.Walk (x i) (y i),
        (∀ i, (q i).IsPath ∧ (q i).length ≤ routingLength W.card (D^(9/10:ℝ)/4) ∧
          (∀ v ∈ (q i).support, v ∈ W) ∧ (q i).edgeSet ⊆ P.edgeSet ∧
          Disjoint (pathInterior (q i)) (Z i)) ∧
        Pairwise (fun i j => Disjoint (q i).edgeSet (q j).edgeSet) ∧
        (∀ i j, i ≠ j → team i = team j →
          Disjoint (pathInterior (q i)) (pathInterior (q j))) := by
  obtain ⟨D₀,hD₀,hm⟩ := batch_routing_margin
  refine ⟨D₀,hD₀,?_⟩
  intro D hD A _ _ G P _ hPG W hexp hr₁ hr₂ I T _ x y hx hy hxy team Z hl ht hZ
  have hD1 : 1 < D := hD₀.trans_le hD
  have hD0 : 0 < D := lt_trans zero_lt_one hD1
  obtain ⟨hr,hbudget⟩ := hm D hD W.card hr₁ hr₂
  apply team_routing_on_set G P hPG W _ (by positivity) hexp (by exact_mod_cast hr)
    x y hx hy hxy team Z _ _ _ _ _ (by positivity) hl ht hZ hbudget
  · exact Real.one_le_rpow hD1.le (by norm_num)
  · exact Real.one_le_rpow hD1.le (by norm_num)

end
end ErdosGallai.Batch

namespace ErdosGallai.Batch
open SimpleGraph

variable {V : Type cycleUniverse1} {G : SimpleGraph V}

structure CycleVisit (G : SimpleGraph V) where
  start : V
  finish : V
  walk : G.Walk start finish

inductive VisitChain (G : SimpleGraph V) : V → V → Type _
  | single {u v : V} (p : G.Walk u v) : VisitChain G u v
  | cons {u v w z : V} (p : G.Walk u v) (h : G.Adj v w)
      (q : VisitChain G w z) : VisitChain G u z

namespace VisitChain

variable {u v : V}

def walk : {u v : V} → VisitChain G u v → G.Walk u v
  | _, _, .single p => p
  | _, _, .cons p h q => p.append (.cons h q.walk)

def visits : {u v : V} → VisitChain G u v → List (CycleVisit G)
  | u, v, .single p => [⟨u,v,p⟩]
  | u, _, .cons (v := v) p _ q => ⟨u,v,p⟩ :: q.visits

def links : {u v : V} → VisitChain G u v → Set (Sym2 V)
  | _, _, .single _ => ∅
  | _, _, .cons (v := v) (w := w) _ _ q => {s(v,w)} ∪ q.links

def switchEdges (q : VisitChain G u v) : Set (Sym2 V) :=
  ⋃ p ∈ q.visits, p.walk.edgeSet

lemma mem_support_iff (q : VisitChain G u v) (x : V) :
    x ∈ q.walk.support ↔ ∃ p ∈ q.visits, x ∈ p.walk.support := by
  induction q with
  | single p => simp [walk, visits]
  | cons p h q ih =>
    simp only [walk, Walk.mem_support_append_iff, Walk.support_cons, List.mem_cons,
      ih, visits, List.mem_cons]
    constructor
    · rintro (hp | rfl | ⟨r,hr,hx⟩)
      · exact ⟨_, Or.inl rfl, hp⟩
      · exact ⟨_, Or.inl rfl, p.end_mem_support⟩
      · exact ⟨r, Or.inr hr, hx⟩
    · rintro ⟨r, rfl | hr, hx⟩
      · exact Or.inl hx
      · exact Or.inr (Or.inr ⟨r,hr,hx⟩)

lemma isPath_of_separated (q : VisitChain G u v)
    (hp : ∀ p ∈ q.visits, p.walk.IsPath)
    (hd : q.visits.Pairwise (fun p r => p.walk.support.Disjoint r.walk.support)) :
    q.walk.IsPath := by
  induction q with
  | single p => exact hp ⟨_,_,p⟩ (by simp [visits])
  | cons p h q ih =>
    have hpd := (List.pairwise_cons.mp hd).1
    have hqt := ih (fun r hr => hp r (by simp [visits, hr]))
      (List.pairwise_cons.mp hd).2
    have hpt := hp ⟨_,_,p⟩ (by simp [visits])
    have hdisj : p.support.Disjoint q.walk.support := by
      rw [List.disjoint_left]
      intro x hx hqx
      obtain ⟨r,hr,hxr⟩ := q.mem_support_iff x |>.mp hqx
      exact hpd r hr hx hxr
    apply Walk.IsPath.mk'
    simpa only [walk, Walk.support_append, Walk.support_cons, List.tail_cons]
      using (List.nodup_append').mpr ⟨hpt.support_nodup, hqt.support_nodup, hdisj⟩

lemma length_visits_le (q : VisitChain G u v) : q.visits.length ≤ q.walk.length + 1 := by
  induction q with
  | single p => simp [visits, walk]
  | cons p h q ih => simp only [visits, List.length_cons, walk, Walk.length_append,
      Walk.length_cons]; omega

lemma edgeSet_eq (q : VisitChain G u v) :
    q.walk.edgeSet = q.links ∪ q.switchEdges := by
  induction q with
  | single p => simp [walk, links, switchEdges, visits]
  | cons p h q ih =>
    simp only [walk, Walk.edgeSet_append, Walk.edgeSet_cons, ih, links,
      switchEdges, visits]
    ext e
    simp only [Set.mem_union, Set.mem_singleton_iff, Set.mem_insert_iff,
      Set.mem_iUnion, List.mem_cons, exists_prop, or_and_right, exists_or, exists_eq_left]
    tauto

theorem close_cycle (q : VisitChain G u v) (hc : G.Adj v u)
    (hp : ∀ p ∈ q.visits, p.walk.IsPath)
    (hd : q.visits.Pairwise (fun p r => p.walk.support.Disjoint r.walk.support))
    (hn : 3 ≤ q.visits.length) :
    (Walk.cons hc q.walk).IsCycle ∧
    (Walk.cons hc q.walk).edgeSet = {s(v,u)} ∪ q.links ∪ q.switchEdges ∧
    3 ≤ (Walk.cons hc q.walk).length := by
  have hpath := q.isPath_of_separated hp hd
  have hlength := q.length_visits_le
  have he : s(v,u) ∉ q.walk.edges := by
    intro he
    have hh := hpath.length_eq_one_of_mem_edges (Sym2.eq_swap ▸ he)
    omega
  refine ⟨Path.cons_isCycle ⟨q.walk,hpath⟩ hc he, ?_, ?_⟩
  · rw [Walk.edgeSet_cons, q.edgeSet_eq]
    ext e
    simp only [Set.mem_union, Set.mem_insert_iff, Set.mem_singleton_iff]
    tauto
  · simp only [Walk.length_cons]
    omega

end VisitChain

namespace CycleVisit

def ends (p : CycleVisit G) : Set V := {p.start, p.finish}
def interior (p : CycleVisit G) : Set V := {x | x ∈ p.walk.support} \ p.ends

lemma separated_of_interiors (p q : CycleVisit G)
    (he : Disjoint p.ends q.ends)
    (hpq : Disjoint p.interior q.ends) (hqp : Disjoint q.interior p.ends)
    (hi : Disjoint p.interior q.interior) :
    p.walk.support.Disjoint q.walk.support := by
  rw [List.disjoint_left]
  intro x hx hy
  by_cases hpx : x ∈ p.ends
  · by_cases hqx : x ∈ q.ends
    · exact Set.disjoint_left.mp he hpx hqx
    · exact Set.disjoint_left.mp hqp ⟨hy,hqx⟩ hpx
  · by_cases hqx : x ∈ q.ends
    · exact Set.disjoint_left.mp hpq ⟨hx,hpx⟩ hqx
    · exact Set.disjoint_left.mp hi ⟨hx,hpx⟩ ⟨hy,hqx⟩

end CycleVisit

theorem quotient_cycle_inflation {u v : V} (q : VisitChain G u v) (hc : G.Adj v u)
    (hp : ∀ p ∈ q.visits, p.walk.IsPath)
    (he : q.visits.Pairwise (fun p r => Disjoint p.ends r.ends))
    (hf : ∀ p ∈ q.visits, ∀ r ∈ q.visits, Disjoint p.interior r.ends)
    (hi : q.visits.Pairwise (fun p r => Disjoint p.interior r.interior))
    (hn : 3 ≤ q.visits.length) :
    (Walk.cons hc q.walk).IsCycle ∧
    (Walk.cons hc q.walk).edgeSet = {s(v,u)} ∪ q.links ∪ q.switchEdges ∧
    3 ≤ (Walk.cons hc q.walk).length := by
  apply q.close_cycle hc hp _ hn
  have hh := he.and hi
  apply hh.imp_of_mem
  intro p r hpm hrm hpr
  exact p.separated_of_interiors r hpr.1 (hf p hpm r hrm) (hf r hrm p hpm) hpr.2

namespace VisitChain
variable {W : Type cycleUniverse2} {Q : SimpleGraph W}

def of_walk (s t : W → V) (q : ∀ z, G.Walk (s z) (t z)) :
    {a b : W} → (p : Q.Walk a b) →
    (∀ d ∈ p.darts, G.Adj (t d.fst) (s d.snd)) → VisitChain G (s a) (t b)
  | _, _, .nil, _ => .single (q _)
  | a, b, .cons (v := c) h p, hr => .cons (q a)
      (hr ⟨(a,c),h⟩ (by simp))
      (of_walk s t q p (by intro d hd; exact hr d (by simp [hd])))

lemma of_walk_visits (s t : W → V) (q : ∀ z, G.Walk (s z) (t z))
    {a b : W} (p : Q.Walk a b)
    (hr : ∀ d ∈ p.darts, G.Adj (t d.fst) (s d.snd)) :
    (of_walk s t q p hr).visits = p.support.map (fun z => (⟨s z,t z,q z⟩ : CycleVisit G)) := by
  induction p with
  | nil => rfl
  | cons h p ih => simp [of_walk, visits, ih]

lemma of_walk_links (s t : W → V) (q : ∀ z, G.Walk (s z) (t z))
    {a b : W} (p : Q.Walk a b)
    (hr : ∀ d ∈ p.darts, G.Adj (t d.fst) (s d.snd)) :
    (of_walk s t q p hr).links = {e | ∃ d ∈ p.darts, e = s(t d.fst,s d.snd)} := by
  induction p with
  | nil => ext e; simp [of_walk, links]
  | cons h p ih =>
    ext e
    simp [of_walk, links, ih,  ]

lemma of_walk_switchEdges (s t : W → V) (q : ∀ z, G.Walk (s z) (t z))
    {a b : W} (p : Q.Walk a b)
    (hr : ∀ d ∈ p.darts, G.Adj (t d.fst) (s d.snd)) :
    (of_walk s t q p hr).switchEdges = ⋃ z ∈ p.support, (q z).edgeSet := by
  rw [switchEdges, of_walk_visits]
  ext e
  simp only [Set.mem_iUnion, List.mem_map, exists_prop]
  constructor
  · rintro ⟨r,⟨z,hz,rfl⟩,he⟩
    exact ⟨z,hz,he⟩
  · rintro ⟨z,hz,he⟩
    exact ⟨⟨s z,t z,q z⟩,⟨z,hz,rfl⟩,he⟩

end VisitChain

theorem lift_quotient_cycle {W : Type cycleUniverse3} {Q : SimpleGraph W}
    (s t : W → V) (q : ∀ z, G.Walk (s z) (t z))
    {a : W} (p : Q.Walk a a) (hp : p.IsCycle)
    (hr : ∀ d ∈ p.dropLast.darts, G.Adj (t d.fst) (s d.snd))
    (hc : G.Adj (t p.penultimate) (s a))
    (hq : ∀ z ∈ p.dropLast.support, (q z).IsPath)
    (hsep : ∀ z ∈ p.dropLast.support, ∀ w ∈ p.dropLast.support,
      z ≠ w → (q z).support.Disjoint (q w).support) :
    ∃ c : G.Walk (t p.penultimate) (t p.penultimate), c.IsCycle ∧
      c.edgeSet = {s(t p.penultimate,s a)} ∪
        {e | ∃ d ∈ p.dropLast.darts, e = s(t d.fst,s d.snd)} ∪
        (⋃ z ∈ p.dropLast.support, (q z).edgeSet) := by
  let chain := VisitChain.of_walk s t q p.dropLast hr
  have hv : chain.visits = p.dropLast.support.map (fun z => (⟨s z,t z,q z⟩ : CycleVisit G)) :=
    VisitChain.of_walk_visits s t q p.dropLast hr
  have hpaths : ∀ v ∈ chain.visits, v.walk.IsPath := by
    intro v hvv
    rw [hv] at hvv
    obtain ⟨z,hz,rfl⟩ := List.mem_map.mp hvv
    exact hq z hz
  have hpair : chain.visits.Pairwise (fun v w => v.walk.support.Disjoint w.walk.support) := by
    rw [hv, List.pairwise_map]
    apply (List.pairwise_iff_getElem).mpr
    intro i j hi hj hij
    have hne : p.dropLast.support[i] ≠ p.dropLast.support[j] := by
      intro he
      have hij' := hp.isPath_dropLast.support_nodup.getElem_inj_iff.mp he
      omega
    exact hsep _ (List.getElem_mem _) _ (List.getElem_mem _) hne
  have hn : 3 ≤ chain.visits.length := by
    rw [hv, List.length_map, Walk.length_support, Walk.length_dropLast]
    have := hp.three_le_length
    omega
  obtain ⟨hcycle,hedges,_⟩ := chain.close_cycle hc hpaths hpair hn
  refine ⟨Walk.cons hc chain.walk,hcycle,?_⟩
  rw [hedges, VisitChain.of_walk_links, VisitChain.of_walk_switchEdges]

noncomputable section
attribute [local instance] Classical.propDecidable

theorem orient_edge_representatives {W : Type cycleUniverse4} {Q : SimpleGraph W}
    (projMap : V → W) (S : Set (Sym2 V)) (hSG : S ⊆ G.edgeSet)
    (hrep : ∀ e ∈ Q.edgeSet, ∃ f ∈ S, Sym2.map projMap f = e) :
    ∃ R : Q.Dart → G.Dart, ∀ d,
      (R d).edge ∈ S ∧ projMap (R d).fst = d.fst ∧ projMap (R d).snd = d.snd := by
  have hex : ∀ d : Q.Dart, ∃ r : G.Dart,
      r.edge ∈ S ∧ projMap r.fst = d.fst ∧ projMap r.snd = d.snd := by
    intro d
    obtain ⟨f,hf,hmap⟩ := hrep d.edge d.edge_mem
    induction f using Sym2.ind with
    | _ x y =>
      have hadj : G.Adj x y := hSG hf
      change s(projMap x,projMap y) = s(d.fst,d.snd) at hmap
      rcases Sym2.eq_iff.mp hmap with he | he
      · exact ⟨⟨(x,y),hadj⟩,hf,he.1,he.2⟩
      · refine ⟨⟨(y,x),hadj.symm⟩,?_,he.2,he.1⟩
        change s(y,x) ∈ S
        simpa only [Sym2.eq_swap] using hf
  exact Classical.axiomOfChoice hex

def portFrom {A : Type cycleUniverse5} {W : Type cycleUniverse6} (L : List A) (f : A → W) (g : A → V)
    (v₀ : V) (z : W) : V :=
  if h : ∃ d ∈ L, f d = z then g h.choose else v₀

lemma portFrom_on {A : Type cycleUniverse7} {W : Type cycleUniverse8} (L : List A) (f : A → W) (g : A → V)
    (v₀ : V) (hn : (L.map f).Nodup) {d : A} (hd : d ∈ L) :
    portFrom L f g v₀ (f d) = g d := by
  have hex : ∃ e ∈ L, f e = f d := ⟨d,hd,rfl⟩
  rw [portFrom, dite_eq_left hex]
  congr 1
  exact List.inj_on_of_nodup_map hn hex.choose_spec.1 hd hex.choose_spec.2

theorem choose_cycle_ports {W : Type cycleUniverse9} {Q : SimpleGraph W}
    (projMap : V → W) (R : Q.Dart → G.Dart)
    (hprojMap : ∀ d, projMap (R d).fst = d.fst ∧ projMap (R d).snd = d.snd)
    {a : W} (p : Q.Walk a a) (hp : p.IsCycle) (v₀ : V) :
    ∃ s t : W → V,
      (∀ d ∈ p.darts, t d.fst = (R d).fst ∧ s d.snd = (R d).snd) ∧
      (∀ z ∈ p.dropLast.support, projMap (s z) = z ∧ projMap (t z) = z) := by
  let s := portFrom p.darts (fun d => d.snd) (fun d => (R d).snd) v₀
  let t := portFrom p.darts (fun d => d.fst) (fun d => (R d).fst) v₀
  have hnf : (p.darts.map (fun d => d.fst)).Nodup := by
    rw [Walk.map_fst_darts]
    exact hp.nodup_dropLast_support
  have hns : (p.darts.map (fun d => d.snd)).Nodup := by
    rw [Walk.map_snd_darts]
    exact hp.support_nodup
  have ht : ∀ d ∈ p.darts, t d.fst = (R d).fst := fun d hd =>
    portFrom_on _ _ _ _ hnf hd
  have hs : ∀ d ∈ p.darts, s d.snd = (R d).snd := fun d hd =>
    portFrom_on _ _ _ _ hns hd
  refine ⟨s,t,fun d hd => ⟨ht d hd,hs d hd⟩,?_⟩
  intro z hz
  have hz' : z ∈ p.support.dropLast := by
    rw [← p.support_dropLast hp.not_nil]
    exact hz
  have hzt : z ∈ p.support.tail :=
    p.tail_support_perm_dropLast_support.mem_iff.mpr hz'
  have hzf : z ∈ p.darts.map (fun d => d.fst) := by rwa [Walk.map_fst_darts]
  have hzs : z ∈ p.darts.map (fun d => d.snd) := by rwa [Walk.map_snd_darts]
  obtain ⟨d,hd,he⟩ := List.mem_map.mp hzf
  obtain ⟨e,he',hee⟩ := List.mem_map.mp hzs
  exact ⟨by rw [← hee,hs e he']; exact (hprojMap e).2,
    by rw [← he,ht d hd]; exact (hprojMap d).1⟩

lemma last_dart_mem {W : Type cycleUniverse10} {Q : SimpleGraph W} {a b : W}
    (p : Q.Walk a b) (hp : ¬p.Nil) :
    (⟨(p.penultimate,b),p.adj_penultimate hp⟩ : Q.Dart) ∈ p.darts := by
  have he := congrArg Walk.darts (p.concat_dropLast (p.adj_penultimate hp))
  rw [Walk.darts_concat] at he
  rw [← he]
  simp

lemma cycle_darts_split {W : Type cycleUniverse11} {Q : SimpleGraph W} {a b : W}
    (p : Q.Walk a b) (hp : ¬p.Nil) :
    p.darts = p.dropLast.darts ++ [⟨(p.penultimate,b),p.adj_penultimate hp⟩] := by
  have he := congrArg Walk.darts (p.concat_dropLast (p.adj_penultimate hp))
  simpa only [Walk.darts_concat, List.concat_eq_append] using he.symm

theorem inflate_represented_cycle {W : Type cycleUniverse12} {Q : SimpleGraph W}
    (R : Q.Dart → G.Dart) (s t : W → V)
    {a : W} (p : Q.Walk a a) (hp : p.IsCycle)
    (hports : ∀ d ∈ p.darts, t d.fst = (R d).fst ∧ s d.snd = (R d).snd)
    (q : ∀ z, G.Walk (s z) (t z))
    (hq : ∀ z ∈ p.dropLast.support, (q z).IsPath)
    (hsep : ∀ z ∈ p.dropLast.support, ∀ w ∈ p.dropLast.support,
      z ≠ w → (q z).support.Disjoint (q w).support) :
    ∃ (v : V) (c : G.Walk v v), c.IsCycle ∧
      c.edgeSet = {e | ∃ d ∈ p.darts, e = (R d).edge} ∪
        (⋃ z ∈ p.dropLast.support, (q z).edgeSet) := by
  let last : Q.Dart := ⟨(p.penultimate,a),p.adj_penultimate hp.not_nil⟩
  have hlast : last ∈ p.darts := last_dart_mem p hp.not_nil
  have hsub : p.dropLast.darts ⊆ p.darts := by
    rw [Walk.darts_dropLast]; exact List.dropLast_subset _
  have hed : ∀ d ∈ p.darts, s(t d.fst,s d.snd) = (R d).edge := by
    intro d hd
    rw [(hports d hd).1,(hports d hd).2]
    rfl
  have hadj : ∀ d ∈ p.darts, G.Adj (t d.fst) (s d.snd) := by
    intro d hd
    rw [(hports d hd).1,(hports d hd).2]
    exact (R d).adj
  obtain ⟨c,hc,he⟩ := lift_quotient_cycle s t q p hp
    (fun d hd => hadj d (hsub hd)) (hadj last hlast) hq hsep
  refine ⟨_,c,hc,?_⟩
  rw [he]
  have hlinks : {s(t p.penultimate,s a)} ∪
      {e | ∃ d ∈ p.dropLast.darts, e = s(t d.fst,s d.snd)} =
      {e | ∃ d ∈ p.darts, e = (R d).edge} := by
    ext e
    simp only [Set.mem_union, Set.mem_singleton_iff, Set.mem_ofPred_eq]
    constructor
    · rintro (rfl | ⟨d,hd,rfl⟩)
      · exact ⟨last,hlast,hed last hlast⟩
      · exact ⟨d,hsub hd,hed d (hsub hd)⟩
    · rintro ⟨d,hd,rfl⟩
      rw [cycle_darts_split p hp.not_nil] at hd
      simp only [List.mem_append,List.mem_singleton] at hd
      rcases hd with hd | rfl
      · exact Or.inr ⟨d,hd,(hed d (hsub hd)).symm⟩
      · exact Or.inl (hed last hlast).symm
  rw [hlinks]

theorem interiors_disjoint_across_routers {I : Type cycleUniverse13} {R : Type cycleUniverse14}
    (U : R → Set V) (hi : Pairwise (fun r s => Disjoint (U r) (U s)))
    (router : I → R) (A : I → Set V)
    (hA : ∀ i, A i ⊆ U (router i))
    (hteam : ∀ i j, i ≠ j → router i = router j → Disjoint (A i) (A j)) :
    Pairwise (fun i j => Disjoint (A i) (A j)) := by
  intro i j hij
  by_cases hr : router i = router j
  · exact hteam i j hij hr
  · exact (hi hr).mono (hA i) (hA j)

def cyclePortSet {W : Type cycleUniverse15} (S : Set W) (s t : W → V) : Set V :=
  {v | ∃ z ∈ S, v = s z ∨ v = t z}

def visitInterior {W : Type cycleUniverse16} (s t : W → V) (q : ∀ z, G.Walk (s z) (t z))
    (z : W) : Set V := {x | x ∈ (q z).support ∧ x ≠ s z ∧ x ≠ t z}

theorem switch_supports_separated {W : Type cycleUniverse17}
    (S : Set W) (projMap : V → W) (s t : W → V)
    (q : ∀ z, G.Walk (s z) (t z))
    (hproj : ∀ z ∈ S, projMap (s z) = z ∧ projMap (t z) = z)
    (havoid : ∀ z ∈ S, Disjoint (visitInterior s t q z) (cyclePortSet S s t))
    (hinter : ∀ z ∈ S, ∀ w ∈ S, z ≠ w →
      Disjoint (visitInterior s t q z) (visitInterior s t q w)) :
    ∀ z ∈ S, ∀ w ∈ S, z ≠ w → (q z).support.Disjoint (q w).support := by
  intro z hz w hw hzw
  rw [List.disjoint_left]
  intro x hx hy
  by_cases hxend : x = s z ∨ x = t z
  · have hxZ : x ∈ cyclePortSet S s t := ⟨z,hz,hxend⟩
    by_cases hyend : x = s w ∨ x = t w
    · have hxprojMap : projMap x = z := by rcases hxend with rfl | rfl <;> simp_all
      have hyprojMap : projMap x = w := by rcases hyend with rfl | rfl <;> simp_all
      exact hzw (hxprojMap.symm.trans hyprojMap)
    · exact Set.disjoint_left.mp (havoid w hw)
        ⟨hy,fun he => hyend (Or.inl he),fun he => hyend (Or.inr he)⟩ hxZ
  · have hxI : x ∈ visitInterior s t q z :=
      ⟨hx,fun he => hxend (Or.inl he),fun he => hxend (Or.inr he)⟩
    by_cases hyend : x = s w ∨ x = t w
    · exact Set.disjoint_left.mp (havoid z hz) hxI ⟨w,hw,hyend⟩
    · exact Set.disjoint_left.mp (hinter z hz w hw hzw) hxI
        ⟨hy,fun he => hyend (Or.inl he),fun he => hyend (Or.inr he)⟩

theorem cyclePortSet_eq_representative_vertices {W : Type cycleUniverse18} {Q : SimpleGraph W}
    (R : Q.Dart → G.Dart) (s t : W → V)
    {a : W} (p : Q.Walk a a) (hp : p.IsCycle)
    (hports : ∀ d ∈ p.darts, t d.fst = (R d).fst ∧ s d.snd = (R d).snd) :
    cyclePortSet {z | z ∈ p.dropLast.support} s t =
      {v | ∃ d ∈ p.darts, v = (R d).fst ∨ v = (R d).snd} := by
  have hmF : p.darts.map (fun d => d.fst) = p.dropLast.support := by
    rw [Walk.map_fst_darts, p.support_dropLast hp.not_nil]
  have hmS : ∀ z, z ∈ p.darts.map (fun d => d.snd) ↔ z ∈ p.dropLast.support := by
    intro z
    rw [Walk.map_snd_darts, p.support_dropLast hp.not_nil]
    exact p.tail_support_perm_dropLast_support.mem_iff
  ext v
  constructor
  · rintro ⟨z,hz,hv | hv⟩
    · obtain ⟨d,hd,hds⟩ := List.mem_map.mp ((hmS z).mpr hz)
      exact ⟨d,hd,Or.inr (hv.trans (by rw [← hds]; exact (hports d hd).2))⟩
    · have hz' : z ∈ p.darts.map (fun d => d.fst) := by rwa [hmF]
      obtain ⟨d,hd,hdf⟩ := List.mem_map.mp hz'
      exact ⟨d,hd,Or.inl (hv.trans (by rw [← hdf]; exact (hports d hd).1))⟩
  · rintro ⟨d,hd,hv | hv⟩
    · refine ⟨d.fst,?_,Or.inr (hv.trans (hports d hd).1.symm)⟩
      rw [← hmF]
      exact List.mem_map.mpr ⟨d,hd,rfl⟩
    · exact ⟨d.snd,(hmS _).mp (List.mem_map.mpr ⟨d,hd,rfl⟩),
        Or.inl (hv.trans (hports d hd).2.symm)⟩

theorem complete_batch_cycle {W : Type cycleUniverse19} {Ridx : Type cycleUniverse20} {Q : SimpleGraph W}
    (projMap : V → W) (R : Q.Dart → G.Dart)
    (_hprojMap : ∀ d, projMap (R d).fst = d.fst ∧ projMap (R d).snd = d.snd)
    {a : W} (p : Q.Walk a a) (hp : p.IsCycle)
    (s t : W → V)
    (hports : ∀ d ∈ p.darts, t d.fst = (R d).fst ∧ s d.snd = (R d).snd)
    (hproj : ∀ z ∈ p.dropLast.support, projMap (s z) = z ∧ projMap (t z) = z)
    (q : ∀ z, G.Walk (s z) (t z))
    (hq : ∀ z ∈ p.dropLast.support, (q z).IsPath)
    (U : Ridx → Set V) (hU : Pairwise (fun i j => Disjoint (U i) (U j)))
    (router : {z // z ∈ p.dropLast.support} → Ridx)
    (hroute : ∀ z : {z // z ∈ p.dropLast.support},
      visitInterior s t q z ⊆ U (router z))
    (hteam : ∀ z w : {z // z ∈ p.dropLast.support}, z ≠ w →
      router z = router w → Disjoint (visitInterior s t q z) (visitInterior s t q w))
    (havoid : ∀ z ∈ p.dropLast.support, Disjoint (visitInterior s t q z)
      {v | ∃ d ∈ p.darts, v = (R d).fst ∨ v = (R d).snd}) :
    ∃ (v : V) (c : G.Walk v v), c.IsCycle ∧
      c.edgeSet = {e | ∃ d ∈ p.darts, e = (R d).edge} ∪
        (⋃ z ∈ p.dropLast.support, (q z).edgeSet) := by
  have hinter := interiors_disjoint_across_routers U hU router
    (fun z => visitInterior s t q z) hroute hteam
  apply inflate_represented_cycle R s t p hp hports q hq
  apply switch_supports_separated {z | z ∈ p.dropLast.support} projMap s t q hproj
  · intro z hz
    rw [cyclePortSet_eq_representative_vertices R s t p hp hports]
    exact havoid z hz
  · intro z hz w hw hzw
    exact hinter (show (⟨z,hz⟩ : {z // z ∈ p.dropLast.support}) ≠ ⟨w,hw⟩ from
      fun he => hzw (congrArg Subtype.val he))

end
end ErdosGallai.Batch

end
end
end

end OAI