AFTD Auto-Formalizing Theoretical Domains

not_is_straight_line_cut_consistent_empty_of_ne

theoremverified

For any two points p, q in ℝ × ℝ, any natural number k, and any allocation α : (ℝ × ℝ) → Fin k, if α p ≠ α q, then the two-element finite set {p, q} is not consistent with the empty finite set of straight lines ∅ under α: ¬ is_straight_line_cut_consistent {p, q} ∅ α.

Statement

theorem not_is_straight_line_cut_consistent_empty_of_ne (p q : ℝ × ℝ) {k : ℕ}
    (α : (ℝ × ℝ) → Fin k) (hα : α p ≠ α q) :
    ¬ is_straight_line_cut_consistent {p, q} ∅ α
Source
arXiv:2610.27956 Section 1.1
Verified
22 Oct 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 2
  • is_straight_line_cut_consistentGiven a finite set P of points in ℝ × ℝ, a finite set L of straight lines (StraightLine), a natural number k, and an allocation function α…
  • StraightLineA straight line in the plane ℝ², given by an affine functional with nonzero linear part.

Read back from the Lean

For any points $p, q \in \mathbb{R} \times \mathbb{R}$, any natural number $k$, and any function $\alpha : (\mathbb{R} \times \mathbb{R}) \to \text{Fin } k$, if $\alpha(p) \neq \alpha(q)$, then it is not the case that the pair of points $\{p, q\}$ with the empty set of straight lines is consistent under $\alpha$ (is_straight_line_cut_consistent {p, q} ∅ α).

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

The proof proceeds by contradiction. If the two-point set {p, q} were consistent with zero cuts (the empty set ∅), any two points that agree on all cuts in ∅ would have to be assigned the same agent. Since the set of cuts is empty, p and q agree on every cut vacuously, forcing α p = α q, which contradicts the hypothesis that α p ≠ α q.

  1. Assume for contradiction that {p, q} is consistent with the empty set of straight lines under α.

    We unpack the consistency assumption into a side function s and consistency conditions. In particular, we obtain the hypothesis h2: for any two points in {p, q}, if they agree on all cuts in ∅, they must receive the same allocation under α.

    line 5

      intro ⟨s, _, h2⟩
  2. The points p and q both belong to the two-element set {p, q}.

    By the definitions of finset insertion and singletons, p is in {p, q} by Finset.mem_insert_self, and q is in {p, q} by Finset.mem_singleton_self combined with Finset.mem_insert_of_mem.

    lines 6–7

    uses Finset.mem_insert_self, Finset.mem_insert_of_mem, Finset.mem_singleton_self

      have hp : p ∈ ({p, q} : Finset (ℝ × ℝ)) := Finset.mem_insert_self p {q}
      have hq : q ∈ ({p, q} : Finset (ℝ × ℝ)) := Finset.mem_insert_of_mem (Finset.mem_singleton_self q)
  3. A contradiction arises between α p = α q and α p ≠ α q.

    The condition that s ℓ p = s ℓ q for all ℓ ∈ ∅ is vacuously satisfied, because there are no elements in the empty set (Finset.notMem_empty). Thus, applying h2 to p and q shows that α p = α q, directly contradicting the hypothesis hα that α p ≠ α q.

    line 8

    uses Finset.notMem_empty

      exact hα (h2 p hp q hq fun ℓ hℓ => (Finset.notMem_empty ℓ hℓ).elim)
Finset.mem_insert_self
An element a belongs to insert a s.
Finset.mem_insert_of_mem
If an element a belongs to s, then it also belongs to insert b s.
Finset.mem_singleton_self
An element a belongs to the singleton set {a}.
Finset.notMem_empty
No element belongs to the empty finset ∅.

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

/-- Two points assigned to different agents cannot be consistently allocated using zero straight-line cuts. -/theorem not_is_straight_line_cut_consistent_empty_of_ne (p q : ℝ × ℝ) {k : ℕ}    (α : (ℝ × ℝ) → Fin k) (hα : α p ≠ α q) :    ¬ is_straight_line_cut_consistent {p, q} ∅ α := by  intro ⟨s, _, h2⟩  have hp : p ∈ ({p, q} : Finset (ℝ × ℝ)) := Finset.mem_insert_self p {q}  have hq : q ∈ ({p, q} : Finset (ℝ × ℝ)) := Finset.mem_insert_of_mem (Finset.mem_singleton_self q)  exact hα (h2 p hp q hq fun ℓ hℓ => (Finset.notMem_empty ℓ hℓ).elim)
See it in the graphDiscuss this resultChallenge it