AFTD Auto-Formalizing Theoretical Domains

planar_necklace_line_sign_split

theoremverified

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.

  1. 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`).

    lines 9–29

    uses disjoint_filter, disjoint_union_left, mem_union, mem_filter, lt_trichotomy, card_union_of_disjoint

      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]
  2. 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`.

    lines 30–32

    uses exists_subset_card_eq

      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 hle
  3. 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.

    lines 40–49

    uses and_assoc, mem_filter, Bool.eq_false_eq_not_eq_true, card_filter_add_card_filter_not

      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
  4. 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₁.

    lines 67–72

    uses planar_necklace_line_sign_split_exists_subset_on_line

      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₁)
  5. 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.

    lines 73–102

    uses Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, Finset.disjoint_right, Finset.card_union_of_disjoint

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

    lines 103–132

    uses Finset.mem_filter, Finset.mem_union, decide_eq_true_iff, Finset.disjoint_right, Finset.card_union_of_disjoint

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

    lines 133–150

    uses decide_eq_true_iff, decide_eq_false_iff_not, Finset.mem_filter, planar_necklace_line_sign_split_false_card

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

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

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
See it in the graphDiscuss this resultChallenge it