| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.WalkLength |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| open scoped ENNReal NNReal |
|
|
| structure LabelCoverData (U V L R C : Type*) where |
| left : C → U |
| right : C → V |
| project : C → L → R |
|
|
| def LabelCoverData.Satisfied {U V L R C : Type*} (lc : LabelCoverData U V L R C) |
| (ℓ : U → L) (ρ : V → R) : Prop := |
| ∀ c, lc.project c (ℓ (lc.left c)) = ρ (lc.right c) |
|
|
| def MixedTuple (A B : Type*) (n i : ℕ) := |
| {x : Fin n → B ⊕ A // ∀ h, (x h).isLeft = decide (h.val < i)} |
|
|
| noncomputable def MixedTuple.map {A B A' B' : Type*} {n i : ℕ} |
| (l : A → A') (r : B → B') (x : MixedTuple A B n i) : MixedTuple A' B' n i := |
| ⟨fun h => Sum.map r l (x.val h), by |
| intro h |
| simpa only [Sum.isLeft_map] using x.property h⟩ |
|
|
| def mixedProject {L R : Type*} {n : ℕ} (h : Fin n) (π : L → R) |
| (x : MixedTuple L R n h.val) : MixedTuple L R n (h.val + 1) := |
| ⟨fun k => if k = h then Sum.inl ((x.val k).elim id π) else x.val k, by |
| intro k |
| by_cases hk : k = h |
| · subst k |
| simp |
| · simp only [ite_eq_right hk, x.property k] |
| have hne : k.val ≠ h.val := fun e => hk (Fin.ext e) |
| have he : (k.val < h.val) = (k.val < h.val + 1) := propext (by omega) |
| simp only [he]⟩ |
|
|
| abbrev LayerQuestion (U V : Type*) (n : ℕ) := |
| Σ i : Fin (n + 1), MixedTuple U V n i.val |
|
|
| abbrev LayerAnswer {U V : Type*} (L R : Type*) {n : ℕ} |
| (q : LayerQuestion U V n) := MixedTuple L R n q.1.val |
|
|
| inductive LayerImposed {U V L R C : Type*} (lc : LabelCoverData U V L R C) (n : ℕ) : |
| (q q' : LayerQuestion U V n) → (LayerAnswer L R q → LayerAnswer L R q') → Prop |
| | adjacent (h : Fin n) (q : MixedTuple U V n h.val) |
| (q' : MixedTuple U V n (h.val + 1)) (c : C) |
| (hleft : q.val h = Sum.inr (lc.left c)) |
| (hright : q'.val h = Sum.inl (lc.right c)) |
| (houtside : ∀ k, k ≠ h → q.val k = q'.val k) : |
| LayerImposed lc n ⟨h.castSucc, q⟩ ⟨h.succ, q'⟩ (mixedProject h (lc.project c)) |
|
|
| def layeredSystem {U V L R C : Type*} (lc : LabelCoverData U V L R C) (n : ℕ) : |
| ProjectionSystem (LayerQuestion U V n) (LayerAnswer L R) where |
| imposed := LayerImposed lc n |
|
|
| noncomputable def productLabeling {U V L R : Type*} {n : ℕ} |
| (ℓ : U → L) (ρ : V → R) (q : LayerQuestion U V n) : LayerAnswer L R q := |
| MixedTuple.map ℓ ρ q.2 |
|
|
| theorem productLabeling_consistent {U V L R C : Type*} |
| (lc : LabelCoverData U V L R C) (n : ℕ) (ℓ : U → L) (ρ : V → R) |
| (hsat : lc.Satisfied ℓ ρ) : |
| (layeredSystem lc n).Consistent (productLabeling ℓ ρ) := by |
| intro q q' π hπ |
| cases hπ with |
| | adjacent h q q' c hleft hright houtside => |
| apply Subtype.ext |
| funext k |
| by_cases hk : k = h |
| · subst k |
| simp [mixedProject, productLabeling, MixedTuple.map, |
| hleft, hright, hsat c] |
| · simp only [mixedProject, productLabeling, MixedTuple.map, ite_eq_right hk, |
| houtside k hk] |
|
|
| theorem layered_completeness {U V L R C : Type*} |
| (lc : LabelCoverData U V L R C) (n : ℕ) (ℓ : U → L) (ρ : V → R) |
| (hsat : lc.Satisfied ℓ ρ) {D : ℕ} [NeZero D] (hD : Even D) : |
| (∀ x : GridLocation (LayerAnswer L R (U := U) (V := V) (n := n)) D, |
| ¬pathDistance (layeredSystem lc n).linkLength x (gridAntipode x) ≤ |
| ENNReal.ofReal (1 / 8)) ∧ |
| (∀ (W : Type*) (location : W → GridLocation (LayerAnswer L R |
| (U := U) (V := V) (n := n)) D), |
| ∃ color : W → Fin 3, ∀ u v, (gridGraph (layeredSystem lc n) hD location).Adj u v → |
| color u ≠ color v) := by |
| have h := productLabeling_consistent lc n ℓ ρ hsat |
| exact ⟨(projection_grid_completeness.{_, _, 0} (layeredSystem lc n) hD _ h).1, |
| fun W location => gridGraph_three_coloring (layeredSystem lc n) hD _ h location⟩ |
|
|
| noncomputable def distanceBump (d : ℝ≥0∞) : ℝ := |
| if d = ⊤ then 0 else max (1 - 32 * d.toReal) 0 |
|
|
| lemma distanceBump_bounds (d : ℝ≥0∞) : 0 ≤ distanceBump d ∧ distanceBump d ≤ 1 := by |
| unfold distanceBump |
| split_ifs |
| · norm_num |
| · refine ⟨le_max_right _ _, max_le ?_ (by norm_num)⟩ |
| have := ENNReal.toReal_nonneg (a := d) |
| linarith |
|
|
| @[simp] lemma distanceBump_zero : distanceBump 0 = 1 := by |
| norm_num [distanceBump] |
|
|
| lemma distanceBump_vanish {d : ℝ≥0∞} (hd : ENNReal.ofReal (1 / 32) ≤ d) : |
| distanceBump d = 0 := by |
| unfold distanceBump |
| split_ifs with htop |
| · rfl |
| · have hr := ENNReal.toReal_mono htop hd |
| norm_num at hr |
| exact max_eq_right (by linarith) |
|
|
| lemma distanceBump_difference {a b c : ℝ≥0∞} (hc : c ≠ ⊤) |
| (hab : a ≤ c + b) (hba : b ≤ c + a) : |
| |distanceBump a - distanceBump b| ≤ 32 * c.toReal := by |
| by_cases ha : a = ⊤ |
| · by_cases hb : b = ⊤ |
| · simp only [distanceBump, ha, hb, ite_eq_left, sub_self, abs_zero] |
| exact mul_nonneg (by norm_num) ENNReal.toReal_nonneg |
| · have htop : c + b = ⊤ := top_le_iff.mp (ha ▸ hab) |
| exact False.elim ((ENNReal.add_ne_top.mpr ⟨hc, hb⟩) htop) |
| · by_cases hb : b = ⊤ |
| · have htop : c + a = ⊤ := top_le_iff.mp (hb ▸ hba) |
| exact False.elim ((ENNReal.add_ne_top.mpr ⟨hc, ha⟩) htop) |
| · have har := (ENNReal.toReal_le_toReal ha (ENNReal.add_ne_top.mpr ⟨hc, hb⟩)).mpr hab |
| have hbr := (ENNReal.toReal_le_toReal hb (ENNReal.add_ne_top.mpr ⟨hc, ha⟩)).mpr hba |
| rw [ENNReal.toReal_add hc hb] at har |
| rw [ENNReal.toReal_add hc ha] at hbr |
| simp only [distanceBump, ite_eq_right ha, ite_eq_right hb] |
| calc |
| _ ≤ max |(1 - 32 * a.toReal) - (1 - 32 * b.toReal)| |(0 : ℝ) - 0| := |
| abs_max_sub_max_le_max _ _ _ _ |
| _ = |(1 - 32 * a.toReal) - (1 - 32 * b.toReal)| := by simp |
| _ ≤ 32 * c.toReal := by |
| rw [abs_le] |
| constructor <;> linarith |
|
|
| noncomputable def setBump {X : Type*} [PseudoEMetricSpace X] (A : Set X) (x : X) : ℝ := |
| distanceBump (Metric.infEDist x A) |
|
|
| lemma setBump_lipschitz {X : Type*} [PseudoEMetricSpace X] (A : Set X) : |
| LipschitzWith 32 (setBump A) := by |
| intro x y |
| by_cases hc : edist x y = ⊤ |
| · simp [hc] |
| · have h := distanceBump_difference hc |
| (Metric.infEDist_le_edist_add_infEDist (x := x) (y := y) (s := A)) |
| (by simpa only [edist_comm x y] using |
| (Metric.infEDist_le_edist_add_infEDist (x := y) (y := x) (s := A))) |
| have hh := ENNReal.ofReal_le_ofReal h |
| simpa only [setBump, edist_dist, Real.dist_eq, ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 32), |
| ENNReal.ofReal_toReal hc, ENNReal.ofReal_ofNat, ENNReal.coe_ofNat] using hh |
|
|
| noncomputable def oddBump {X : Type*} [PseudoEMetricSpace X] |
| (T : X → X) (A : Set X) (x : X) : ℝ := setBump A x - setBump A (T x) |
|
|
| lemma oddBump_bounds {X : Type*} [PseudoEMetricSpace X] |
| (T : X → X) (A : Set X) (x : X) : -1 ≤ oddBump T A x ∧ oddBump T A x ≤ 1 := by |
| have hx := distanceBump_bounds (Metric.infEDist x A) |
| have htx := distanceBump_bounds (Metric.infEDist (T x) A) |
| unfold oddBump setBump |
| constructor <;> linarith |
|
|
| lemma oddBump_odd {X : Type*} [PseudoEMetricSpace X] (T : X → X) |
| (hT : Function.Involutive T) (A : Set X) (x : X) : |
| oddBump T A (T x) = -oddBump T A x := by |
| simp only [oddBump, hT x] |
| ring |
|
|
| lemma oddBump_lipschitz {X : Type*} [PseudoEMetricSpace X] |
| (T : X → X) (hT : Isometry T) (A : Set X) : LipschitzWith 64 (oddBump T A) := by |
| have h := (setBump_lipschitz A).sub ((setBump_lipschitz A).comp hT.lipschitzWith) |
| norm_num only [mul_one, Nat.reduceAdd] at h |
| exact h |
|
|
| lemma oddBump_eq_one {X : Type*} [PseudoEMetricSpace X] |
| (T : X → X) (A : Set X) |
| (hsep : ∀ x ∈ A, ∀ y ∈ A, ENNReal.ofReal (1 / 8) < edist x (T y)) |
| {x : X} (hx : x ∈ A) : oddBump T A x = 1 := by |
| have hdist : ENNReal.ofReal (1 / 32) ≤ Metric.infEDist (T x) A := by |
| apply Metric.le_infEDist.mpr |
| intro y hy |
| rw [edist_comm] |
| exact (by norm_num : ENNReal.ofReal (1 / 32) ≤ ENNReal.ofReal (1 / 8)).trans |
| (hsep y hy x hx).le |
| simp only [oddBump, setBump, Metric.infEDist_zero_of_mem hx, |
| distanceBump_zero, distanceBump_vanish hdist, sub_zero] |
|
|
| lemma linkLength_le_copyLength {Q : Type*} {M : Q → Type*} |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] (x y : GridLocation M D) : |
| S.linkLength x y ≤ copyLength x y := by |
| classical |
| unfold ProjectionSystem.linkLength |
| split_ifs <;> simp |
|
|
| lemma grid_independent_separation {Q : Type*} {M : Q → Type*} |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] (hD : Even D) |
| (hnoclique : ∀ x : GridLocation M D, |
| ¬pathDistance S.linkLength x (gridAntipode x) ≤ ENNReal.ofReal (1 / 8)) |
| {V : Type*} (location : V → GridLocation M D) (A : Set V) |
| (hA : (gridGraph S hD location).IsIndepSet A) : |
| ∀ x ∈ location '' A, ∀ y ∈ location '' A, |
| ENNReal.ofReal (1 / 8) < pathDistance S.linkLength x (gridAntipode y) := by |
| rintro x ⟨u, hu, rfl⟩ y ⟨v, hv, rfl⟩ |
| by_contra hn |
| have hle := le_of_not_gt hn |
| by_cases h : u = v |
| · subst v |
| exact hnoclique (location u) hle |
| · exact ((gridGraph S hD location).isIndepSet_iff.mp hA) hu hv h ⟨h, hle⟩ |
|
|
| noncomputable def gridBump {Q : Type*} {M : Q → Type*} |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] |
| (A : Set (GridLocation M D)) (x : GridLocation M D) : ℝ := by |
| letI := linkPseudoEMetric (S.linkLength (D := D)) (linkLength_self S) (linkLength_symm S) |
| exact oddBump gridAntipode A x |
|
|
| theorem grid_independent_bump {Q : Type*} {M : Q → Type*} [∀ q, Fintype (M q)] |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] (hD : Even D) |
| (hnoclique : ∀ x : GridLocation M D, |
| ¬pathDistance S.linkLength x (gridAntipode x) ≤ ENNReal.ofReal (1 / 8)) |
| {V : Type*} (location : V → GridLocation M D) (A : Set V) |
| (hA : (gridGraph S hD location).IsIndepSet A) : |
| let f := gridBump S (location '' A) |
| (∀ x, -1 ≤ f x ∧ f x ≤ 1) ∧ |
| (∀ x, f (gridAntipode x) = -f x) ∧ |
| (∀ v ∈ A, f (location v) = 1) ∧ |
| (∀ x y, S.ZeroLink D x y → f x = f y) ∧ |
| (∀ q (u v : M q → ZMod D), |
| edist (f ⟨q, u⟩) (f ⟨q, v⟩) ≤ (64 : ℝ≥0∞) * |
| edist (fun k => ZMod.toAddCircle (u k)) (fun k => ZMod.toAddCircle (v k))) := by |
| let := linkPseudoEMetric (S.linkLength (D := D)) (linkLength_self S) (linkLength_symm S) |
| have hT : Isometry (gridAntipode : GridLocation M D → GridLocation M D) := |
| pathDistance_invariant S.linkLength gridAntipode (gridAntipode_involutive hD) |
| (linkLength_antipode S hD) |
| have hf : LipschitzWith 64 (gridBump S (location '' A)) := |
| oddBump_lipschitz gridAntipode hT (location '' A) |
| refine ⟨oddBump_bounds gridAntipode (location '' A), |
| oddBump_odd gridAntipode (gridAntipode_involutive hD) (location '' A), ?_, ?_, ?_⟩ |
| · intro v hv |
| exact oddBump_eq_one gridAntipode (location '' A) |
| (grid_independent_separation S hD hnoclique location A hA) ⟨v, hv, rfl⟩ |
| · intro x y hxy |
| have hpath : pathDistance S.linkLength x y = 0 := by |
| apply le_antisymm _ bot_le |
| apply (pathDistance_le_link S.linkLength x y).trans |
| simp [ProjectionSystem.linkLength, hxy] |
| have h := hf x y |
| change edist (gridBump S (location '' A) x) (gridBump S (location '' A) y) ≤ |
| (64 : ℝ≥0∞) * pathDistance S.linkLength x y at h |
| rw [hpath, mul_zero] at h |
| exact edist_eq_zero.mp (le_antisymm h bot_le) |
| · intro q u v |
| apply (hf ⟨q, u⟩ ⟨q, v⟩).trans |
| simp only [ENNReal.coe_ofNat] |
| apply mul_le_mul_right |
| change pathDistance S.linkLength ⟨q, u⟩ ⟨q, v⟩ ≤ _ |
| apply (pathDistance_le_link S.linkLength _ _).trans |
| apply (linkLength_le_copyLength S _ _).trans_eq |
| rw [copyLength_same, edist_pi_def] |
| simp only [Finset.sup_univ_eq_iSup] |
|
|
| noncomputable def finiteMcShane {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (x : X) : ℝ := |
| Finset.univ.inf' Finset.univ_nonempty (fun y => f y + L * dist x (e y)) |
|
|
| lemma finiteMcShane_le {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (x : X) (y : G) : |
| finiteMcShane e f L x ≤ f y + L * dist x (e y) := |
| Finset.inf'_le _ (Finset.mem_univ y) |
|
|
| lemma finiteMcShane_on_grid {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) |
| (hf : ∀ x y, |f x - f y| ≤ L * dist (e x) (e y)) (x : G) : |
| finiteMcShane e f L (e x) = f x := by |
| apply le_antisymm |
| · simpa using finiteMcShane_le e f L (e x) x |
| · apply Finset.le_inf' |
| intro y _ |
| have := (abs_le.mp (hf x y)).2 |
| linarith |
|
|
| lemma finiteMcShane_lipschitz {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) : |
| LipschitzWith L (finiteMcShane e f L) := by |
| have hle (x y : X) : finiteMcShane e f L x ≤ finiteMcShane e f L y + L * dist x y := by |
| obtain ⟨g, _, hg⟩ := Finset.exists_mem_eq_inf' (s := (Finset.univ : Finset G)) |
| Finset.univ_nonempty (fun g => f g + L * dist y (e g)) |
| change finiteMcShane e f L y = _ at hg |
| have hm := mul_le_mul_of_nonneg_left (dist_triangle x y (e g)) L.coe_nonneg |
| have h := finiteMcShane_le e f L x g |
| rw [hg] |
| linarith |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| rw [Real.dist_eq, abs_le] |
| have h₁ := hle x y |
| have h₂ := hle y x |
| rw [dist_comm y x] at h₂ |
| constructor <;> linarith |
|
|
| def clipUnit (x : ℝ) : ℝ := max (-1) (min 1 x) |
|
|
| lemma clipUnit_bounds (x : ℝ) : -1 ≤ clipUnit x ∧ clipUnit x ≤ 1 := by |
| exact ⟨le_max_left _ _, max_le (by norm_num) (min_le_left _ _)⟩ |
|
|
| lemma clipUnit_eq {x : ℝ} (hx : -1 ≤ x ∧ x ≤ 1) : clipUnit x = x := by |
| simp [clipUnit, min_eq_right hx.2, max_eq_right hx.1] |
|
|
| lemma clipUnit_lipschitz : LipschitzWith 1 clipUnit := |
| (LipschitzWith.id.const_min 1).const_max (-1) |
|
|
| noncomputable def finiteOddExtension {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (T : X → X) (x : X) : ℝ := |
| (clipUnit (finiteMcShane e f L x) - clipUnit (finiteMcShane e f L (T x))) / 2 |
|
|
| lemma finiteOddExtension_bounds {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (T : X → X) (x : X) : |
| -1 ≤ finiteOddExtension e f L T x ∧ finiteOddExtension e f L T x ≤ 1 := by |
| have hx := clipUnit_bounds (finiteMcShane e f L x) |
| have htx := clipUnit_bounds (finiteMcShane e f L (T x)) |
| unfold finiteOddExtension |
| constructor <;> linarith |
|
|
| lemma finiteOddExtension_odd {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (T : X → X) |
| (hT : Function.Involutive T) (x : X) : |
| finiteOddExtension e f L T (T x) = -finiteOddExtension e f L T x := by |
| simp only [finiteOddExtension, hT x] |
| ring |
|
|
| lemma finiteOddExtension_on_grid {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (T : X → X) (Tg : G → G) |
| (hT : ∀ x, T (e x) = e (Tg x)) |
| (hf : ∀ x y, |f x - f y| ≤ L * dist (e x) (e y)) |
| (hb : ∀ x, -1 ≤ f x ∧ f x ≤ 1) (ho : ∀ x, f (Tg x) = -f x) (x : G) : |
| finiteOddExtension e f L T (e x) = f x := by |
| simp only [finiteOddExtension, hT x, finiteMcShane_on_grid e f L hf, |
| clipUnit_eq (hb x), clipUnit_eq (hb (Tg x))] |
| rw [ho x] |
| ring |
|
|
| lemma finiteOddExtension_lipschitz {G X : Type*} [Fintype G] [Nonempty G] |
| [PseudoMetricSpace X] (e : G → X) (f : G → ℝ) (L : ℝ≥0) (T : X → X) |
| (hT : Isometry T) : LipschitzWith L (finiteOddExtension e f L T) := by |
| have hg : LipschitzWith L (fun x => clipUnit (finiteMcShane e f L x)) := by |
| simpa only [one_mul, Function.comp_def] using clipUnit_lipschitz.comp (finiteMcShane_lipschitz e f L) |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| have h₁ := hg.dist_le_mul x y |
| have h₂ := hg.dist_le_mul (T x) (T y) |
| rw [hT.dist_eq] at h₂ |
| simp only [Real.dist_eq] at h₁ h₂ ⊢ |
| unfold finiteOddExtension |
| rw [abs_le] at h₁ h₂ ⊢ |
| constructor <;> linarith |
|
|
| noncomputable def torusAntipode {ι : Type*} (x : ι → UnitAddCircle) : ι → UnitAddCircle := |
| fun k => x k + ((1 / 2 : ℝ) : UnitAddCircle) |
|
|
| lemma torusAntipode_involutive {ι : Type*} : |
| Function.Involutive (torusAntipode : (ι → UnitAddCircle) → (ι → UnitAddCircle)) := by |
| intro x |
| funext k |
| simp only [torusAntipode, add_assoc, ← AddCircle.coe_add] |
| norm_num |
|
|
| lemma torusAntipode_isometry {ι : Type*} [Fintype ι] : |
| Isometry (torusAntipode : (ι → UnitAddCircle) → (ι → UnitAddCircle)) := by |
| intro x y |
| simp only [edist_pi_def, torusAntipode, edist_add_right] |
|
|
| noncomputable def torusGrid {ι : Type*} {D : ℕ} [NeZero D] |
| (x : ι → ZMod D) : ι → UnitAddCircle := fun k => ZMod.toAddCircle (x k) |
|
|
| lemma torusGrid_antipode {ι : Type*} {D : ℕ} [NeZero D] (hD : Even D) |
| (x : ι → ZMod D) : |
| torusAntipode (torusGrid x) = torusGrid (fun k => x k + ((D / 2 : ℕ) : ZMod D)) := by |
| funext k |
| simp only [torusAntipode, torusGrid, map_add, ZMod.toAddCircle_natCast, |
| grid_half_real D hD] |
|
|
| noncomputable def tupleExtension {Q : Type*} {M : Q → Type*} [∀ q, Fintype (M q)] |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] |
| (A : Set (GridLocation M D)) (q : Q) (x : M q → UnitAddCircle) : ℝ := by |
| classical |
| exact finiteOddExtension torusGrid (fun u => gridBump S A ⟨q, u⟩) 64 torusAntipode x |
|
|
| lemma tupleExtension_bounds {Q : Type*} {M : Q → Type*} [∀ q, Fintype (M q)] |
| (S : ProjectionSystem Q M) {D : ℕ} [NeZero D] |
| (A : Set (GridLocation M D)) (q : Q) (x : M q → UnitAddCircle) : |
| -1 ≤ tupleExtension S A q x ∧ tupleExtension S A q x ≤ 1 := by |
| classical |
| exact finiteOddExtension_bounds _ _ _ _ _ |
|
|
| end LargeIndependentSets |
|
|
| end OAI |
|
|
