HN Debrief

A SAT Attack on Tarski's High School Algebra Problem

  • Mathematics
  • Developer Tools
  • AI
  • Open Source

The paper attacks a long-running logic problem about positive integers with addition, multiplication, and exponentiation, but without subtraction. Tarski asked whether the obvious school-level laws for those operations were enough to derive every true identity in that setting. Prior work had already shown the answer is no by giving “exotic” counterexamples. This paper narrows the size of the smallest such countermodel using SAT encodings, plus a Lean-backed check that the generated formulas mean what the authors say they mean.

If you use SAT or formal methods in research, this is a good example of where encoding quality and symmetry breaking dominate runtime more than raw solver choice. It is also a reminder to treat LLM-assisted formalization as useful but not self-justifying, especially when the proof object is only as trustworthy as the theorem statement, the kernel, and the review process around them.

Discussion mood

Mostly impressed by the SAT engineering and the result’s precision, with some unease about the verification story. The positive mood came from solver experts recognizing strong encoding and symmetry-breaking work. The skepticism centered on the missed prior artifact and on relying on LLM-generated Lean as part of the trust chain.

Key insights

  1. 01

    Symmetry breaking is doing real work

    The performance jump is not just “Kissat is fast.” It comes from aggressive symmetry breaking with satsuma and from encoding choices that keep equivalent search branches from exploding. That changes how to read the paper. The hard part is less theorem proving in the abstract and more turning a mathematical search into a SAT instance that the solver can actually traverse efficiently.

    If you are building SAT-based tooling, spend time on symmetry handling before chasing marginal solver tweaks. Benchmark encodings with and without those reductions, because that is where order-of-magnitude gains often hide.

      Attribution:
    • zero_k #1
    • NooneAtAll3 #1
  2. 02

    The missed prior lower bound changes the novelty

    A Zenodo artifact had already established the lower bound, so the paper did not break completely fresh ground on that part. What still stands is the engineering improvement. The authors say their encoding solves the size-10 nonexistence case in about 85 seconds versus about 50 minutes for the artifact they found later. That reframes the contribution from “first to prove this bound” to “much better formulation of the same search.”

    When you evaluate SAT papers, separate mathematical novelty from encoding novelty. A result can still matter if it turns an impractical proof search into a routine computation.

      Attribution:
    • bsubs #1
    • 406380581 #1
  3. 03

    This theory is decidable but not finitely axiomatizable

    The Gödel objection misses the target because this is an equational theory, not full first-order arithmetic with quantifiers. The sharper fact is more interesting. Gurevič showed the true identities in this language are decidable, yet no finite set of equations in the original signature can capture them all. That is exactly why a finite “high school algebra” rulebook was doomed even though the overall theory remains computable.

    Do not lump every arithmetic-flavored problem under incompleteness. For product decisions around theorem provers or symbolic systems, ask separately whether a theory is decidable and whether it has a compact axiom basis.

      Attribution:
    • LegionMammal978 #1
  4. 04

    Dropping subtraction is the whole point

    The absence of subtraction is not a cheap loophole. It is the domain choice that makes the problem interesting. Over positive integers, subtraction is not a total operation, and adding it back pushes the theory into much harder territory. One commenter noted that with subtraction on positive integers, even without exponentiation, the resulting theories become undecidable under several natural treatments of negative outcomes. That makes the restricted signature look deliberate rather than artificial.

    When a paper omits a familiar operation, check whether closure and decidability are driving the choice. Those constraints often determine whether exhaustive search and formal analysis are possible at all.

      Attribution:
    • skinner_ #1
    • Sharlin #1
    • woadwarrior01 #1
  5. 05

    Byte-for-byte equality is about solver behavior

    The insistence that the Lean encoder reproduce the Python CNF output exactly was not cargo culting. SAT solvers are sensitive to clause order, variable numbering, and other surface details that do not change logical equivalence. The formalization goal here was not merely to prove two encoders express the same math. It was to prove that the trusted executable encoder produces the exact instances whose runtime behavior the paper reports.

    If your pipeline mixes formal verification with performance claims, prove equivalence at the artifact level that actually affects runtime. Logical equivalence alone may be too weak when downstream tools are heuristic and order-sensitive.

      Attribution:
    • bsubs #1
    • dev_dan_2 #1

Against the grain

  1. 01

    Lean typechecking is not absolute trust

    Recent soundness issues show that a proof assistant can accept a bogus result if the surrounding machinery is flawed, even when the theorem statement looks right and external checkers agree. That does not make this paper suspect. It does puncture the easy line that typechecking lets you ignore almost all generated code. The trust boundary includes the kernel, import and export machinery, and any features whose soundness story is still unsettled.

    Treat proof assistants like strong risk reduction, not perfect guarantees. For high-stakes claims, prefer simple theorem statements, minimized dependencies, and independently reviewable artifacts.

      Attribution:
    • BalinKing #1
    • dev_dan_2 #1
  2. 02

    The search is narrower than it first appears

    The SAT run is not exploring arbitrary counterexamples to Tarski’s problem. It is searching within a shape derived from Wilkie-style exotic identities, and the authors say they tried some alternatives without finding smaller countermodels. That means the result is powerful inside a carefully chosen family, but it is not a generic automated hunt over the whole identity space.

    Be careful when reading “search” papers. Ask what family was encoded and what was ruled out by construction, because those modeling choices define the actual scope of the result.

      Attribution:
    • bsubs #1
    • yorwba #1

In plain english

CNF
Conjunctive normal form, a standard way to write a Boolean formula as an AND of OR-clauses for use by SAT solvers.
countermodel
A structure that satisfies the chosen axioms but makes a target statement false, showing the statement is not derivable from those axioms.
decidable
A property of a problem meaning there is an algorithm that will always determine the correct yes or no answer in finite time.
equational theory
A theory concerned with which equations are true in a given algebraic system.
first-order arithmetic
A logical system for reasoning about numbers using quantifiers like “for all” and “there exists.”
kernel
In this context, a small performance-critical function, often run on a GPU or other accelerator, that does the core numerical work.
Kissat
A high-performance SAT solver widely used in satisfiability research and competitions.
Lean
A proof assistant and programming language used to write mathematics in a formal way that a small trusted kernel can mechanically verify.
SAT
Boolean satisfiability, the problem of deciding whether there exists an assignment of true or false values that makes a logical formula true.
satsuma
A symmetry-breaking system mentioned in the comments as part of the paper’s SAT workflow.
signature
The basic symbols and operations allowed in a formal language, such as addition, multiplication, exponentiation, and constants.
symmetry breaking
A technique that adds constraints to eliminate equivalent cases so a solver does not waste time exploring the same structure many times.
typechecking
The process by which a proof assistant verifies that code and proofs follow the formal rules of its logic and type system.

Reference links

Prior work and related papers

SAT tooling and performance references

Proof assistant and soundness discussion