introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
19 kB
import OAI.Computability.WeisfeilerLeman.Marking
namespace OAI
universe uV uW uD uP uE uT uL uA uB
namespace WLTime.Marking
variable {V : Type uV} {W : Type uW} {D : Type uD} [Fintype V] [Fintype W]
theorem degree_detect_base (G : SimpleGraph V) (H : SimpleGraph W)
(c : V β†’ D) (d : W β†’ D) (code : D β†’ β„•) (hcode : Function.Injective code)
(hpos : βˆ€ b, 0 < code b) (e : V ≃ W) (hc : βˆ€ v, c v = d (e v))
(q : β„•) (hN : 2 ≀ Fintype.card V) (x : V)
(y : Vertex W (fun v => code (d v)*(Fintype.card V+1)) q)
(hd : Pebble.degree (graph G (fun v => code (c v)*(Fintype.card V+1)) q) (.base x) =
Pebble.degree (graph H (fun v => code (d v)*(Fintype.card V+1)) q) y) :
βˆƒ z, y = .base z ∧ c x = d z := by
have hcard : Fintype.card V = Fintype.card W := Fintype.card_congr e
have hx : 2 < Pebble.degree (graph G (fun v => code (c v)*(Fintype.card V+1)) q) (.base x) := by
rw [degree_base]
have hm := Nat.mul_le_mul_right (Fintype.card V+1) (hpos (c x))
nlinarith
cases y with
| base z =>
refine ⟨z,rfl,hcode ?_⟩
rw [degree_base,degree_base] at hd
exact code_of_degree (base_degree_lt G x) (hcard β–Έ base_degree_lt H z) hd
| mark z i => rw [degree_mark] at hd; omega
| pad i => rw [degree_pad] at hd; omega
| hub =>
have hsum : (βˆ‘ v : W, code (d v)*(Fintype.card V+1)) =
βˆ‘ v : V, code (c v)*(Fintype.card V+1) := by
rw [← e.sum_comp (fun v => code (d v)*(Fintype.card V+1))]
simp_rw [← hc]
have hh := hub_above_base G (fun v => code (c v)*(Fintype.card V+1)) q hN
(fun v => Nat.mul_pos (hpos (c v)) (by omega)) x
rw [degree_hub] at hd hh
rw [← hcard,hsum] at hd
omega
def basePosition {K : β„•} {count : V β†’ β„•} {count' : W β†’ β„•} {q : β„•}
(P : Pebble.Position K V W) : Pebble.Position K (Vertex V count q) (Vertex W count' q) :=
fun i => (P i).map (fun xy => (.base xy.1,.base xy.2))
omit [Fintype V] [Fintype W] in
@[simp] theorem basePosition_update {K : β„•} {count : V β†’ β„•} {count' : W β†’ β„•} {q : β„•}
(P : Pebble.Position K V W) (i : Fin K) (x : V) (y : W) :
(basePosition (count := count) (count' := count') (q := q) (Function.update P i (some (x,y)))) =
Function.update (basePosition P) i (some (.base x,.base y)) := by
funext j
by_cases h : j=i
Β· subst j; simp [basePosition]
Β· simp [basePosition,h]
theorem wins_bases (G : SimpleGraph V) (H : SimpleGraph W)
(c : V β†’ D) (d : W β†’ D) (code : D β†’ β„•) (hcode : Function.Injective code)
(hpos : βˆ€ b, 0 < code b) (eβ‚€ : V ≃ W) (hc : βˆ€ v, c v = d (eβ‚€ v))
(q K : β„•) (hN : 2 ≀ Fintype.card V) (hK : 2 ≀ K)
(h : Pebble.Wins (graph G (fun v => code (c v)*(Fintype.card V+1)) q)
(graph H (fun v => code (d v)*(Fintype.card V+1)) q) (fun _ _ => True)
(fun _ : Fin K => none)) :
Pebble.Wins G H (fun v w => c v = d w) (fun _ : Fin K => none) := by
classical
let J : Pebble.Invariant G H (fun v w => c v = d w) K := {
safe := fun P => Pebble.Wins (graph G (fun v => code (c v)*(Fintype.card V+1)) q)
(graph H (fun v => code (d v)*(Fintype.card V+1)) q) (fun _ _ => True) (basePosition P)
forget := by
intro P Q hQ hPQ
refine hQ.forget (fun i => ?_)
rcases hPQ i with hi | hi
Β· exact Or.inl (by simp [basePosition,hi])
Β· exact Or.inr (by simp [basePosition,hi])
atomic := by
intro P hP
constructor
Β· intro i x y hi
have hdi := hP.degree_eq hK (i := i) (x := .base x) (y := .base y) (by simp [basePosition,hi])
obtain ⟨z,hz,hcz⟩ := degree_detect_base G H c d code hcode hpos eβ‚€ hc q hN x (.base y) hdi
cases Vertex.base.inj hz
exact hcz
Β· intro i j x y u v hi hj
have hh := hP.atomic.2 i j (.base x) (.base y) (.base u) (.base v)
(by simp [basePosition,hi]) (by simp [basePosition,hj])
simpa only [Vertex.base.injEq,graph,Adj] using hh
extend := by
intro P hP i hi
obtain ⟨e,he⟩ := hP.extend i (by simp [basePosition,hi])
have hb (x : V) : βˆƒ y, e (.base x) = .base y ∧ c x = d y := by
exact degree_detect_base G H c d code hcode hpos eβ‚€ hc q hN x (e (.base x))
((he (.base x)).degree_eq hK (Function.update_self _ _ _))
choose f hf hcf using hb
have hinj : Function.Injective f := by
intro x y hxy
exact Vertex.base.inj (e.injective (by rw [hf,hf,hxy]))
let eb : V ≃ W := Equiv.ofBijective f
((Fintype.bijective_iff_injective_and_card f).mpr ⟨hinj,Fintype.card_congr eβ‚€βŸ©)
refine ⟨eb,fun x => ?_⟩
rw [basePosition_update]
simpa only [hf,eb,Equiv.ofBijective_apply] using he (.base x) }
refine ⟨J,?_⟩
unfold J basePosition
exact h
end WLTime.Marking
namespace WLTime.Compression
namespace ConsistencyData
variable {r m : β„•} {P : Type uP} {E : Type uE} [Fintype P] [Fintype E]
(I : ConsistencyData (r+1) m P E)
noncomputable def baseEquiv (K : β„•) (hr : 1 ≀ r) : I.Vertex K 0 ≃ I.Vertex K 1 :=
Equiv.sigmaCongrRight (fun b => I.translate K b.val
(Classical.choice (I.legal_nonempty K hr 1 b.val)))
omit [Fintype P] [Fintype E] in
@[simp] theorem baseEquiv_block (K : β„•) (hr : 1 ≀ r) (x : I.Vertex K 0) :
(I.baseEquiv K hr x).1 = x.1 := rfl
noncomputable def blockCode (K : β„•) (b : I.Block K) : β„• :=
(Fintype.equivFin (I.Block K) b).val + 1
theorem blockCode_injective (K : β„•) : Function.Injective (I.blockCode K) := by
intro b c h
apply (Fintype.equivFin (I.Block K)).injective
apply Fin.ext
simpa only [blockCode,Nat.add_right_cancel_iff] using h
theorem blockCode_pos (K : β„•) (b : I.Block K) : 0 < I.blockCode K b := Nat.zero_lt_succ _
noncomputable def markCount (K : β„•) (b : I.Block K) : β„• :=
I.blockCode K b * (Fintype.card (I.Vertex K 0)+1)
abbrev MarkedVertex (K : β„•) (Ξ΅ : Fβ‚‚) (q : β„•) :=
Marking.Vertex (I.Vertex K Ξ΅) (fun v => I.markCount K v.1) q
noncomputable def markedGraph (K : β„•) (Ξ΅ : Fβ‚‚) (q : β„•) :
SimpleGraph (I.MarkedVertex K Ξ΅ q) :=
Marking.graph (I.valuationGraph K Ξ΅) (fun v => I.markCount K v.1) q
theorem marked_diameter_two (K : β„•) (Ξ΅ : Fβ‚‚) (q : β„•) (x y : I.MarkedVertex K Ξ΅ q) :
x=y ∨ (I.markedGraph K Ρ q).Adj x y ∨
βˆƒ z, (I.markedGraph K Ξ΅ q).Adj x z ∧ (I.markedGraph K Ξ΅ q).Adj z y :=
Marking.diameter_two _ x y
noncomputable def markedEquiv (K : β„•) (hr : 1 ≀ r) (q : β„•) :
I.MarkedVertex K 0 q ≃ I.MarkedVertex K 1 q :=
Marking.liftEquiv (I.baseEquiv K hr) (fun _ => rfl)
theorem card_marked_eq (K : β„•) (hr : 1 ≀ r) (q : β„•) :
Fintype.card (I.MarkedVertex K 0 q) = Fintype.card (I.MarkedVertex K 1 q) :=
Fintype.card_congr (I.markedEquiv K hr q)
theorem two_le_card_base [Nonempty P] (K : β„•) (hm : 2 ≀ m) :
2 ≀ Fintype.card (I.Vertex K 0) := by
classical
let p : P := Classical.choice inferInstance
let z : Fin m := ⟨0,by omega⟩
let f : Fin m β†’ I.Vertex K 0 := fun a =>
⟨⟨.site 0 (.inl p) a z,True.intro,True.intro⟩,I.zeroValuation K _⟩
have hf : Function.Injective f := by
intro a b h
have he := congrArg (fun x : I.Vertex K 0 => x.1.val) h
exact (BlockName.site.inj he).2.2.1
have hc := Fintype.card_le_of_injective f hf
simp only [Fintype.card_fin] at hc
omega
theorem marked_wins_iff_ac [Nonempty P] (hr : 2 ≀ r) (hm : 2 ≀ m) (q : β„•) :
Pebble.Wins (I.markedGraph (r+2) 0 q) (I.markedGraph (r+2) 1 q)
(fun _ _ => True) (fun _ : Fin (r+2) => none) ↔ I.ArcConsistent := by
classical
constructor
Β· intro h
apply (I.colored_wins_iff_ac hr).mp
exact Marking.wins_bases (I.valuationGraph (r+2) 0) (I.valuationGraph (r+2) 1)
Sigma.fst Sigma.fst (I.blockCode (r+2)) (I.blockCode_injective (r+2))
(I.blockCode_pos (r+2)) (I.baseEquiv (r+2) (by omega)) (fun _ => rfl)
q (r+2) (I.two_le_card_base (r+2) hm) (by omega) h
Β· intro h
obtain ⟨Q⟩ := I.arcConsistent_iff.mp h
exact (Marking.liftSystem Sigma.fst Sigma.fst (I.markCount (r+2)) q (r+2)
(I.valuationSystem Q (r+2) (by omega) hr le_rfl)).wins_empty
end ConsistencyData
end WLTime.Compression
namespace WLTime.Compression
noncomputable def BlockName.equivProduct {r : β„•} {T : Type uT} {L : Type uL} {A : Type uA} :
BlockName r T L A ≃ Fin (r+1) Γ— (T βŠ• L) Γ— A Γ— A where
toFun
| .site i t a b => (i,.inl t,a,b)
| .square i l a b => (i,.inr l,a,b)
invFun
| (i,.inl t,a,b) => .site i t a b
| (i,.inr l,a,b) => .square i l a b
left_inv x := by cases x <;> rfl
right_inv x := by rcases x with ⟨i,t | l,a,b⟩ <;> rfl
theorem BlockName.card {r : β„•} {T : Type uT} {L : Type uL} {A : Type uA} [Fintype T] [Fintype L] [Fintype A] :
Fintype.card (BlockName r T L A) =
(r+1)*(Fintype.card T+Fintype.card L)*(Fintype.card A)^2 := by
rw [Fintype.card_congr BlockName.equivProduct]
simp only [Fintype.card_prod,Fintype.card_sum,Fintype.card_fin]
ring
namespace ConsistencyData
variable {r m : β„•} {P : Type uP} {E : Type uE} [Fintype P] [Fintype E]
(I : ConsistencyData (r+1) m P E)
noncomputable def blockCoefficient (_I : ConsistencyData (r+1) m P E) (K : β„•) : β„• :=
(r+1)*(Fintype.card P+Fintype.card E*(8*K+1))
theorem card_blocks_le (K : β„•) : Fintype.card (I.Block K) ≀ I.blockCoefficient K*m^2 := by
classical
calc
_ ≀ Fintype.card (RawBlock (r := r) (m := m) (P := P) (E := E) K) :=
Fintype.card_subtype_le _
_ = _ := by
rw [BlockName.card]
simp only [TypeNode,TypeLink,Fintype.card_sum,Fintype.card_prod,Fintype.card_fin,
blockCoefficient]
ring
omit [Fintype P] [Fintype E] in
theorem footprint_card_le (K : β„•)
(b : RawBlock (r := r) (m := m) (P := P) (E := E) K) :
(I.footprint K b).card ≀ 4 := by
classical
cases b <;> simp only [footprint]
Β· simp
Β· exact (Finset.card_insert_le _ _).trans (Nat.succ_le_succ
((Finset.card_insert_le _ _).trans (Nat.succ_le_succ
((Finset.card_insert_le _ _).trans (by simp)))))
omit [Fintype P] [Fintype E] in
theorem card_readValue_le (K D : β„•) (hD : 2 ≀ D) (hp : βˆ€ p, 2^(I.dim p) ≀ D)
(n : RawName (r := r) (m := m) (P := P) (E := E) K) :
Fintype.card (I.ReadValue K n) ≀ D := by
cases n with
| horizontal i t a b =>
cases t with
| inl p => simpa [ReadValue,Value,Fβ‚‚,ZMod.card] using hp p
| inr ej => simpa [ReadValue,Value,Fβ‚‚,ZMod.card] using hD
| vertical => simpa [ReadValue,Fβ‚‚,ZMod.card] using hD
theorem card_legal_le (K D : β„•) (hD : 2 ≀ D) (hp : βˆ€ p, 2^(I.dim p) ≀ D)
(Ξ΅ : Fβ‚‚) (b : I.Block K) : Fintype.card (I.Legal K Ξ΅ b.val) ≀ D^4 := by
classical
let f : I.Legal K Ξ΅ b.val β†’ ((n : {n // n ∈ I.footprint K b.val}) β†’ I.ReadValue K n.val) :=
fun R n => R.val.val n.val
have hf : Function.Injective f := by
intro R S h
apply Subtype.ext
apply Subtype.ext
funext n
by_cases hn : n ∈ I.footprint K b.val
· exact congrFun h ⟨n,hn⟩
Β· exact (R.val.property n hn).trans (S.val.property n hn).symm
calc
_ ≀ Fintype.card ((n : {n // n ∈ I.footprint K b.val}) β†’ I.ReadValue K n.val) :=
Fintype.card_le_of_injective f hf
_ = ∏ n : {n // n ∈ I.footprint K b.val}, Fintype.card (I.ReadValue K n.val) :=
Fintype.card_pi
_ ≀ ∏ _n : {n // n ∈ I.footprint K b.val}, D :=
Finset.prod_le_prod (fun n _ => I.card_readValue_le K D hD hp n.val)
_ = D^(I.footprint K b.val).card := by simp
_ ≀ D^4 := Nat.pow_le_pow_right (by omega) (I.footprint_card_le K b.val)
theorem card_bases_le (K D : β„•) (hD : 2 ≀ D) (hp : βˆ€ p, 2^(I.dim p) ≀ D) (Ξ΅ : Fβ‚‚) :
Fintype.card (I.Vertex K Ξ΅) ≀ I.blockCoefficient K*D^4*m^2 := by
classical
calc
_ = βˆ‘ b : I.Block K, Fintype.card (I.Legal K Ξ΅ b.val) := Fintype.card_sigma
_ ≀ βˆ‘ _b : I.Block K, D^4 := Finset.sum_le_sum (fun b _ => I.card_legal_le K D hD hp Ξ΅ b)
_ = Fintype.card (I.Block K)*D^4 := by simp
_ ≀ (I.blockCoefficient K*m^2)*D^4 := Nat.mul_le_mul_right _ (I.card_blocks_le K)
_ = _ := by ring
theorem card_blocks_le_bases (K : β„•) : Fintype.card (I.Block K) ≀ Fintype.card (I.Vertex K 0) := by
exact Fintype.card_le_of_injective (fun b : I.Block K => (⟨b,I.zeroValuation K b.val⟩ : I.Vertex K 0))
(fun _ _ h => congrArg Sigma.fst h)
theorem marked_order_cubic (K q : β„•) :
Fintype.card (I.MarkedVertex K 0 q) ≀ (Fintype.card (I.Vertex K 0)+1)^3+q := by
classical
rw [Marking.card_vertices]
have hmark (v : I.Vertex K 0) : I.markCount K v.1 ≀
Fintype.card (I.Vertex K 0)*(Fintype.card (I.Vertex K 0)+1) := by
apply Nat.mul_le_mul_right
exact (Nat.succ_le_iff.mpr (Fintype.equivFin (I.Block K) v.1).isLt).trans (I.card_blocks_le_bases K)
have hs := Finset.sum_le_sum (fun v (_ : v ∈ (Finset.univ : Finset (I.Vertex K 0))) => hmark v)
simp only [Finset.sum_const,Finset.card_univ,smul_eq_mul] at hs
nlinarith
theorem marked_order_six (K D : β„•) (hm : 1 ≀ m) (hD : 2 ≀ D)
(hp : βˆ€ p, 2^(I.dim p) ≀ D) (q : β„•) :
Fintype.card (I.MarkedVertex K 0 q) ≀ (I.blockCoefficient K*D^4+1)^3*m^6+q := by
have hN := I.card_bases_le K D hD hp 0
have hm2 : 1 ≀ m^2 := Nat.one_le_pow _ _ hm
calc
_ ≀ (Fintype.card (I.Vertex K 0)+1)^3+q := I.marked_order_cubic K q
_ ≀ (I.blockCoefficient K*D^4*m^2+1)^3+q := by gcongr
_ ≀ ((I.blockCoefficient K*D^4+1)*m^2)^3+q := by gcongr; nlinarith
_ = _ := by ring
end ConsistencyData
end WLTime.Compression
namespace WLTime
noncomputable def Graph.ofSimple {V : Type uV} {n : β„•} (G : SimpleGraph V) (e : V ≃ Fin n) : Graph n := by
classical
exact ⟨fun x y => decide (G.Adj (e.symm x) (e.symm y)),
(by intro x y; simp only [decide_eq_decide]; exact G.adj_comm _ _),fun x => by simp⟩
def Graph.simple {n : β„•} (G : Graph n) : SimpleGraph (Fin n) where
Adj x y := G.adj x y = true
symm := ⟨fun x y h => (G.property.1 y x).trans h⟩
loopless := ⟨fun x h => Bool.false_ne_true ((G.property.2 x).symm.trans h)⟩
@[simp] theorem Graph.ofSimple_adj {V : Type uV} {n : β„•} (G : SimpleGraph V)
(e : V ≃ Fin n) (x y : V) :
((Graph.ofSimple G e).simple).Adj (e x) (e y) ↔ G.Adj x y := by
simp [Graph.ofSimple,Graph.simple,Graph.adj]
@[simp] theorem Graph.ofSimple_diameter {V : Type uV} {n : β„•} (G : SimpleGraph V)
(e : V ≃ Fin n) (hn : 0 < n)
(h : βˆ€ x y, x=y ∨ G.Adj x y ∨ βˆƒ z, G.Adj x z ∧ G.Adj z y) :
(Graph.ofSimple G e).diameterTwo := by
refine ⟨hn,fun x y => ?_⟩
rcases h (e.symm x) (e.symm y) with he | he | ⟨z,hz,hz'⟩
Β· exact Or.inl (e.symm.injective he)
Β· exact Or.inr (Or.inl (by simpa [Graph.ofSimple,Graph.adj] using he))
· exact Or.inr (Or.inr ⟨e z,by simpa [Graph.ofSimple,Graph.adj] using hz,
by simpa [Graph.ofSimple,Graph.adj] using hz'⟩)
theorem pebble_iff_wins {n K : β„•} (G H : Graph n) (P : Position K n) :
Pebble.Wins G.simple H.simple (fun _ _ => True) P ↔ Wins G H P := by
constructor
· rintro ⟨I,hI⟩
let J : GameInvariant G H K := {
safe := I.safe
forget := I.forget
atomic := by
intro Q hQ i j x y u v hi hj
obtain ⟨he,ha⟩ := (I.atomic hQ).2 i j x y u v hi hj
refine ⟨he,?_⟩
change (G.adj x u = true ↔ H.adj y v = true) at ha
cases hg : G.adj x u <;> cases hh : H.adj y v <;> simp_all
extend := I.extend }
exact ⟨J,hI⟩
· rintro ⟨I,hI⟩
let J : Pebble.Invariant G.simple H.simple (fun _ _ => True) K := {
safe := I.safe
forget := I.forget
atomic := by
intro Q hQ
refine ⟨fun _ _ _ _ => True.intro,?_⟩
intro i j x y u v hi hj
obtain ⟨he,ha⟩ := I.atomic hQ i j x y u v hi hj
exact ⟨he,by change (_ = true ↔ _ = true); rw [ha]⟩
extend := I.extend }
exact ⟨J,hI⟩
theorem wins_ofSimple_iff {A : Type uA} {B : Type uB} {n K : β„•} (G : SimpleGraph A) (H : SimpleGraph B)
(e : A ≃ Fin n) (f : B ≃ Fin n) :
Wins (Graph.ofSimple G e) (Graph.ofSimple H f) (fun _ : Fin K => none) ↔
Pebble.Wins G H (fun _ _ => True) (fun _ : Fin K => none) := by
rw [← pebble_iff_wins]
constructor
Β· intro h
have hh := h.transport (G' := G) (H' := H) e.symm f.symm
(fun x y => by simp [Graph.ofSimple,Graph.simple,Graph.adj])
(fun x y => by simp [Graph.ofSimple,Graph.simple,Graph.adj])
simpa only [Pebble.Position.map_none] using hh
Β· intro h
have hh := h.transport e f (fun x y => (Graph.ofSimple_adj G e x y).symm)
(fun x y => (Graph.ofSimple_adj H f x y).symm)
simpa only [Pebble.Position.map_none] using hh
end WLTime
namespace WLTime.Compression
namespace ConsistencyData
variable {r m : β„•} {P : Type uP} {E : Type uE} [Fintype P] [Fintype E]
(I : ConsistencyData (r+1) m P E)
theorem marked_padding_order (K q : β„•) :
Fintype.card (I.MarkedVertex K 0 q) = Fintype.card (I.MarkedVertex K 0 0)+q := by
rw [Marking.card_vertices,Marking.card_vertices]
theorem matrix_compression [Nonempty P] (hr : 2 ≀ r) (hm : 2 ≀ m) (n : β„•)
(hn : Fintype.card (I.MarkedVertex (r+2) 0 0) ≀ n) :
βˆƒ G H : Graph n, G.diameterTwo ∧ H.diameterTwo ∧
(Equivalent .joint (r+1) G H ↔ I.ArcConsistent) ∧
(Equivalent .separate (r+2) G H ↔ I.ArcConsistent) := by
classical
let q := n-Fintype.card (I.MarkedVertex (r+2) 0 0)
have hcard : Fintype.card (I.MarkedVertex (r+2) 0 q) = n := by
rw [I.marked_padding_order]
exact Nat.add_sub_of_le hn
let e : I.MarkedVertex (r+2) 0 q ≃ Fin n :=
(Fintype.equivFin _).trans (finCongr hcard)
let f : I.MarkedVertex (r+2) 1 q ≃ Fin n :=
(I.markedEquiv (r+2) (by omega) q).symm.trans e
have hnpos : 0 < n := hcard β–Έ Fintype.card_pos_iff.mpr ⟨Marking.Vertex.hub⟩
let G := Graph.ofSimple (I.markedGraph (r+2) 0 q) e
let H := Graph.ofSimple (I.markedGraph (r+2) 1 q) f
refine ⟨G,H,Graph.ofSimple_diameter _ _ hnpos (I.marked_diameter_two _ _ _),
Graph.ofSimple_diameter _ _ hnpos (I.marked_diameter_two _ _ _),?_,?_⟩
Β· exact (joint_equivalent_iff_wins hnpos (by omega)).trans
((wins_ofSimple_iff _ _ e f).trans (I.marked_wins_iff_ac hr hm q))
Β· exact (separate_equivalent_iff_wins hnpos).trans
((wins_ofSimple_iff _ _ e f).trans (I.marked_wins_iff_ac hr hm q))
theorem matrix_compression_six [Nonempty P] (hr : 2 ≀ r) (hm : 2 ≀ m)
(D : β„•) (hD : 2 ≀ D) (hp : βˆ€ p, 2^(I.dim p) ≀ D) (n : β„•)
(hn : (I.blockCoefficient (r+2)*D^4+1)^3*m^6 ≀ n) :
βˆƒ G H : Graph n, G.diameterTwo ∧ H.diameterTwo ∧
(Equivalent .joint (r+1) G H ↔ I.ArcConsistent) ∧
(Equivalent .separate (r+2) G H ↔ I.ArcConsistent) := by
apply I.matrix_compression hr hm n
have h := I.marked_order_six (r+2) D (by omega) hD hp 0
simp only [Nat.add_zero] at h
exact h.trans hn
end ConsistencyData
end WLTime.Compression
end OAI