lean/OAI/Combinatorics/ListHadwiger/Recursion.lean

import OAI.Combinatorics.ListHadwiger.StageSeparation

namespace OAI

namespace LinearListHadwiger.Recursion
open SimpleGraph Finset
attribute [local instance] Classical.propDecidable
variable {V : Type} [Fintype V] [DecidableEq V]

theorem weaving_from_proxy_groups (G : SimpleGraph V) {a p : ℕ}
    (roots : Fin a → V) (x y : Fin p → V) (hr : Function.Injective roots)
    (he : ∀ i j, i ≠ j → Disjoint ({x i,y i} : Set V) {x j,y j})
    (C : (Fin a ⊕ Fin p) → Set V)
    (hC : ∀ i, (G.induce (C i)).Connected)
    (hCC : ∀ i j, i ≠ j → Disjoint (C i) (C j))
    (hroot : ∀ i j, roots j ∉ C i)
    (hx : ∀ i j, x j ∉ C i) (hy : ∀ i j, y j ∉ C i)
    (hclique : ∀ i j, i ≠ j → ∃ v ∈ C (.inl i), ∃ w ∈ C (.inl j), G.Adj v w)
    (hattachRoot : ∀ j, ∃ w ∈ C (.inl j), G.Adj (roots j) w)
    (hattachX : ∀ i, ∃ w ∈ C (.inr i), G.Adj (x i) w)
    (hattachY : ∀ i, ∃ w ∈ C (.inr i), G.Adj (y i) w) :
    Nonempty (WeavingWithin G Set.univ roots x y) := by
  classical
  let bag (j : Fin a) := insert (roots j) (C (.inl j))
  have hb (j : Fin a) : (G.induce (bag j)).Connected := by
    obtain ⟨w,hw,hew⟩ := hattachRoot j
    exact Incidence.connected_insert (hC (.inl j)) hw hew
  have hbd (i j : Fin a) (hij : i ≠ j) : Disjoint (bag i) (bag j) := by
    apply Set.disjoint_left.mpr
    intro v hi hj
    rcases hi with hi | hi <;> rcases hj with hj | hj
    · exact hij (hr (hi.symm.trans hj))
    · exact hroot (.inl j) i (hi ▸ hj)
    · exact hroot (.inl i) j (hj ▸ hi)
    · exact Set.disjoint_left.mp (hCC (.inl i) (.inl j) (by simpa using hij)) hi hj
  let M : RootedCliqueModel G roots :=
    { branch := bag
      connected := hb
      disjoint := hbd
      adjacent := fun i j hij => by
        obtain ⟨v,hv,w,hw,hvw⟩ := hclique i j hij
        exact ⟨v,Or.inr hv,w,Or.inr hw,hvw⟩
      root_mem := fun _ => Or.inl rfl }
  let S (i : Fin p) := insert (x i) (insert (y i) (C (.inr i)))
  have hS (i : Fin p) : (G.induce (S i)).Connected := by
    obtain ⟨w,hw,hew⟩ := hattachY i
    have hh := Incidence.connected_insert (hC (.inr i)) hw hew
    obtain ⟨w,hw,hew⟩ := hattachX i
    exact Incidence.connected_insert hh (Or.inr hw) hew
  have hpaths : ∀ i, ∃ Q : G.Path (x i) (y i), ∀ v ∈ Q.val.support, v ∈ S i :=
    fun i => Assembly.path_in_connected (hS i) (Or.inl rfl) (Or.inr (Or.inl rfl))
  choose Q hQ using hpaths
  refine ⟨⟨M,fun _ _ _ => Set.mem_univ _,Q,fun _ _ _ => Set.mem_univ _,?_,?_⟩⟩
  · intro i j hij
    apply Set.disjoint_left.mpr
    intro v hi hj
    have hi' := hQ i v hi
    have hj' := hQ j v hj
    have hterm : ∀ i k, ∀ v ∈ ({x i,y i} : Set V), v ∉ C k := by
      intro i k v hv
      rcases hv with rfl | hv
      · exact hx k i
      · exact hv ▸ hy k i
    have hsplit : ∀ i v, v ∈ S i → v ∈ ({x i,y i} : Set V) ∨ v ∈ C (.inr i) := by
      intro i v hv
      rcases hv with hv | hv | hv
      · exact Or.inl (Or.inl hv)
      · exact Or.inl (Or.inr hv)
      · exact Or.inr hv
    rcases hsplit i v hi' with hi' | hi' <;> rcases hsplit j v hj' with hj' | hj'
    · exact Set.disjoint_left.mp (he i j hij) hi' hj'
    · exact hterm i (.inr j) v hi' hj'
    · exact hterm j (.inr i) v hj' hi'
    · exact Set.disjoint_left.mp (hCC (.inr i) (.inr j) (by simpa using hij)) hi' hj'
  · intro i j v hv hbag
    have hs := hQ i v hv
    change v ∈ insert (roots j) (C (.inl j)) at hbag
    rcases hs with hs | hs | hs
    · subst v
      rcases hbag with hb | hb
      · exact ⟨⟨j,hb.symm⟩,Or.inl rfl⟩
      · exact (hx (.inl j) i hb).elim
    · subst v
      rcases hbag with hb | hb
      · exact ⟨⟨j,hb.symm⟩,Or.inr rfl⟩
      · exact (hy (.inl j) i hb).elim
    · rcases hbag with hb | hb
      · exact (hroot (.inr i) j (hb ▸ hs)).elim
      · exact (Set.disjoint_left.mp (hCC (.inr i) (.inl j) (by simp)) hs hb).elim

