import Mathlib

namespace OAI

section
section
section
noncomputable section
namespace CannonCycleOrder
open Set SimpleGraph

def next {n:ℕ} (hn:0<n) (i:Fin n) : Fin n :=
  if h:i.val+1<n then ⟨i.val+1,h⟩ else ⟨0,hn⟩

lemma next_surjective {n:ℕ} (hn:0<n) : Function.Surjective (next hn) := by
  intro i
  by_cases hi:i.val=0
  · refine ⟨⟨n-1,by omega⟩,?_⟩
    apply Fin.ext
    simp only [next]
    split_ifs with h <;> dsimp <;> omega
  · refine ⟨⟨i.val-1,by omega⟩,?_⟩
    apply Fin.ext
    simp only [next]
    split_ifs with h <;> dsimp <;> omega

lemma next_ne {n:ℕ} (hn:0<n) (hn2:2≤n) (i:Fin n) : next hn i≠i := by
  intro he
  have hh:=congrArg Fin.val he
  simp only [next] at hh
  split_ifs at hh <;> dsimp at hh <;> omega

lemma next_mod {n:ℕ} (hn:0<n) (i:Fin n) : (next hn i).val=(i.val+1)%n := by
  simp only [next]
  split_ifs with h
  · exact (Nat.mod_eq_of_lt h).symm
  · dsimp
    have he:i.val+1=n := by omega
    simp [he]

def bipartite {E A:Type*} (R:E→A→Prop) : SimpleGraph (E⊕A) where
  Adj
    | .inl e,.inr a => R e a
    | .inr a,.inl e => R e a
    | _,_ => False
  symm := ⟨by intro x y h; cases x <;> cases y <;> exact h⟩
  loopless := ⟨by intro x; cases x <;> exact id⟩

def tag {E A:Type*} : E⊕A→ℕ | .inl _ => 0 | .inr _ => 1

lemma walk_tag {E A:Type*} {R:E→A→Prop} {e:E} {z:E⊕A}
    (p:(bipartite R).Walk (.inl e) z) : ∀ k≤p.length,tag (p.getVert k)=k%2 := by
  intro k
  induction k with
  | zero => intro _; simp [tag]
  | succ k ih =>
    intro hk
    have hr := ih (by omega)
    have ha := p.adj_getVert_succ (i:=k) (by omega)
    have hstep : tag (p.getVert (k+1))+tag (p.getVert k)=1 := by
      cases h0:p.getVert k <;> cases h1:p.getVert (k+1) <;>
        simp_all [bipartite,tag]
    rw [hr] at hstep
    omega

