lean/OAI/Computability/WLIdentification/MateReconstruction.lean

import OAI.Computability.WLIdentification.AffineIncidence

namespace OAI

namespace WLIdentification

theorem histogram_eq_of_equiv {α β γ : Type} [Fintype α] [Fintype β]
    (e : α ≃ β) (f : α → γ) (g : β → γ) (h : ∀ a, f a = g (e a)) :
    Finset.univ.val.map f = Finset.univ.val.map g := by
  rw [← Multiset.map_univ_val_equiv e, Multiset.map_map]
  exact Multiset.map_congr rfl (fun a _ => h a)

theorem filteredHistogram_eq_of_equiv {α β γ : Type} [Fintype α] [Fintype β]
    (e : α ≃ β) (p : α → Prop) (q : β → Prop) [DecidablePred p] [DecidablePred q]
    (f : α → γ) (g : β → γ) (hp : ∀ a, p a ↔ q (e a)) (h : ∀ a, f a = g (e a)) :
    (Finset.univ.filter p).val.map f = (Finset.univ.filter q).val.map g := by
  simp only [Finset.filter_val]
  conv_rhs => rw [← Multiset.map_univ_val_equiv e, Multiset.filter_map, Multiset.map_map]
  apply Multiset.map_congr
  · exact Multiset.filter_congr (fun a _ => hp a)
  · exact fun a _ => h a

theorem isomorphic_refl (G : Graph) : Isomorphic G G := ⟨Equiv.refl _, fun _ _ => rfl⟩

theorem isomorphic_symm {G H : Graph} (h : Isomorphic G H) : Isomorphic H G := by
  obtain ⟨e, he⟩ := h
  refine ⟨e.symm, ?_⟩
  intro v w
  simpa only [e.apply_symm_apply] using (he (e.symm v) (e.symm w)).symm