lemma distinct_proxies {O : Type} [Fintype O]
    (G : SimpleGraph V) [DecidableRel G.Adj] (port : O → V) (Z : Finset V)
    {k : ℕ} (hc : KConnectedOn G univ k) (hk : Fintype.card O+Z.card≤k) :
    ∃ nbr : O → V, Function.Injective nbr ∧ ∀ o, nbr o ∉ Z ∧ G.Adj (port o) (nbr o) := by
  classical
  have hn (o : O) : Fintype.card O ≤ ((univ\Z).filter (G.Adj (port o))).card := by
    have hdeg := Knitting.min_degree G hc (mem_univ (port o))
    have he : Density.neighbors G univ (port o) \ Z = (univ\Z).filter (G.Adj (port o)) := by
      ext v
      simp only [Density.neighbors,mem_sdiff,mem_filter,mem_univ,true_and]
      tauto
    have hh := card_le_card (show Density.neighbors G univ (port o) ⊆
      Density.neighbors G univ (port o) \ Z ∪ Z from fun v hv => by
        by_cases hZ : v∈Z
        · exact mem_union_right _ hZ
        · exact mem_union_left _ (mem_sdiff.mpr ⟨hv,hZ⟩))
    have hu := card_union_le (Density.neighbors G univ (port o) \ Z) Z
    rw [he] at hh hu
    omega
  obtain ⟨nbr,hi,hn'⟩ := Assembly.attach_ports (G:=G) port (univ\Z) hn
  exact ⟨nbr,hi,fun o => ⟨(mem_sdiff.mp (hn' o).1).2,(hn' o).2⟩⟩

omit [Fintype V] [DecidableEq V] in

lemma proxy_groups_of_model (G : SimpleGraph V) {a p : ℕ}
    (proxy : Fin a ⊕ (Fin p × Bool) → V)
    (M : RootedCliqueModel G proxy) :
    ∃ C : (Fin a ⊕ Fin p) → Set V,
      (∀ i, (G.induce (C i)).Connected) ∧
      (∀ i j, i ≠ j → Disjoint (C i) (C j)) ∧
      (∀ j, C (.inl j)=M.branch (.inl j)) ∧
      (∀ i, proxy (.inr (i,false))∈C (.inr i) ∧ proxy (.inr (i,true))∈C (.inr i)) ∧
      (∀ i v, v∈C i → ∃ o, v∈M.branch o) := by
  classical
  let C : (Fin a ⊕ Fin p) → Set V := Sum.elim (fun j => M.branch (.inl j))
    (fun i => M.branch (.inr (i,false)) ∪ M.branch (.inr (i,true)))
  have hs (i) (v) (hv : v∈C i) : ∃ o, v∈M.branch o ∧
      (Sum.map id (fun z : Fin p × Bool => z.1) o : Fin a ⊕ Fin p) = i := by
    cases i with
    | inl j => exact ⟨.inl j,hv,rfl⟩
    | inr j =>
      rcases hv with hv|hv
      · exact ⟨.inr (j,false),hv,rfl⟩
      · exact ⟨.inr (j,true),hv,rfl⟩
  refine ⟨C,?_,?_,fun _ => rfl,fun i => ⟨Or.inl (M.root_mem _),Or.inr (M.root_mem _)⟩,?_⟩
  · intro i
    cases i with
    | inl j => exact M.connected (.inl j)
    | inr j =>
      obtain ⟨v,hv,w,hw,he⟩ := M.adjacent (.inr (j,false)) (.inr (j,true)) (by simp)
      exact SimpleGraph.connected_induce_union (M.connected _).preconnected
        (M.connected _).preconnected hv hw he
  · intro i j hij
    apply Set.disjoint_left.mpr
    intro v hi hj
    obtain ⟨o,ho,hoi⟩ := hs i v hi
    obtain ⟨o',ho',hoj⟩ := hs j v hj
    exact Set.disjoint_left.mp (M.disjoint o o' (fun h => hij (hoi.symm.trans (h ▸ hoj)))) ho ho'
  · intro i v hv
    obtain ⟨o,ho,_⟩ := hs i v hv
    exact ⟨o,ho⟩

omit [Fintype V] [DecidableEq V] in
lemma connected_pullback (G : SimpleGraph V) (S B : Set V) (hBS : B⊆S)
    (hc : (G.induce B).Connected) :
    ((G.induce S).induce {v | v.val∈B}).Connected := by
  let f : G.induce B →g (G.induce S).induce {v | v.val∈B} :=
    ⟨fun v => ⟨⟨v.val,hBS v.property⟩,v.property⟩,fun h => h⟩
  refine { preconnected := ?_, nonempty := ?_ }
  · intro u v
    exact (hc.preconnected ⟨u.val.val,u.property⟩ ⟨v.val.val,v.property⟩).map f
  · obtain ⟨v⟩ := hc.nonempty
    exact ⟨f v⟩

lemma hadwiger_delete (G : SimpleGraph V) (Z : Finset V) :
    hadwigerNumber G ≤ hadwigerNumber (G.induce (↑(univ\Z):Set V))+Z.card := by
  classical
  obtain ⟨B,hB,hBB,hE⟩ := hasCliqueMinor_hadwigerNumber G
  let E := univ.filter (fun i => Disjoint (↑Z:Set V) (B i))
  have hn := eligible_bags_card Z B hBB
  change Fintype.card (Fin (hadwigerNumber G))≤E.card+Z.card at hn
  rw [Fintype.card_fin] at hn
  let e : Fin E.card ≃ E := by simpa only [Fintype.card_coe] using (Fintype.equivFin E).symm
  have hBS (i : E) : B i.val ⊆ (↑(univ\Z):Set V) := by
    intro v hv
    exact mem_sdiff.mpr ⟨mem_univ _,fun hz => Set.disjoint_left.mp (mem_filter.mp i.property).2 hz hv⟩
  have hm : HasCliqueMinor (G.induce (↑(univ\Z):Set V)) E.card := by
    refine ⟨fun i => {v | v.val∈B (e i).val},?_,?_,?_⟩
    · intro i
      exact connected_pullback G _ _ (hBS (e i)) (hB (e i).val)
    · intro i j hij
      apply Set.disjoint_left.mpr
      intro v hi hj
      exact Set.disjoint_left.mp (hBB _ _ (fun h => hij (e.injective (Subtype.ext h)))) hi hj
    · intro i j hij
      obtain ⟨v,hv,w,hw,he⟩ := hE _ _ (fun h => hij (e.injective (Subtype.ext h)))
      exact ⟨⟨v,hBS (e i) hv⟩,hv,⟨w,hBS (e j) hw⟩,hw,he⟩
  exact hn.trans (Nat.add_le_add_right (cliqueMinor_le_hadwigerNumber hm) _)

lemma rooting_on {I : Type} [Fintype I] (G : SimpleGraph V) (S : Finset V)
    (r : I → V) (hi : Function.Injective r) (hr : ∀ i, r i∈S)
    (hc : KConnectedOn G S (2*Fintype.card I))
    (hh : 4*Fintype.card I≤hadwigerNumber (G.induce (↑S:Set V))) :
    ∃ M : RootedCliqueModel G r, ∀ i, M.branch i⊆(↑S:Set V) := by
  classical
  let rr : I → (↑S:Set V) := fun i => ⟨r i,hr i⟩
  have hir : Function.Injective rr := fun i j he => hi (congrArg Subtype.val he)
  let A := univ.image rr
  have hac : A.card=Fintype.card I := by simp [A,card_image_of_injective _ hir]
  have har (i) : rr i∈A := mem_image.mpr ⟨i,mem_univ _,rfl⟩
  have hci : KConnectedOn (G.induce (↑S:Set V)) univ (2*A.card) := by
    rw [hac]
    exact Knitting.induce_connected G S hc
  have hhi : 4*A.card≤hadwigerNumber (G.induce (↑S:Set V)) := by simpa only [hac] using hh
  obtain ⟨M⟩ := rooting (G.induce (↑S:Set V)) A hci hhi
  let f : I → A := fun i => ⟨rr i,har i⟩
  have hif : Function.Injective f := fun _ _ he => hir (congrArg Subtype.val he)
  let N := M.reindex f hif
  let D := Knitting.model_induce G S
  let B (i : I) := D.expand (N.branch i)
  have hB (i) : B i⊆(↑S:Set V) := by
    rintro v ⟨w,_,hw⟩
    have he : v=w.val := hw
    exact he ▸ w.property
  refine ⟨⟨B,fun i => D.expand_connected (N.connected i),
    fun i j hij => D.expand_disjoint (N.disjoint i j hij),?_,?_⟩,hB⟩
  · intro i j hij
    obtain ⟨v,hv,w,hw,he⟩ := N.adjacent i j hij
    exact ⟨v.val,⟨v,hv,rfl⟩,w.val,⟨w,hw,rfl⟩,he⟩
  · intro i
    exact ⟨rr i,N.root_mem i,rfl⟩

theorem large_minor_woven (G : SimpleGraph V) [DecidableRel G.Adj]
    {a : ℕ} (ha : 1≤a) (hc : KConnectedOn G univ (100*a))
    (hh : 64*a≤hadwigerNumber G) : Woven G a (3*a) := by
  classical
  intro roots hr _ p hp x y _ hxy
  let O := Fin a ⊕ (Fin p × Bool)
  let port : O → V := Sum.elim roots (fun z => if z.2 then y z.1 else x z.1)
  let Z := univ.image port
  have hO : Fintype.card O=a+2*p := by simp [O]; omega
  have hZ : Z.card≤a+2*p := by
    calc Z.card≤Fintype.card O := (card_image_le).trans (by simp)
         _ = a+2*p := hO
  obtain ⟨proxy,hproxy,hadj⟩ := distinct_proxies G port Z hc
    (show Fintype.card O+Z.card≤100*a by rw [hO]; omega)
  let R := univ\Z
  have hrp (o) : proxy o∈R := mem_sdiff.mpr ⟨mem_univ _,(hadj o).1⟩
  have hcR : KConnectedOn G R (2*Fintype.card O) := by
    have hd := Knitting.delete_connected G hc (subset_univ Z)
      (show Z.card<100*a by omega)
    exact Knitting.kConnected_mono hd (by rw [hO]; omega)
  have hhR : 4*Fintype.card O≤hadwigerNumber (G.induce (↑R:Set V)) := by
    have hd := hadwiger_delete G Z
    change hadwigerNumber G≤hadwigerNumber (G.induce (↑R:Set V))+Z.card at hd
    rw [hO]
    omega
  obtain ⟨M,hMR⟩ := rooting_on G R proxy hproxy hrp hcR hhR
  obtain ⟨C,hC,hCC,hCr,hCp,hCM⟩ := proxy_groups_of_model G proxy M
  have hCZ (i v) (hv : v∈C i) : v∉Z := by
    obtain ⟨o,ho⟩ := hCM i v hv
    exact (mem_sdiff.mp (hMR o ho)).2
  have hpZ (o : O) : port o∈Z := mem_image.mpr ⟨o,mem_univ _,rfl⟩
  have hrZ (j) : roots j∈Z := hpZ (.inl j)
  have hxZ (i) : x i∈Z := hpZ (.inr (i,false))
  have hyZ (i) : y i∈Z := hpZ (.inr (i,true))
  apply weaving_from_proxy_groups G roots x y hr hxy C hC hCC
    (fun i j hv => hCZ i _ hv (hrZ j))
    (fun i j hv => hCZ i _ hv (hxZ j))
    (fun i j hv => hCZ i _ hv (hyZ j))
  · intro i j hij
    rw [hCr i,hCr j]
    exact M.adjacent (.inl i) (.inl j) (fun he => hij (Sum.inl.inj he))
  · intro j
    refine ⟨proxy (.inl j),?_,(hadj (.inl j)).2⟩
    rw [hCr j]
    exact M.root_mem (.inl j)
  · intro i
    exact ⟨proxy (.inr (i,false)),(hCp i).1,(hadj (.inr (i,false))).2⟩
  · intro i
    exact ⟨proxy (.inr (i,true)),(hCp i).2,(hadj (.inr (i,true))).2⟩

end LinearListHadwiger.Recursion

end OAI