theorem exists_order {E A:Type*} [Finite E] [Finite A] (R:E→A→Prop)
    (hc:(bipartite R).IsCycles) (hp:(bipartite R).Preconnected)
    (hne:∃ e a,R e a) :
    ∃ n:ℕ,∃ hn:0<n,∃ e:Fin n≃E,∃ a:Fin n≃A,
      2≤n ∧ (∀ i,R (e i) (a i)) ∧ (∀ i,R (e (next hn i)) (a i)) := by
  classical
  obtain ⟨e₀,a₀,he₀⟩ := hne
  let G := bipartite R
  obtain ⟨p,hpc,hcover⟩ := hc.exists_cycle_toSubgraph_verts_eq_connectedComponentSupp
    (c:=G.connectedComponentMk (.inl e₀)) (by rfl)
    (show (G.neighborSet (.inl e₀)).Nonempty from ⟨.inr a₀,he₀⟩)
  have hsupp (z:E⊕A) : z∈p.support := by
    rw [←p.mem_verts_toSubgraph,hcover]
    change G.connectedComponentMk z=G.connectedComponentMk (.inl e₀)
    exact ConnectedComponent.sound (hp z (.inl e₀))
  have hpar := walk_tag p
  have heven : p.length%2=0 := by
    have hh := hpar p.length le_rfl
    simpa only [p.getVert_length,tag] using hh.symm
  let n := p.length/2
  have hlen : p.length=2*n := by omega
  have hn : 0<n := by have hh:=hpc.three_le_length; omega
  have hs (z:E⊕A) : ∃ k<p.length,p.getVert k=z := by
    obtain ⟨k,hk,hkl⟩ := Walk.mem_support_iff_exists_getVert.mp (hsupp z)
    by_cases h:k<p.length
    · exact ⟨k,h,hk⟩
    · have he:k=p.length := by omega
      exact ⟨0,by omega,by simpa [he] using hk⟩
  have exE (i:Fin n) : ∃ e:E,p.getVert (2*i.val)=.inl e := by
    have hh := hpar (2*i.val) (by omega)
    cases hv:p.getVert (2*i.val) with
    | inl e => exact ⟨e,rfl⟩
    | inr a => simp [hv,tag] at hh
  have exA (i:Fin n) : ∃ a:A,p.getVert (2*i.val+1)=.inr a := by
    have hh := hpar (2*i.val+1) (by omega)
    cases hv:p.getVert (2*i.val+1) with
    | inl e => simp [hv,tag] at hh
    | inr a => exact ⟨a,rfl⟩
  choose e he using exE
  choose a ha using exA
  have hein : Function.Injective e := by
    intro i j hij
    have hh := hpc.getVert_injOn' (by change 2*i.val≤p.length-1; omega)
      (by change 2*j.val≤p.length-1; omega) ((he i).trans ((congrArg Sum.inl hij).trans (he j).symm))
    apply Fin.ext; omega
  have hain : Function.Injective a := by
    intro i j hij
    have hh := hpc.getVert_injOn' (by change 2*i.val+1≤p.length-1; omega)
      (by change 2*j.val+1≤p.length-1; omega) ((ha i).trans ((congrArg Sum.inr hij).trans (ha j).symm))
    apply Fin.ext; omega
  have hesur : Function.Surjective e := by
    intro v
    obtain ⟨k,hk,hv⟩ := hs (.inl v)
    have hm := hpar k (by omega)
    simp only [hv,tag] at hm
    let i:Fin n := ⟨k/2,by omega⟩
    have heq:2*i.val=k := by dsimp [i]; omega
    exact ⟨i,Sum.inl.inj ((he i).symm.trans (by simpa only [heq] using hv))⟩
  have hasur : Function.Surjective a := by
    intro v
    obtain ⟨k,hk,hv⟩ := hs (.inr v)
    have hm := hpar k (by omega)
    simp only [hv,tag] at hm
    let i:Fin n := ⟨k/2,by omega⟩
    have heq:2*i.val+1=k := by dsimp [i]; omega
    exact ⟨i,Sum.inr.inj ((ha i).symm.trans (by simpa only [heq] using hv))⟩
  have hnext (i:Fin n) : p.getVert (2*i.val+2)=.inl (e (next hn i)) := by
    unfold next
    split_ifs with h
    · convert he ⟨i.val+1,h⟩ using 1
    · have hi:2*i.val+2=p.length := by omega
      rw [hi,p.getVert_length]
      simpa using (he ⟨0,hn⟩)
  refine ⟨n,hn,Equiv.ofBijective e ⟨hein,hesur⟩,Equiv.ofBijective a ⟨hain,hasur⟩,by have hh:=hpc.three_le_length; omega,?_,?_⟩
  · intro i
    have hh := p.adj_getVert_succ (i:=2*i.val) (by omega)
    rw [he i,ha i] at hh
    exact hh
  · intro i
    have hh := p.adj_getVert_succ (i:=2*i.val+1) (by omega)
    have heq:2*i.val+1+1=2*i.val+2 := by omega
    rw [heq,ha i,hnext i] at hh
    exact hh
end CannonCycleOrder

end
end
end
end

end OAI