| 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 |
|
|
