planar_necklace_line_sign_split
Let Q be a finite set of points coloured red (0) and blue (1), with 2a red points and 2b blue points, and let ℓ be a straight line such that each of the two strict sides of ℓ contains at most a red and at most b blue points of Q. Then the points of Q can be split into two parts, each with exactly a red and b blue points, subject to the constraint that a point strictly on the positive side of ℓ goes to the first part and a point strictly on the negative side goes to the second part (points ON the line may be assigned to either part).
Statement
theorem planar_necklace_line_sign_split (Q : Finset (ℝ × ℝ)) (c : (ℝ × ℝ) → Fin 2) (ℓ : StraightLine) (a b : ℕ) (hred : (Q.filter (fun p => c p = 0)).card = 2 * a) (hblue : (Q.filter (fun p => c p = 1)).card = 2 * b) (hup_red : (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)).card ≤ a) (hdown_red : (Q.filter (fun p => c p = 0 ∧ ℓ.cut p < 0)).card ≤ a) (hup_blue : (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)).card ≤ b) (hdown_blue : (Q.filter (fun p => c p = 1 ∧ ℓ.cut p < 0)).card ≤ b) : ∃ β : (ℝ × ℝ) → Bool, (∀ p ∈ Q, 0 < ℓ.cut p → β p = true) ∧ (∀ p ∈ Q, ℓ.cut p < 0 → β p = false) ∧ (Q.filter (fun p => c p = 0 ∧ β p = true)).card = a ∧ (Q.filter (fun p => c p = 0 ∧ β p = false)).card = a ∧ (Q.filter (fun p => c p = 1 ∧ β p = true)).card = b ∧ (Q.filter (fun p => c p = 1 ∧ β p = false)).card = b
- Source
- step towards planar_necklace_three_agents_three_cuts
- Verified
- 29 Oct 2026
- Axioms
Classical.choiceQuot.soundpropext- Built on 1
- StraightLineA straight line in the plane ℝ², given by an affine functional with nonzero linear part.
The proof, explained
To partition the 2a red and 2b blue points into two balanced halves respecting the strict sides of the line ℓ, all points strictly above ℓ are assigned to the first half (true) and all points strictly below ℓ are assigned to the second half (false). Because each strict side contains at most a red and at most b blue points, the first half is deficient by a - (red above) red points and b - (blue above) blue points. A counting lemma shows that the line itself contains at least these many points of each colour, so we can select on-line subsets T₀ (red) and T₁ (blue) to reach the exact quotas a and b. Assigning true to the strictly positive points together with T₀ and T₁ produces an assignment whose true and false classes each contain exactly a red and b blue points.
The points of colour P are partitioned by the line ℓ into three mutually disjoint subsets (positive side, negative side, and on the line), so their total count 2n is the sum of the counts in these three regions.
The conditions ℓ.cut p > 0, ℓ.cut p < 0, and ℓ.cut p = 0 are mutually exclusive by linear arithmetic on ℝ, yielding disjointness between the positive and negative regions (`hd1`) as well as between their union and the line (`hd2`). By real trichotomy (`lt_trichotomy`), every point falls into exactly one of these three cases, partitioning the set of P-points into three disjoint subsets (`hsplit`). Taking cardinalities, the total count 2n is the sum of the counts in the three regions (`hcard`).
uses
disjoint_filter,disjoint_union_left,mem_union,mem_filter,lt_trichotomy,card_union_of_disjointhave hd1 : Disjoint (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)) (Q.filter (fun p => P p ∧ ℓ.cut p < 0)) := by rw [disjoint_filter]; intro p _ h1 h2; linarith have hd2 : Disjoint (Q.filter (fun p => P p ∧ 0 < ℓ.cut p) ∪ Q.filter (fun p => P p ∧ ℓ.cut p < 0)) (Q.filter (fun p => P p ∧ ℓ.cut p = 0)) := by rw [disjoint_union_left] constructor · rw [disjoint_filter]; intro p _ h1 h2; linarith · rw [disjoint_filter]; intro p _ h1 h2; linarith have hsplit : Q.filter (fun p => P p) = Q.filter (fun p => P p ∧ 0 < ℓ.cut p) ∪ Q.filter (fun p => P p ∧ ℓ.cut p < 0) ∪ Q.filter (fun p => P p ∧ ℓ.cut p = 0) := by ext p simp only [mem_union, mem_filter] rcases lt_trichotomy (ℓ.cut p) 0 with h | h | h <;> tauto have hcard : (Q.filter (fun p => P p)).card = (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card + (Q.filter (fun p => P p ∧ ℓ.cut p < 0)).card + (Q.filter (fun p => P p ∧ ℓ.cut p = 0)).card := by conv_lhs => rw [hsplit] rw [card_union_of_disjoint hd2, card_union_of_disjoint hd1]
There exists a subset T of points with property P lying on the line ℓ whose cardinality is exactly n minus the number of strictly positive P-points.
Because the negative side contains at most n points and the total is 2n, the positive side and the line together contain at least n points. Subtracting the positive count shows that the number of on-line P-points is at least n minus the positive count (`hle`). Since this target size is bounded by the number of on-line points, such a subset T exists by `exists_subset_card_eq`.
uses
exists_subset_card_eqhave hle : n - (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card ≤ (Q.filter (fun p => P p ∧ ℓ.cut p = 0)).card := by omega exact exists_subset_card_eq hle
For any colour k, if exactly n of the 2n points of colour k satisfy β p = true, then exactly n points satisfy β p = false.
The points of colour k are partitioned into those where β evaluates to true and those where it does not, which for booleans is equivalent to β evaluating to false (`Bool.eq_false_eq_not_eq_true`). By `card_filter_add_card_filter_not`, the sum of the cardinalities of these two complementary subsets equals the total count 2n, so the false subset must also have size 2n - n = n.
uses
and_assoc,mem_filter,Bool.eq_false_eq_not_eq_true,card_filter_add_card_filter_nothave h1 : Q.filter (fun p => c p = k ∧ β p = true) = (Q.filter (fun p => c p = k)).filter (fun p => β p = true) := by ext x; simp [and_assoc] have h2 : Q.filter (fun p => c p = k ∧ β p = false) = (Q.filter (fun p => c p = k)).filter (fun p => ¬ (β p = true)) := by ext x simp only [mem_filter, and_assoc] rw [← Bool.eq_false_eq_not_eq_true] rw [h1] at htrue rw [h2] have h_sum := @card_filter_add_card_filter_not _ (Q.filter (fun p => c p = k)) (fun p => β p = true) _ _ omega
Choose subsets T₀ and T₁ of on-line points of red and blue colours respectively, and define the assignment function β.
Applying the first lemma to red points (colour 0, quota a) yields a subset T₀ of red points on ℓ of size a - |{red strictly above}|. Symmetrically, applying it to blue points (colour 1, quota b) yields a subset T₁ of blue points on ℓ of size b - |{blue strictly above}|. We then define β(p) = true if and only if p is strictly above ℓ (0 < ℓ.cut p) or p ∈ T₀ or p ∈ T₁.
uses
planar_necklace_line_sign_split_exists_subset_on_lineclassical obtain ⟨T₀, hT₀_sub, hT₀_card⟩ := planar_necklace_line_sign_split_exists_subset_on_line Q (fun p => c p = 0) ℓ a hred hup_red hdown_red obtain ⟨T₁, hT₁_sub, hT₁_card⟩ := planar_necklace_line_sign_split_exists_subset_on_line Q (fun p => c p = 1) ℓ b hblue hup_blue hdown_blue let β : (ℝ × ℝ) → Bool := fun p => decide (0 < ℓ.cut p ∨ p ∈ T₀ ∨ p ∈ T₁)
Exactly a red points are assigned true by β.
A red point p (c p = 0) satisfies β(p) = true if and only if 0 < ℓ.cut p, p ∈ T₀, or p ∈ T₁. But p cannot be in T₁, because points in T₁ are blue (c p = 1 ≠ 0). Thus the red points assigned true are the union of the red points strictly above ℓ and T₀ (`heq`). Furthermore, this union is disjoint (`hd`) because points in T₀ lie on ℓ (ℓ.cut p = 0) while points above have ℓ.cut p > 0. Summing their cardinalities gives |red above| + (a - |red above|) = a.
uses
Finset.mem_filter,Finset.mem_union,decide_eq_true_iff,Finset.disjoint_right,Finset.card_union_of_disjointhave h_card_0 : (Q.filter (fun p => c p = 0 ∧ β p = true)).card = a := by have heq : Q.filter (fun p => c p = 0 ∧ β p = true) = (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)) ∪ T₀ := by ext p simp only [Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, β] constructor · rintro ⟨hpQ, hc, hcut | hpT₀ | hpT₁⟩ · left; exact ⟨hpQ, hc, hcut⟩ · right; exact hpT₀ · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h have hc1 : c p = 1 := h.2.1 have hne : (0 : Fin 2) ≠ 1 := by decide exfalso; apply hne rw [← hc, hc1] · rintro (⟨hpQ, hc, hcut⟩ | hpT₀) · exact ⟨hpQ, hc, Or.inl hcut⟩ · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h exact ⟨h.1, h.2.1, Or.inr (Or.inl hpT₀)⟩ have hd : Disjoint (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)) T₀ := by rw [Finset.disjoint_right] intro p hpT₀ have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h ⊢ intro ⟨_, _, hcut⟩ have : ℓ.cut p = 0 := h.2.2 linarith rw [heq, Finset.card_union_of_disjoint hd, hT₀_card] omega
Exactly b blue points are assigned true by β.
By the exact same argument, a blue point p (c p = 1) cannot belong to T₀ (which contains only red points with c p = 0 ≠ 1). Thus the blue points assigned true are the disjoint union of the blue points strictly above ℓ and T₁. Summing their cardinalities gives |blue above| + (b - |blue above|) = b.
uses
Finset.mem_filter,Finset.mem_union,decide_eq_true_iff,Finset.disjoint_right,Finset.card_union_of_disjointhave h_card_1 : (Q.filter (fun p => c p = 1 ∧ β p = true)).card = b := by have heq : Q.filter (fun p => c p = 1 ∧ β p = true) = (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)) ∪ T₁ := by ext p simp only [Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, β] constructor · rintro ⟨hpQ, hc, hcut | hpT₀ | hpT₁⟩ · left; exact ⟨hpQ, hc, hcut⟩ · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h have hc0 : c p = 0 := h.2.1 have hne : (1 : Fin 2) ≠ 0 := by decide exfalso; apply hne rw [← hc, hc0] · right; exact hpT₁ · rintro (⟨hpQ, hc, hcut⟩ | hpT₁) · exact ⟨hpQ, hc, Or.inl hcut⟩ · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h exact ⟨h.1, h.2.1, Or.inr (Or.inr hpT₁)⟩ have hd : Disjoint (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)) T₁ := by rw [Finset.disjoint_right] intro p hpT₁ have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h ⊢ intro ⟨_, _, hcut⟩ have : ℓ.cut p = 0 := h.2.2 linarith rw [heq, Finset.card_union_of_disjoint hd, hT₁_card] omega
The assignment β sends strictly positive points to true, strictly negative points to false, and splits both colours into equal halves of sizes a and b.
Any point strictly above ℓ satisfies the first condition of β and is assigned true. Any point strictly below ℓ has ℓ.cut p < 0 and cannot belong to T₀ or T₁ (which lie on ℓ where ℓ.cut p = 0), so it is assigned false. The counts of red and blue points assigned true are a and b as proved above. Finally, the second lemma (`planar_necklace_line_sign_split_false_card`) implies that the red and blue points assigned false also number exactly a and b.
uses
decide_eq_true_iff,decide_eq_false_iff_not,Finset.mem_filter,planar_necklace_line_sign_split_false_cardrefine ⟨β, ?_, ?_, h_card_0, ?_, h_card_1, ?_⟩ · intro p _ hcut simp only [β, decide_eq_true_iff] exact Or.inl hcut · intro p _ hcut simp only [β, decide_eq_false_iff_not] rintro (h | hpT₀ | hpT₁) · linarith · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h have : ℓ.cut p = 0 := h.2.2 linarith · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h have : ℓ.cut p = 0 := h.2.2 linarith · exact planar_necklace_line_sign_split_false_card Q c β 0 a hred h_card_0 · exact planar_necklace_line_sign_split_false_card Q c β 1 b hblue h_card_1
disjoint_filter- Two sub-finsets defined by filtering the same set by predicates p and q are disjoint if and only if no element satisfies both p and q.
disjoint_union_left- A union of two sets is disjoint from a third set if and only if each of the two sets is disjoint from the third.
mem_union- An element belongs to the union of two sets if and only if it belongs to at least one of them.
mem_filter- An element belongs to a filtered set if and only if it belongs to the base set and satisfies the predicate.
lt_trichotomy- For any two elements in a linear order, exactly one holds: the first is strictly less than, equal to, or strictly greater than the second.
card_union_of_disjoint- The cardinality of the union of two disjoint finite sets is the sum of their cardinalities.
exists_subset_card_eq- Any finite set contains a subset of any specified size that is less than or equal to its own cardinality.
and_assoc- Conjunction of propositions is associative.
Bool.eq_false_eq_not_eq_true- A boolean value is not equal to true if and only if it is equal to false.
card_filter_add_card_filter_not- For any predicate on a finite set, the number of elements satisfying the predicate plus the number of elements satisfying its negation equals the total size of the set.
planar_necklace_line_sign_split_exists_subset_on_line- Given 2n points with property P such that at most n lie strictly on either side of ℓ, there is a subset of the on-line points of size n minus the number of strictly positive points.
Finset.mem_filter- An element belongs to a filtered finset if and only if it belongs to the base finset and satisfies the predicate.
Finset.mem_union- An element belongs to the union of two finsets if and only if it belongs to at least one of them.
decide_eq_true_iff- A decidable proposition evaluates to the boolean true if and only if it holds.
Finset.disjoint_right- Two finsets are disjoint if and only if no element of the second set belongs to the first set.
Finset.card_union_of_disjoint- The cardinality of the union of two disjoint finsets is the sum of their cardinalities.
decide_eq_false_iff_not- A decidable proposition evaluates to the boolean false if and only if its negation holds.
planar_necklace_line_sign_split_false_card- If a set of 2n points of colour k has exactly n points where β evaluates to true, then exactly n points have β equal to false.
- The line ℓ is represented by an affine map `ℓ.cut : (ℝ × ℝ) →ᵃ[ℝ] ℝ`, where the line itself is the zero locus `ℓ.cut p = 0`, and the two open half-planes are `0 < ℓ.cut p` and `ℓ.cut p < 0`.
- The split into two parts is encoded by a boolean signing function `β : (ℝ × ℝ) → Bool`, assigning points with `β p = true` to the first part and `β p = false` to the second part.
Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.
Lean source view module on GitHub
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
open Finset inlemma planar_necklace_line_sign_split_exists_subset_on_line (Q : Finset (ℝ × ℝ)) (P : (ℝ × ℝ) → Prop) [DecidablePred P] (ℓ : StraightLine) (n : ℕ) (hn : (Q.filter (fun p => P p)).card = 2 * n) (hup : (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card ≤ n) (hdown : (Q.filter (fun p => P p ∧ ℓ.cut p < 0)).card ≤ n) : ∃ T ⊆ Q.filter (fun p => P p ∧ ℓ.cut p = 0), T.card = n - (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card := by have hd1 : Disjoint (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)) (Q.filter (fun p => P p ∧ ℓ.cut p < 0)) := by rw [disjoint_filter]; intro p _ h1 h2; linarith have hd2 : Disjoint (Q.filter (fun p => P p ∧ 0 < ℓ.cut p) ∪ Q.filter (fun p => P p ∧ ℓ.cut p < 0)) (Q.filter (fun p => P p ∧ ℓ.cut p = 0)) := by rw [disjoint_union_left] constructor · rw [disjoint_filter]; intro p _ h1 h2; linarith · rw [disjoint_filter]; intro p _ h1 h2; linarith have hsplit : Q.filter (fun p => P p) = Q.filter (fun p => P p ∧ 0 < ℓ.cut p) ∪ Q.filter (fun p => P p ∧ ℓ.cut p < 0) ∪ Q.filter (fun p => P p ∧ ℓ.cut p = 0) := by ext p simp only [mem_union, mem_filter] rcases lt_trichotomy (ℓ.cut p) 0 with h | h | h <;> tauto have hcard : (Q.filter (fun p => P p)).card = (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card + (Q.filter (fun p => P p ∧ ℓ.cut p < 0)).card + (Q.filter (fun p => P p ∧ ℓ.cut p = 0)).card := by conv_lhs => rw [hsplit] rw [card_union_of_disjoint hd2, card_union_of_disjoint hd1] have hle : n - (Q.filter (fun p => P p ∧ 0 < ℓ.cut p)).card ≤ (Q.filter (fun p => P p ∧ ℓ.cut p = 0)).card := by omega exact exists_subset_card_eq hleopen Finset inlemma planar_necklace_line_sign_split_false_card (Q : Finset (ℝ × ℝ)) (c : (ℝ × ℝ) → Fin 2) (β : (ℝ × ℝ) → Bool) (k : Fin 2) (n : ℕ) (htot : (Q.filter (fun p => c p = k)).card = 2 * n) (htrue : (Q.filter (fun p => c p = k ∧ β p = true)).card = n) : (Q.filter (fun p => c p = k ∧ β p = false)).card = n := by have h1 : Q.filter (fun p => c p = k ∧ β p = true) = (Q.filter (fun p => c p = k)).filter (fun p => β p = true) := by ext x; simp [and_assoc] have h2 : Q.filter (fun p => c p = k ∧ β p = false) = (Q.filter (fun p => c p = k)).filter (fun p => ¬ (β p = true)) := by ext x simp only [mem_filter, and_assoc] rw [← Bool.eq_false_eq_not_eq_true] rw [h1] at htrue rw [h2] have h_sum := @card_filter_add_card_filter_not _ (Q.filter (fun p => c p = k)) (fun p => β p = true) _ _ omega/-- Boundary-flexible signing step: if both strict sides of a line are within quota, the on-line points can be used to split the set into two exactly-balanced parts. -/theorem planar_necklace_line_sign_split (Q : Finset (ℝ × ℝ)) (c : (ℝ × ℝ) → Fin 2) (ℓ : StraightLine) (a b : ℕ) (hred : (Q.filter (fun p => c p = 0)).card = 2 * a) (hblue : (Q.filter (fun p => c p = 1)).card = 2 * b) (hup_red : (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)).card ≤ a) (hdown_red : (Q.filter (fun p => c p = 0 ∧ ℓ.cut p < 0)).card ≤ a) (hup_blue : (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)).card ≤ b) (hdown_blue : (Q.filter (fun p => c p = 1 ∧ ℓ.cut p < 0)).card ≤ b) : ∃ β : (ℝ × ℝ) → Bool, (∀ p ∈ Q, 0 < ℓ.cut p → β p = true) ∧ (∀ p ∈ Q, ℓ.cut p < 0 → β p = false) ∧ (Q.filter (fun p => c p = 0 ∧ β p = true)).card = a ∧ (Q.filter (fun p => c p = 0 ∧ β p = false)).card = a ∧ (Q.filter (fun p => c p = 1 ∧ β p = true)).card = b ∧ (Q.filter (fun p => c p = 1 ∧ β p = false)).card = b := by classical obtain ⟨T₀, hT₀_sub, hT₀_card⟩ := planar_necklace_line_sign_split_exists_subset_on_line Q (fun p => c p = 0) ℓ a hred hup_red hdown_red obtain ⟨T₁, hT₁_sub, hT₁_card⟩ := planar_necklace_line_sign_split_exists_subset_on_line Q (fun p => c p = 1) ℓ b hblue hup_blue hdown_blue let β : (ℝ × ℝ) → Bool := fun p => decide (0 < ℓ.cut p ∨ p ∈ T₀ ∨ p ∈ T₁) have h_card_0 : (Q.filter (fun p => c p = 0 ∧ β p = true)).card = a := by have heq : Q.filter (fun p => c p = 0 ∧ β p = true) = (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)) ∪ T₀ := by ext p simp only [Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, β] constructor · rintro ⟨hpQ, hc, hcut | hpT₀ | hpT₁⟩ · left; exact ⟨hpQ, hc, hcut⟩ · right; exact hpT₀ · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h have hc1 : c p = 1 := h.2.1 have hne : (0 : Fin 2) ≠ 1 := by decide exfalso; apply hne rw [← hc, hc1] · rintro (⟨hpQ, hc, hcut⟩ | hpT₀) · exact ⟨hpQ, hc, Or.inl hcut⟩ · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h exact ⟨h.1, h.2.1, Or.inr (Or.inl hpT₀)⟩ have hd : Disjoint (Q.filter (fun p => c p = 0 ∧ 0 < ℓ.cut p)) T₀ := by rw [Finset.disjoint_right] intro p hpT₀ have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h ⊢ intro ⟨_, _, hcut⟩ have : ℓ.cut p = 0 := h.2.2 linarith rw [heq, Finset.card_union_of_disjoint hd, hT₀_card] omega have h_card_1 : (Q.filter (fun p => c p = 1 ∧ β p = true)).card = b := by have heq : Q.filter (fun p => c p = 1 ∧ β p = true) = (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)) ∪ T₁ := by ext p simp only [Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, β] constructor · rintro ⟨hpQ, hc, hcut | hpT₀ | hpT₁⟩ · left; exact ⟨hpQ, hc, hcut⟩ · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h have hc0 : c p = 0 := h.2.1 have hne : (1 : Fin 2) ≠ 0 := by decide exfalso; apply hne rw [← hc, hc0] · right; exact hpT₁ · rintro (⟨hpQ, hc, hcut⟩ | hpT₁) · exact ⟨hpQ, hc, Or.inl hcut⟩ · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h exact ⟨h.1, h.2.1, Or.inr (Or.inr hpT₁)⟩ have hd : Disjoint (Q.filter (fun p => c p = 1 ∧ 0 < ℓ.cut p)) T₁ := by rw [Finset.disjoint_right] intro p hpT₁ have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h ⊢ intro ⟨_, _, hcut⟩ have : ℓ.cut p = 0 := h.2.2 linarith rw [heq, Finset.card_union_of_disjoint hd, hT₁_card] omega refine ⟨β, ?_, ?_, h_card_0, ?_, h_card_1, ?_⟩ · intro p _ hcut simp only [β, decide_eq_true_iff] exact Or.inl hcut · intro p _ hcut simp only [β, decide_eq_false_iff_not] rintro (h | hpT₀ | hpT₁) · linarith · have h := hT₀_sub hpT₀ simp only [Finset.mem_filter] at h have : ℓ.cut p = 0 := h.2.2 linarith · have h := hT₁_sub hpT₁ simp only [Finset.mem_filter] at h have : ℓ.cut p = 0 := h.2.2 linarith · exact planar_necklace_line_sign_split_false_card Q c β 0 a hred h_card_0 · exact planar_necklace_line_sign_split_false_card Q c β 1 b hblue h_card_1