lean/OAI/Computability/WLIdentification/AcceptingMates.lean

import OAI.Computability.WLIdentification.GlobalSolvability

namespace OAI

namespace WLIdentification

namespace SimpleGraph

theorem reachable_propagate {V : Type} {G : SimpleGraph V} {a b : V} {P : V → Prop}
    (hab : G.Reachable a b) (ha : P a)
    (step : ∀ {u v}, G.Reachable a u → G.Adj u v → P u → P v) : P b := by
  obtain ⟨p⟩ := hab
  have aux : ∀ {u v} (p : G.Walk u v), G.Reachable a u → P u → P v := by
    intro u v p
    induction p with
    | nil => exact fun _ h => h
    | cons h p ih =>
      intro hu hp
      exact ih (hu.trans h.reachable) (step hu h hp)
  exact aux p (.refl a) ha

end SimpleGraph

namespace ComparisonSchemas
variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E)

theorem shift_link_forward {n : ℕ} (h h' : (S.layout n).Shift) (l : S.Link n)
    (he : (S.layout n).firstForm l (h ((S.layout n).first l)) +
        (S.layout n).secondForm l (h ((S.layout n).second l)) =
      (S.layout n).firstForm l (h' ((S.layout n).first l)) +
        (S.layout n).secondForm l (h' ((S.layout n).second l)))
    (hreal : ∀ p, (S.layout n).second l = Sum.inl p → h (.inl p) = h' (.inl p))
    (hh : h ((S.layout n).first l) = h' ((S.layout n).first l)) :
    h ((S.layout n).second l) = h' ((S.layout n).second l) := by
  rw [hh] at he
  have hv := add_left_cancel he
  cases l with
  | inl e =>
    funext j
    have hj : j = (0 : Fin 1) := Subsingleton.elim (α := Fin 1) _ _
    subst j
    exact hv
  | inr l => cases l with
    | inl ei =>
      funext j
      have hj : j = (0 : Fin 1) := Subsingleton.elim (α := Fin 1) _ _
      subst j
      exact hv
    | inr e => exact hreal (S.target e) rfl

theorem shift_link_backward {n : ℕ} (h h' : (S.layout n).Shift) (l : S.Link n)
    (he : (S.layout n).firstForm l (h ((S.layout n).first l)) +
        (S.layout n).secondForm l (h ((S.layout n).second l)) =
      (S.layout n).firstForm l (h' ((S.layout n).first l)) +
        (S.layout n).secondForm l (h' ((S.layout n).second l)))
    (hreal : ∀ p, (S.layout n).first l = Sum.inl p → h (.inl p) = h' (.inl p))
    (hh : h ((S.layout n).second l) = h' ((S.layout n).second l)) :
    h ((S.layout n).first l) = h' ((S.layout n).first l) := by
  rw [hh] at he
  have hv := add_right_cancel he
  cases l with
  | inl e => exact hreal (S.source e) rfl
  | inr l => cases l with
    | inl ei =>
      funext j
      have hj : j = (0 : Fin 1) := Subsingleton.elim (α := Fin 1) _ _
      subst j
      exact hv
    | inr e =>
      funext j
      have hj : j = (0 : Fin 1) := Subsingleton.elim (α := Fin 1) _ _
      subst j
      exact hv

theorem shift_agreement_reachable {n : ℕ} {U : Finset (S.layout n).Block}
    (hr : 2 ≤ r) (old new : (S.layout n).Shift) {a c : (S.layout n).Corner}
    (he : ∀ l ∈ (S.layout n).usedLinks U,
      (S.layout n).firstForm l (old ((S.layout n).first l)) +
        (S.layout n).secondForm l (old ((S.layout n).second l)) =
      (S.layout n).firstForm l (new ((S.layout n).first l)) +
        (S.layout n).secondForm l (new ((S.layout n).second l)))
    (hreal : ∀ d, ((S.layout n).cornerGraph hr U).Reachable a d →
      ∀ p, d.1 = Sum.inl p → old (.inl p) = new (.inl p))
    (ha : old a.1 = new a.1)
    (hc : ((S.layout n).cornerGraph hr U).Reachable a c) : old c.1 = new c.1 := by
  apply SimpleGraph.reachable_propagate hc ha
  intro u v hu huv hh
  have hv := hu.trans huv.reachable
  obtain ⟨x, hx, hd⟩ := huv
  cases x with
  | inl x => rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> exact hh
  | inr x =>
    have hl := he x.1 ((S.layout n).vertical_usedLink hx)
    rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
    · exact S.shift_link_forward old new x.1 hl (hreal _ hv) hh
    · exact S.shift_link_backward old new x.1 hl (hreal _ hv) hh

def SameAlignment (n : ℕ) (cut cut' : E → Fin n) (t : S.InternalType n) : Prop :=
  ∀ i (a : (S.layout n).Label t i),
    S.align n cut ⟨t, i, a⟩ = S.align n cut' ⟨t, i, a⟩

theorem alignment_link_forward {n : ℕ} {U : Finset (S.layout n).Block}
    {cut cut' : E → Fin n} (hc : S.Avoids n U cut) (hc' : S.Avoids n U cut')
    {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U)
    (hh : S.SameAlignment n cut cut' ((S.layout n).first l)) :
    S.SameAlignment n cut cut' ((S.layout n).second l) := by
  have step (i : Fin r) (a : (S.layout n).Match l i) :=
    (S.align_link hc hl i a).symm.trans ((hh i _).trans (S.align_link hc' hl i a))
  cases l with
  | inl e => exact step
  | inr l => cases l with
    | inl ei => exact step
    | inr e => exact fun _ _ => rfl

theorem alignment_link_backward {n : ℕ} {U : Finset (S.layout n).Block}
    {cut cut' : E → Fin n} (hc : S.Avoids n U cut) (hc' : S.Avoids n U cut')
    {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U)
    (hh : S.SameAlignment n cut cut' ((S.layout n).second l)) :
    S.SameAlignment n cut cut' ((S.layout n).first l) := by
  have step (i : Fin r) (a : (S.layout n).Match l i) :=
    (S.align_link hc hl i a).trans ((hh i _).trans (S.align_link hc' hl i a).symm)
  cases l with
  | inl e => exact fun _ _ => rfl
  | inr l => cases l with
    | inl ei => exact step
    | inr e => exact step

theorem alignment_agreement_reachable {n : ℕ} {U : Finset (S.layout n).Block}
    {cut cut' : E → Fin n} (hc : S.Avoids n U cut) (hc' : S.Avoids n U cut')
    (hr : 2 ≤ r) {a c : (S.layout n).Corner}
    (ha : S.SameAlignment n cut cut' a.1)
    (h : ((S.layout n).cornerGraph hr U).Reachable a c) :
    S.SameAlignment n cut cut' c.1 := by
  apply SimpleGraph.reachable_propagate h ha
  intro u v _ huv hh
  obtain ⟨x, hx, hd⟩ := huv
  cases x with
  | inl x => rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> exact hh
  | inr x =>
    have hl := (S.layout n).vertical_usedLink hx
    rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
    · exact S.alignment_link_forward hc hc' hl hh
    · exact S.alignment_link_backward hc hc' hl hh

end ComparisonSchemas

namespace ComparisonSchemas
variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E)

def arm (n : ℕ) (cut : E → Fin n) : S.InternalType n → Option (E × Bool)
  | .inl _ => none
  | .inr (e, j) => some (e, decide (S.onLeft n cut e j))

def NoRealFrom (n : ℕ) (hr : 2 ≤ r) (U : Finset (S.layout n).Block)
    (a : (S.layout n).Corner) : Prop :=
  ∀ c, ((S.layout n).cornerGraph hr U).Reachable a c → ∀ p, c.1 ≠ Sum.inl p

theorem arm_link {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n}
    (hc : S.Avoids n U cut) {l : S.Link n} (hl : l ∈ (S.layout n).usedLinks U)
    (hf : ∀ p, (S.layout n).first l ≠ Sum.inl p)
    (hs : ∀ p, (S.layout n).second l ≠ Sum.inl p) :
    S.arm n cut ((S.layout n).first l) = S.arm n cut ((S.layout n).second l) := by
  cases l with
  | inl e => exact (hf (S.source e) rfl).elim
  | inr l => cases l with
    | inl ei =>
      obtain ⟨e, j⟩ := ei
      have hj : j ≠ cut e := fun h => hc e (h ▸ hl)
      change some (e, decide (S.onLeft n cut e j.castSucc)) =
        some (e, decide (S.onLeft n cut e j.succ))
      simp only [S.cut_middle hj]
    | inr e => exact (hs (S.target e) rfl).elim

theorem arm_reachable {n : ℕ} {U : Finset (S.layout n).Block} {cut : E → Fin n}
    (hc : S.Avoids n U cut) (hr : 2 ≤ r) {a c : (S.layout n).Corner}
    (hn : S.NoRealFrom n hr U a)
    (hh : ((S.layout n).cornerGraph hr U).Reachable a c) :
    S.arm n cut c.1 = S.arm n cut a.1 := by
  apply SimpleGraph.reachable_propagate (P := fun d => S.arm n cut d.1 = S.arm n cut a.1) hh rfl
  intro u v hu huv ih
  have hv := hu.trans huv.reachable
  obtain ⟨x, hx, hd⟩ := huv
  cases x with
  | inl x => rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩ <;> exact ih
  | inr x =>
    rcases hd with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
    · exact (S.arm_link hc ((S.layout n).vertical_usedLink hx) (hn _ hu) (hn _ hv)).symm.trans ih
    · exact (S.arm_link hc ((S.layout n).vertical_usedLink hx) (hn _ hv) (hn _ hu)).trans ih

theorem arm_label {n : ℕ} {cut : E → Fin n} {c : (S.layout n).Corner}
    {e : E} {side : Bool} (h : S.arm n cut c.1 = some (e, side)) :
    c.2.2.val ∈ S.domain e c.2.1 ∧
      S.align n cut c = if side then c.2.2.val else S.permutation e c.2.1 c.2.2.val := by
  obtain ⟨t, i, a⟩ := c
  cases t with
  | inl p => cases h
  | inr ej =>
    obtain ⟨f, j⟩ := ej
    have he := (Prod.mk.inj (Option.some.inj h)).1
    have hs := (Prod.mk.inj (Option.some.inj h)).2
    subst f
    refine ⟨a.property, ?_⟩
    change (if S.onLeft n cut e j then a.val else S.permutation e i a.val) = _
    rw [← hs]
    simp only [decide_eq_true_eq]

theorem arm_shift {n : ℕ} {cut : E → Fin n} {t : S.InternalType n}
    {e : E} {side : Bool} (b : E → Bit) (q : S.RealShift)
    (h : S.arm n cut t = some (e, side)) :
    ∃ j : Fin (n + 1), t = Sum.inr (e, j) ∧ ∀ k : Fin 1,
      S.starShift n cut b q (.inr (e, j)) k =
        if side then S.left e (q (S.source e)) else b e + S.right e (q (S.target e)) := by
  cases t with
  | inl p => cases h
  | inr fj =>
    obtain ⟨f, j⟩ := fj
    have he := (Prod.mk.inj (Option.some.inj h)).1
    have hs := (Prod.mk.inj (Option.some.inj h)).2
    subst f
    refine ⟨j, rfl, ?_⟩
    intro k
    change (if S.onLeft n cut e j then _ else _) = _
    rw [← hs]
    simp only [decide_eq_true_eq]

end ComparisonSchemas

namespace RingLayout
variable {r : ℕ} {T L : Type} (R : RingLayout r T L)

theorem blockStart_eq (a : R.Corner → Bool) (b : R.Block) :
    R.blockStart a b = a (R.blockRepresentative b) := by cases b <;> rfl

theorem representative_row (b : R.Block) : (R.blockRepresentative b).2.1 = R.blockRow b := by
  cases b <;> rfl

theorem wrapping_names_reachable (hr : 3 ≤ r) {U : Finset R.Block}
    (hu : U.card ≤ r) (hw : R.Wrapping (by omega) U) {b : R.Block} (hb : b ∈ U)
    {x : R.Name} (hx : x ∈ R.names U) :
    (R.cornerGraph (by omega) U).Reachable (R.blockRepresentative b) (R.nameFirst x) ∧
    (R.cornerGraph (by omega) U).Reachable (R.blockRepresentative b) (R.nameSecond x) := by
  classical
  obtain ⟨c, hc, hxc⟩ := Finset.mem_biUnion.mp hx
  have hbc := R.wrapping_blocks_reachable hr hu hw hb hc
  have hc' := R.block_reachable (by omega) hc hxc
  exact ⟨hbc.trans hc'.1, hbc.trans hc'.2⟩

end RingLayout

namespace ComparisonSchemas
variable {r : ℕ} {P E : Type} (S : ComparisonSchemas r P E)

theorem wrapping_real_addresses {n : ℕ} (hr : 3 ≤ r) {U : Finset (S.layout n).Block}
    (hu : U.card ≤ r) (hw : (S.layout n).Wrapping (by omega) U)
    {cut cut' : E → Fin n} (hc : S.Avoids n U cut) (hc' : S.Avoids n U cut')
    {A A' : Fin r → Bool}
    (hA : (S.layout n).IsWrappingAddress U (S.align n cut) A)
    (hA' : (S.layout n).IsWrappingAddress U (S.align n cut') A')
    {b : (S.layout n).Block} (hb : b ∈ U)
    {d : (S.layout n).Corner} {p : P} (hd : d.1 = Sum.inl p)
    (hbd : ((S.layout n).cornerGraph (by omega) U).Reachable ((S.layout n).blockRepresentative b) d) :
    A = A' := by
  funext i
  obtain ⟨c, hcu, hci⟩ := Finset.mem_image.mp ((S.layout n).wrapping_rows hr hw i)
  have hdc := hbd.symm.trans ((S.layout n).wrapping_blocks_reachable hr hu hw hb hcu)
  have hd' : S.SameAlignment n cut cut' d.1 := by rw [hd]; exact fun _ _ => rfl
  have he := S.alignment_agreement_reachable hc hc' (by omega) hd' hdc
  have he' : (S.layout n).blockStart (S.align n cut) c =
      (S.layout n).blockStart (S.align n cut') c := by
    rw [RingLayout.blockStart_eq, RingLayout.blockStart_eq]
    exact he _ _
  rw [(hA c hcu).1, (hA' c hcu).1, hci] at he'
  exact he'

def expressAddress (e : E) (side : Bool) (a : S.DomainAddress e) : Fin r → Bool :=
  fun i => if side then (a i).val else S.mapping e i (a i)

theorem wrapping_internal_addresses {n : ℕ} (hr : 3 ≤ r) {U : Finset (S.layout n).Block}
    (hu : U.card ≤ r) (hw : (S.layout n).Wrapping (by omega) U)
    {cut cut' : E → Fin n} (hc : S.Avoids n U cut) (hc' : S.Avoids n U cut')
    {A A' : Fin r → Bool}
    (hA : (S.layout n).IsWrappingAddress U (S.align n cut) A)
    (hA' : (S.layout n).IsWrappingAddress U (S.align n cut') A')
    {b : (S.layout n).Block} (hb : b ∈ U)
    (hn : S.NoRealFrom n (by omega) U ((S.layout n).blockRepresentative b))
    {e : E} {side side' : Bool}
    (ha : S.arm n cut ((S.layout n).blockRepresentative b).1 = some (e, side))
    (ha' : S.arm n cut' ((S.layout n).blockRepresentative b).1 = some (e, side')) :
    ∃ a : S.DomainAddress e, A = S.expressAddress e side a ∧ A' = S.expressAddress e side' a := by
  classical
  have hex (i : Fin r) : ∃ c ∈ U, (S.layout n).blockRow c = i :=
    Finset.mem_image.mp ((S.layout n).wrapping_rows hr hw i)
  choose c hcu hci using hex
  have harm (i : Fin r) := (S.arm_reachable hc (by omega) hn
    ((S.layout n).wrapping_blocks_reachable hr hu hw hb (hcu i))).trans ha
  have harm' (i : Fin r) := (S.arm_reachable hc' (by omega) hn
    ((S.layout n).wrapping_blocks_reachable hr hu hw hb (hcu i))).trans ha'
  have hrow (i : Fin r) : ((S.layout n).blockRepresentative (c i)).2.1 = i :=
    ((S.layout n).representative_row (c i)).trans (hci i)
  let a : S.DomainAddress e := fun i => ⟨((S.layout n).blockRepresentative (c i)).2.2.val,
    by simpa only [hrow i] using (S.arm_label (harm i)).1⟩
  refine ⟨a, ?_, ?_⟩
  · funext i
    have he := (S.arm_label (harm i)).2
    change S.align n cut ((S.layout n).blockRepresentative (c i)) =
      (if side then (a i).val else S.permutation e ((S.layout n).blockRepresentative (c i)).2.1 (a i).val) at he
    rw [hrow i] at he
    have hs := (hA (c i) (hcu i)).1
    rw [RingLayout.blockStart_eq, hci i] at hs
    rw [← hs, he]
    change (if side then (a i).val else S.permutation e i (a i).val) = _
    rw [S.permutation_apply]
    rfl
  · funext i
    have he := (S.arm_label (harm' i)).2
    change S.align n cut' ((S.layout n).blockRepresentative (c i)) =
      (if side' then (a i).val else S.permutation e ((S.layout n).blockRepresentative (c i)).2.1 (a i).val) at he
    rw [hrow i] at he
    have hs := (hA' (c i) (hcu i)).1
    rw [RingLayout.blockStart_eq, hci i] at hs
    rw [← hs, he]
    change (if side' then (a i).val else S.permutation e i (a i).val) = _
    rw [S.permutation_apply]
    rfl

end ComparisonSchemas

end WLIdentification

end OAI