theorem isomorphic_trans {G H I : Graph} (h : Isomorphic G H) (h' : Isomorphic H I) :
    Isomorphic G I := by
  obtain ⟨e, he⟩ := h
  obtain ⟨f, hf⟩ := h'
  exact ⟨e.trans f, fun v w => (he v w).trans (hf (e v) (e w))⟩

theorem neighborColor_isomorphic {G H : Graph} (e : Fin G.order ≃ Fin H.order)
    (he : ∀ v w, G.edge v w = H.edge (e v) (e w)) (s : ℕ) (v : Fin G.order) :
    neighborColor G s v = neighborColor H s (e v) := by
  induction s generalizing v with
  | zero => rfl
  | succ s ih =>
    change (neighborColor G s v, _) = (neighborColor H s (e v), _)
    apply Prod.ext (ih v)
    exact filteredHistogram_eq_of_equiv e _ _ _ _
      (fun w => by rw [he v w]) ih

theorem tupleColor_isomorphic {G H : Graph} (e : Fin G.order ≃ Fin H.order)
    (he : ∀ v w, G.edge v w = H.edge (e v) (e w)) (k s : ℕ) (v : Fin k → Fin G.order) :
    tupleColor G k s v = tupleColor H k s (e ∘ v) := by
  induction s generalizing v with
  | zero =>
    apply Prod.ext
    · funext i j
      exact decide_eq_decide.mpr e.injective.eq_iff.symm
    · funext i j
      exact he (v i) (v j)
  | succ s ih =>
    change (tupleColor G k s v, _) = (tupleColor H k s (e ∘ v), _)
    apply Prod.ext (ih v)
    apply histogram_eq_of_equiv e
    intro z
    funext i
    simpa only [Function.comp_update] using ih (Function.update v i z)

theorem isomorphic_equivalent {G H : Graph} (h : Isomorphic G H) (k : ℕ) : Equivalent k G H := by
  obtain ⟨e, he⟩ := h
  unfold Equivalent
  split_ifs
  · intro s
    exact histogram_eq_of_equiv e _ _ (neighborColor_isomorphic e he s)
  · intro s
    exact histogram_eq_of_equiv (Equiv.piCongrRight (fun _ : Fin k => e)) _ _
      (tupleColor_isomorphic e he k s)

theorem equivalent_trans {G H I : Graph} {k : ℕ}
    (h : Equivalent k G H) (h' : Equivalent k H I) : Equivalent k G I := by
  unfold Equivalent at *
  split_ifs at * <;> exact fun s => (h s).trans (h' s)

def simpleOfGraph (G : Graph) : SimpleGraph (Fin G.order) where
  Adj v w := G.edge v w = true
  symm := ⟨by intro v w; rw [G.symmetric v w]; exact id⟩
  loopless := ⟨by intro v; rw [G.loopless v]; decide⟩

instance simpleOfGraph_decidable (G : Graph) : DecidableRel (simpleOfGraph G).Adj :=
  fun _ _ => inferInstanceAs (Decidable (_ = true))

theorem graph_simple_isomorphic (G : Graph) : Isomorphic G (graphOfSimple (simpleOfGraph G)) := by
  refine ⟨Fintype.equivFin (Fin G.order), ?_⟩
  intro v w
  have hh : decide ((simpleOfGraph G).Adj v w) = G.edge v w := by
    cases h : G.edge v w <;> simp [simpleOfGraph, h]
  exact hh.symm.trans (graphOfSimple_edge (simpleOfGraph G) v w).symm

@[simp]
theorem simpleOfGraph_degree (G : Graph) (v : Fin G.order) :
    (simpleOfGraph G).degree v = degree G v := by
  unfold SimpleGraph.degree degree
  congr 1
  ext w
  simp only [SimpleGraph.mem_neighborFinset, Finset.mem_filter, Finset.mem_univ, true_and]
  rfl

/-- A degree-one vertex has the same unique neighbor in every incident edge. -/
theorem degree_one_neighbors_eq {V : Type} [Fintype V] (G : SimpleGraph V)
    [DecidableRel G.Adj] {v x y : V} (hd : G.degree v = 1)
    (hx : G.Adj v x) (hy : G.Adj v y) : x = y := by
  obtain ⟨w, _, hw⟩ := SimpleGraph.degree_eq_one_iff_existsUnique_adj.mp hd
  exact (hw x hx).trans (hw y hy).symm

/-- Private-leaf reconstruction by exact finite counting. The prescribed leaf
counts exhaust all leaf vertices; no separate leaf-only component can remain. -/
theorem private_leaf_reconstruction {V : Type} [Fintype V] (ell : V → ℕ)
    (H : SimpleGraph (LeafVertex ell)) [DecidableRel H.Adj]
    (hleaf : ∀ (v : V) (j : Fin (ell v)), H.degree (.inr ⟨v, j⟩) = 1)
    (hcount : ∀ v, Fintype.card {l : Σ v, Fin (ell v) // H.Adj (.inl v) (.inr l)} = ell v) :
    ∃ e : withLeaves (H.comap Sum.inl) ell ≃g H, ∀ v, e (.inl v) = .inl v := by
  classical
  let F (v : V) : Fin (ell v) ≃ {l : Σ v, Fin (ell v) // H.Adj (.inl v) (.inr l)} :=
    Classical.choice (Fintype.card_eq.mp (by rw [Fintype.card_fin, hcount]))
  let f : (Σ v, Fin (ell v)) → (Σ v, Fin (ell v)) := fun l => (F l.1 l.2).val
  have hfadj (l : Σ v, Fin (ell v)) : H.Adj (.inl l.1) (.inr (f l)) := (F l.1 l.2).property
  have hfparent (l : Σ v, Fin (ell v)) (v : V) :
      H.Adj (.inl v) (.inr (f l)) ↔ v = l.1 := by
    constructor
    · intro h
      exact Sum.inl.inj (degree_one_neighbors_eq H (hleaf (f l).1 (f l).2)
        h.symm (hfadj l).symm)
    · rintro rfl
      exact hfadj l
  have hfinj : Function.Injective f := by
    intro l m heq
    have hp : l.1 = m.1 := (hfparent m l.1).mp (heq ▸ hfadj l)
    obtain ⟨v, i⟩ := l
    obtain ⟨w, j⟩ := m
    dsimp at hp
    subst w
    have hij : i = j := (F v).injective (Subtype.ext heq)
    subst j
    rfl
  let E := Equiv.ofBijective f ((Fintype.bijective_iff_injective_and_card f).mpr ⟨hfinj, rfl⟩)
  refine ⟨{ toEquiv := Equiv.sumCongr (Equiv.refl V) E, map_rel_iff' := ?_ }, fun _ => rfl⟩
  intro x y
  cases x with
  | inl v =>
    cases y with
    | inl w => rfl
    | inr l => exact hfparent l v
  | inr l =>
    cases y with
    | inl v =>
      change H.Adj (.inr (f l)) (.inl v) ↔ l.1 = v
      rw [H.adj_comm, hfparent, eq_comm]
    | inr m =>
      change H.Adj (.inr (f l)) (.inr (f m)) ↔ False
      refine ⟨fun h => ?_, False.elim⟩
      have hf := degree_one_neighbors_eq H (hleaf (f l).1 (f l).2) h (hfadj l).symm
      cases hf

def simpleDegreeNeighbors {V : Type} [Fintype V] (G : SimpleGraph V)
    [DecidableRel G.Adj] (v : V) (d : ℕ) : ℕ :=
  (Finset.univ.filter (fun w => G.Adj v w ∧ G.degree w = d)).card

@[simp]
theorem graphOfSimple_degree_at {V : Type} [Fintype V] (G : SimpleGraph V)
    [DecidableRel G.Adj] (i : Fin (Fintype.card V)) :
    degree (graphOfSimple G) i = G.degree ((Fintype.equivFin V).symm i) := by
  have hh := graphOfSimple_degree G ((Fintype.equivFin V).symm i)
  simpa only [Equiv.apply_symm_apply] using hh

@[simp]
theorem graphOfSimple_degreeNeighbors {V : Type} [Fintype V] (G : SimpleGraph V)
    [DecidableRel G.Adj] (v : V) (d : ℕ) :
    degreeNeighbors (graphOfSimple G) (Fintype.equivFin V v) d = simpleDegreeNeighbors G v d := by
  classical
  unfold degreeNeighbors simpleDegreeNeighbors
  apply Finset.card_equiv (Fintype.equivFin V).symm
  intro j
  have hdegree := graphOfSimple_degree_at G j
  simp only [graphOfSimple] at hdegree ⊢
  simp [hdegree]
  intro _ _
  exact Finset.mem_univ _

/-- Transfer the literal WL local information to any finite graph vertex types. -/
theorem simple_equivalent_local {V W : Type} [Fintype V] [Fintype W]
    (G : SimpleGraph V) (H : SimpleGraph W) [DecidableRel G.Adj] [DecidableRel H.Adj]
    {k m : ℕ} (hk : 2 ≤ k) (h : Equivalent k (graphOfSimple G) (graphOfSimple H))
    (hm : m ≤ k) (hm0 : 0 < m) (v : Fin m → V) :
    ∃ w : Fin m → W,
      (∀ i j, v i = v j ↔ w i = w j) ∧
      (∀ i j, G.Adj (v i) (v j) ↔ H.Adj (w i) (w j)) ∧
      (∀ i, G.degree (v i) = H.degree (w i)) ∧
      (∀ i d, simpleDegreeNeighbors G (v i) d = simpleDegreeNeighbors H (w i) d) := by
  classical
  obtain ⟨wg, heq, hadj, hd, hn⟩ := equivalent_local_neighborhood_match hk h hm hm0
    (fun i => Fintype.equivFin V (v i))
  let w (i : Fin m) : W := (Fintype.equivFin W).symm (wg i)
  have hw (i : Fin m) : Fintype.equivFin W (w i) = wg i := Equiv.apply_symm_apply _ _
  refine ⟨w, ?_, ?_, ?_, ?_⟩
  · intro i j
    exact (Fintype.equivFin V).injective.eq_iff.symm.trans
      ((heq i j).trans (Fintype.equivFin W).symm.injective.eq_iff.symm)
  · intro i j
    have hh := hadj i j
    rw [← hw i, ← hw j] at hh
    have hv := graphOfSimple_edge G (v i) (v j)
    have hw' := graphOfSimple_edge H (w i) (w j)
    exact decide_eq_decide.mp (hv.symm.trans (hh.trans hw'))
  · intro i
    have hh := hd i
    rw [← hw i] at hh
    exact (graphOfSimple_degree G (v i)).symm.trans (hh.trans (graphOfSimple_degree H (w i)))
  · intro i d
    have hh := hn i d
    rw [← hw i] at hh
    exact (graphOfSimple_degreeNeighbors G (v i) d).symm.trans
      (hh.trans (graphOfSimple_degreeNeighbors H (w i) d))

theorem simple_equivalent_local_finite {A V W : Type}
    [Fintype A] [Nonempty A] [Fintype V] [Fintype W]
    (G : SimpleGraph V) (H : SimpleGraph W) [DecidableRel G.Adj] [DecidableRel H.Adj]
    {k : ℕ} (hk : 2 ≤ k) (h : Equivalent k (graphOfSimple G) (graphOfSimple H))
    (hA : Fintype.card A ≤ k) (v : A → V) :
    ∃ w : A → W,
      (∀ i j, v i = v j ↔ w i = w j) ∧
      (∀ i j, G.Adj (v i) (v j) ↔ H.Adj (w i) (w j)) ∧
      (∀ i, G.degree (v i) = H.degree (w i)) ∧
      (∀ i d, simpleDegreeNeighbors G (v i) d = simpleDegreeNeighbors H (w i) d) := by
  obtain ⟨w, heq, hadj, hd, hn⟩ := simple_equivalent_local G H hk h hA
    Fintype.card_pos (fun i => v ((Fintype.equivFin A).symm i))
  refine ⟨w ∘ Fintype.equivFin A, ?_, ?_, ?_, ?_⟩
  · intro i j
    simpa only [Function.comp_def, Equiv.symm_apply_apply] using heq (Fintype.equivFin A i) (Fintype.equivFin A j)
  · intro i j
    simpa only [Function.comp_def, Equiv.symm_apply_apply] using hadj (Fintype.equivFin A i) (Fintype.equivFin A j)
  · intro i
    have hv := congrArg (fun a => G.degree (v a)) ((Fintype.equivFin A).symm_apply_apply i)
    exact hv.symm.trans (hd (Fintype.equivFin A i))
  · intro i d
    simpa only [Function.comp_def, Equiv.symm_apply_apply] using hn (Fintype.equivFin A i) d

/-- The diagonal-tuple degree bijection is independent of the chosen finite encoding. -/
theorem simple_equivalent_degreeBijection {V W : Type} [Fintype V] [Fintype W]
    (G : SimpleGraph V) (H : SimpleGraph W) [DecidableRel G.Adj] [DecidableRel H.Adj]
    {k : ℕ} (hk : 2 ≤ k) (h : Equivalent k (graphOfSimple G) (graphOfSimple H)) :
    ∃ e : V ≃ W, ∀ v, G.degree v = H.degree (e v) := by
  obtain ⟨e, he⟩ := equivalent_degreeBijection hk h
  let E := (Fintype.equivFin V).trans (e.trans (Fintype.equivFin W).symm)
  refine ⟨E, ?_⟩
  intro v
  have hh := he (Fintype.equivFin V v)
  exact (graphOfSimple_degree G v).symm.trans (hh.trans (graphOfSimple_degree_at H _))

theorem leaf_count_eq_degreeNeighbors {V : Type} [Fintype V] (ell : V → ℕ)
    (H : SimpleGraph (LeafVertex ell)) [DecidableRel H.Adj]
    (hleaf : ∀ (v : V) (j : Fin (ell v)), H.degree (.inr ⟨v, j⟩) = 1)
    (hbase : ∀ v, 1 < H.degree (.inl v)) (v : V) :
    Fintype.card {l : Σ v, Fin (ell v) // H.Adj (.inl v) (.inr l)} =
      simpleDegreeNeighbors H (.inl v) 1 := by
  classical
  let e : {l : Σ v, Fin (ell v) // H.Adj (.inl v) (.inr l)} ≃
      {x : LeafVertex ell // H.Adj (.inl v) x ∧ H.degree x = 1} := {
    toFun l := ⟨.inr l.val, l.property, hleaf l.val.1 l.val.2⟩
    invFun x := by
      rcases x with ⟨x, hx, hd⟩
      cases x with
      | inl w => exact False.elim (by have := hbase w; omega)
      | inr l => exact ⟨l, hx⟩
    left_inv _ := rfl
    right_inv x := by
      rcases x with ⟨x, hx, hd⟩
      cases x with
      | inl w => exact False.elim (by have := hbase w; omega)
      | inr l => rfl }
  rw [Fintype.card_congr e, Fintype.card_subtype]
  rfl

theorem tagged_degreeNeighbors_one {V : Type} [Fintype V] (G : SimpleGraph V)
    [DecidableRel G.Adj] (color : V → ℕ) (hc : ∀ v, 0 < color v) (v : V) :
    simpleDegreeNeighbors (withLeaves G (tagSize color)) (.inl v) 1 = tagSize color v := by
  classical
  rw [← leaf_count_eq_degreeNeighbors _ _ (withLeaves_leaf_degree G _) (tag_base_degree_gt_one G color hc)]
  let e : {l : Σ v, Fin (tagSize color v) // (withLeaves G (tagSize color)).Adj (.inl v) (.inr l)} ≃
      Fin (tagSize color v) := {
    toFun l := by
      have hl : v = l.val.1 := l.property
      exact hl.symm ▸ l.val.2
    invFun i := ⟨⟨v, i⟩, rfl⟩
    left_inv l := by
      rcases l with ⟨⟨w, i⟩, hw⟩
      change v = w at hw
      subst w
      rfl
    right_inv _ := rfl }
  exact (Fintype.card_congr e).trans (Fintype.card_fin _)

/-- An arbitrary WL mate of a leaf-coded graph has exactly the same leaf-coded
shape. This theorem quantifies over all finite mate graphs, with no gadget promise. -/
theorem tagged_arbitrary_mate {V W : Type} [Fintype V] [Fintype W]
    (G : SimpleGraph V) (H : SimpleGraph W) [DecidableRel G.Adj] [DecidableRel H.Adj]
    (color : V → ℕ) (hc : ∀ v, 0 < color v) {k : ℕ} (hk : 2 ≤ k)
    (h : Equivalent k (taggedGraph G color) (graphOfSimple H)) :
    ∃ G' : SimpleGraph V, Nonempty (withLeaves G' (tagSize color) ≃g H) := by
  classical
  let T := withLeaves G (tagSize color)
  obtain ⟨e, he⟩ := simple_equivalent_degreeBijection T H hk h
  let H' := H.comap e
  let E : H' ≃g H := SimpleGraph.Iso.comap e H
  have hd (v : LeafVertex (tagSize color)) : H'.degree v = T.degree v :=
    (E.degree_eq v).symm.trans (he v).symm
  have hleaf (v : V) (i : Fin (tagSize color v)) : H'.degree (.inr ⟨v, i⟩) = 1 := by
    rw [hd, withLeaves_leaf_degree]
  have hbase (v : V) : 1 < H'.degree (.inl v) := by
    rw [hd]
    exact tag_base_degree_gt_one G color hc v
  have heq : Equivalent k (graphOfSimple H') (graphOfSimple T) :=
    equivalent_trans (isomorphic_equivalent ((isomorphic_graphOfSimple_iff H' H).mpr ⟨E⟩) k)
      (equivalent_symm h)
  have hn (v : V) : simpleDegreeNeighbors H' (.inl v) 1 = tagSize color v := by
    obtain ⟨w, _, _, hw, hneigh⟩ := simple_equivalent_local H' T hk heq
      (m := 1) (by omega) (by omega) (fun _ => .inl v)
    have hdeg := hw 0
    have hh := hneigh 0 1
    cases hval : w 0 with
    | inr l =>
      rw [hval, withLeaves_leaf_degree] at hdeg
      have := hbase v
      omega
    | inl u =>
      rw [hval] at hdeg hh
      have hcu : color v = color u := by
        rw [hd] at hdeg
        have hdiv := congrArg (fun n => n / (Fintype.card V + 1)) hdeg
        simpa only [T, tag_degree_color] using hdiv
      rw [tagged_degreeNeighbors_one G color hc] at hh
      exact hh.trans (by simp only [tagSize, hcu])
  have hn' (v : V) : Fintype.card {l : Σ v, Fin (tagSize color v) // H'.Adj (.inl v) (.inr l)} =
      tagSize color v := (leaf_count_eq_degreeNeighbors _ H' hleaf hbase v).trans (hn v)
  obtain ⟨F, _⟩ := private_leaf_reconstruction (tagSize color) H' hleaf hn'
  exact ⟨H'.comap Sum.inl, ⟨F.trans E⟩⟩

/-- A bounded set of base vertices of equivalent tagged graphs has a simultaneous
color-preserving induced-graph match. Degree coding recovers the original colors. -/
theorem tagged_equivalent_local {A V W : Type} [Fintype A] [Nonempty A]
    [Fintype V] [Fintype W] (G : SimpleGraph V) (H : SimpleGraph W)
    [DecidableRel G.Adj] [DecidableRel H.Adj] (color : V → ℕ) (color' : W → ℕ)
    (hc : ∀ v, 0 < color v)
    (hN : Fintype.card V = Fintype.card W) {k : ℕ} (hk : 2 ≤ k)
    (h : Equivalent k (taggedGraph G color) (taggedGraph H color'))
    (hA : Fintype.card A ≤ k) (v : A → V) :
    ∃ w : A → W, (∀ i j, v i = v j ↔ w i = w j) ∧
      (∀ i j, G.Adj (v i) (v j) ↔ H.Adj (w i) (w j)) ∧
      (∀ i, color (v i) = color' (w i)) := by
  classical
  obtain ⟨w, he, ha, hd, _⟩ := simple_equivalent_local_finite
    (withLeaves G (tagSize color)) (withLeaves H (tagSize color')) hk h hA (fun i => .inl (v i))
  have hw (i : A) : ∃ u, w i = .inl u := by
    cases hh : w i with
    | inl u => exact ⟨u, rfl⟩
    | inr l =>
      have hd' := hd i
      rw [hh, withLeaves_leaf_degree] at hd'
      have := tag_base_degree_gt_one G color hc (v i)
      omega
  choose w' hw' using hw
  refine ⟨w', ?_, ?_, ?_⟩
  · intro i j
    simpa only [hw', Sum.inl.injEq] using he i j
  · intro i j
    simpa only [hw', withLeaves] using ha i j
  · intro i
    have hh := hd i
    rw [hw'] at hh
    have hdiv := congrArg (fun n => n / (Fintype.card V + 1)) hh
    rw [tag_degree_color, hN, tag_degree_color] at hdiv
    exact hdiv

namespace AffineBlocks

variable {C B : Type} [Fintype C] [DecidableEq C]

def AllowedName (D : AffineBlocks C B) (x y : C ⊕ B) : Prop :=
  match x, y with
  | .inl c, .inr b => c ∈ D.coordinates b
  | .inr b, .inl c => c ∈ D.coordinates b
  | _, _ => False

theorem allowed_name (D : AffineBlocks C B) {beta : B → Bit} (x y : D.Vertex beta) :
    D.Allowed x y ↔ D.AllowedName (D.colorName x) (D.colorName y) := by
  cases x <;> cases y <;> rfl

theorem piece_contains_color (D : AffineBlocks C B) {beta : B → Bit} (b : B)
    (x : D.Piece beta b) (y : D.Vertex beta)
    (h : D.colorName y = D.colorName (D.pieceEmbed b x)) :
    ∃ y' : D.Piece beta b, D.pieceEmbed b y' = y := by
  cases x with
  | inl p =>
    obtain ⟨a, ha⟩ := D.exists_bit_of_color y p.1.val h
    exact ⟨.inl (p.1, a), ha.symm⟩
  | inr v =>
    obtain ⟨u, hu⟩ := D.exists_valuation_of_color y b h
    exact ⟨.inr u, hu.symm⟩

variable [Fintype B]

/-- Bounded local WL information excludes every edge between forbidden colors. -/
theorem tagged_equivalent_allowed (D : AffineBlocks C B) (H : SimpleGraph (D.Vertex 0))
    [DecidableRel H.Adj] {k : ℕ} (hk : 2 ≤ k)
    (h : Equivalent k (D.graph 0) (taggedGraph H D.colorNat)) :
    ∀ x y, H.Adj x y → D.Allowed x y := by
  classical
  intro x y hxy
  obtain ⟨w, _, ha, hc⟩ := tagged_equivalent_local (A := Fin 2) H (D.baseGraph 0)
    D.colorNat D.colorNat D.colorNat_pos rfl hk (equivalent_symm h)
    (by simpa using hk) ![x, y]
  have he : (D.baseGraph 0).Adj (w 0) (w 1) := (ha 0 1).mp hxy
  have hcx := (D.colorNat_eq_iff _ _).mp (hc 0)
  have hcy := (D.colorNat_eq_iff _ _).mp (hc 1)
  change D.colorName x = D.colorName (w 0) at hcx
  change D.colorName y = D.colorName (w 1) at hcy
  have hallow := D.base_adj_allowed he
  rw [D.allowed_name] at hallow ⊢
  rw [hcx, hcy]
  exact hallow

/-- Match a complete incidence piece at once. Finite cardinality upgrades the
injective local match into an isomorphism of the entire piece. -/
theorem tagged_equivalent_piece (D : AffineBlocks C B) (H : SimpleGraph (D.Vertex 0))
    [DecidableRel H.Adj] {k : ℕ} (hk : 2 ≤ k)
    (h : Equivalent k (D.graph 0) (taggedGraph H D.colorNat)) (b : B)
    (hb : Fintype.card (D.Piece 0 b) ≤ k) :
    ∃ e : D.pieceGraph 0 b ≃g H.comap (D.pieceEmbed b),
      ∀ v, D.colorName (D.pieceEmbed b (e v)) = D.colorName (D.pieceEmbed b v) := by
  classical
  let : Nonempty (D.Piece 0 b) := ⟨.inr ⟨0, D.legal_zero b⟩⟩
  obtain ⟨w, he, ha, hc⟩ := tagged_equivalent_local (A := D.Piece 0 b) (D.baseGraph 0) H
    D.colorNat D.colorNat D.colorNat_pos rfl hk h hb (D.pieceEmbed b)
  have hw (x : D.Piece 0 b) : ∃ y : D.Piece 0 b, D.pieceEmbed b y = w x :=
    D.piece_contains_color b x (w x) ((D.colorNat_eq_iff _ _).mp (hc x)).symm
  choose f hf using hw
  have hfinj : Function.Injective f := by
    intro x y hxy
    apply (D.pieceEmbed b).injective
    apply (he x y).mpr
    rw [← hf x, ← hf y, hxy]
  let E := Equiv.ofBijective f ((Fintype.bijective_iff_injective_and_card f).mpr ⟨hfinj, rfl⟩)
  refine ⟨{ toEquiv := E, map_rel_iff' := ?_ }, ?_⟩
  · intro x y
    change H.Adj (D.pieceEmbed b (f x)) (D.pieceEmbed b (f y)) ↔
      (D.baseGraph 0).Adj (D.pieceEmbed b x) (D.pieceEmbed b y)
    rw [hf, hf]
    exact (ha x y).symm
  · intro x
    change D.colorName (D.pieceEmbed b (f x)) = _
    rw [hf]
    exact ((D.colorNat_eq_iff _ _).mp (hc x)).symm

/-- Full arbitrary-mate reconstruction, not pair-equivalence hardness: every
finite uncolored WL mate is isomorphic to some affine shift of the same system. -/
theorem graph_arbitrary_mate (D : AffineBlocks C B) {k : ℕ} (hk : 2 ≤ k)
    (hbound : ∀ b, Fintype.card (D.Piece 0 b) ≤ k) (H : Graph)
    (h : Equivalent k (D.graph 0) H) :
    ∃ beta : B → Bit, Isomorphic H (D.graph beta) := by
  classical
  have hS : Equivalent k (D.graph 0) (graphOfSimple (simpleOfGraph H)) :=
    equivalent_trans h (isomorphic_equivalent (graph_simple_isomorphic H) k)
  obtain ⟨H0, ⟨E⟩⟩ := tagged_arbitrary_mate (D.baseGraph 0) (simpleOfGraph H)
    D.colorNat D.colorNat_pos hk hS
  have hE := (isomorphic_graphOfSimple_iff _ _).mpr ⟨E⟩
  have h0 : Equivalent k (D.graph 0) (taggedGraph H0 D.colorNat) :=
    equivalent_trans hS (isomorphic_equivalent (isomorphic_symm hE) k)
  obtain ⟨beta, F, hF⟩ := D.base_reconstruction H0
    (D.tagged_equivalent_allowed H0 hk h0)
    (fun b => D.tagged_equivalent_piece H0 hk h0 b (hbound b))
  have hsize (v : D.Vertex beta) : tagSize D.colorNat v = tagSize D.colorNat (F v) := by
    dsimp only [tagSize]
    rw [D.vertex_card beta 0]
    exact congrArg (fun n => n * (Fintype.card (D.Vertex 0) + 1))
      ((D.colorNat_eq_iff _ _).mpr (hF v).symm)
  let T := withLeavesIso F (tagSize D.colorNat) (tagSize D.colorNat) hsize
  have hT : Isomorphic (D.graph beta) (taggedGraph H0 D.colorNat) :=
    (isomorphic_graphOfSimple_iff _ _).mpr ⟨T⟩
  refine ⟨beta, isomorphic_symm ?_⟩
  exact isomorphic_trans hT (isomorphic_trans hE (isomorphic_symm (graph_simple_isomorphic H)))

end AffineBlocks

end WLIdentification

end OAI