papexlabs/kobon-triangles

Copy on Hugging Face. These are the files of github.com/papexlabs/kobon-triangles at commit aafcb6d (10 November 2026). Two things differ: this README has a dataset header and this note, and one table is added for the dataset viewer: hf/case_b_solves.jsonl, described under "Tables in this copy" at the end. The archived version is 10.5281/zenodo.24105026. The result has not been peer reviewed, and Parpalak and Utkin proved it first (see below).

Kobon triangles: eleven lines

Earlier result. Roman Parpalak and Denis Utkin proved a(11) = 32 first, by exhaustive enumeration: Theorem 3.12 of Non-simple Arrangements of Lines and Pseudolines with Many Triangles (arXiv:2611.03096). Their enumeration output has been public since September 2026 at parpalak/kobon-even-draft. This repository verifies their result by a different method: a case split proved by hand and two SAT instances with checked proofs.

Correction (version 2, 10 November 2026). Version 1 said that an independent proof checker verified every step. The checker of the original runs, drat-trim's lrat-check, does not check the last step of a proof, the empty clause (drat-trim issue #42); that step rested on the solver. With a patched checker (checker/) we re-checked case A in full, the covers of all 1,094 splits of case B (also with the formally verified cake_lpr) and 100 random leaves; all were verified (results/recheck-fixed/). For the other 67,514 leaves of case B the last step still rests on CaDiCaL; every earlier step was checked.

Result. No arrangement of 11 pseudolines in the affine plane (straight lines included, simple or not: parallel lines and three or more lines through a point are allowed) has 33 or more bounded triangular faces. With the known 32-triangle arrangements of Honma and Kabanovitch, the Kobon triangle number for 11 lines (OEIS A006066, a(11)) is 32.

Signed record on Papex: https://papex.org/id/PXP-18B537AWDH1F/v/1 (version 1 of the paper, signed by Papex Labs). The paper source is paper/kobon11.tex (version 2); the PDFs are attached to the v1 and v2 releases. Version 2 with a snapshot of this repository is archived at Zenodo: 10.5281/zenodo.24105026. It has not been peer reviewed. The hand argument that reduces every arrangement to two SAT instances (Proposition 5, the case split) is the part we most want checked: a similar reduction in Clément–Bader (2007) has a counterexample, which is why a(11) was removed from A006066 in October 2026.

How the proof is put together

1. Case split (by hand, paper Section 2). An arrangement with 3T ≥ n(n−2) triangles is either simple (case A) or has three concurrent lines 1, 2, 3 with triangles on lines {1,2,4}, {1,2,5} and {2,3,z} (case B). For n = 11, 3 · 33 = 11 · 9.
2. Case A. One CNF, refuted by CaDiCaL 3.0.1 with a 22.66 GB LRAT proof. The patched lrat-check verified it in full (results/recheck-fixed/caseA.log). The proof is not included; it can be regenerated (about 4.5 hours).
3. Case B. A cube-and-conquer tree in results/cubes_k11B_lex_d8/: 1,094 splits, each with a cover check (the node formula plus the negations of all its cubes refuted with a checked LRAT proof), and 67,614 leaves, each refuted by CaDiCaL with its LRAT proof streamed into lrat-check (the unpatched one; see the correction above). Every node directory holds sub.icnf (its cubes), cover.out and results.jsonl (one record per solve; the latest record per cube counts). scripts/summary.py walks the tree and reports ALL CLOSED.

Layout

• src/kobon_cnf.py: the SAT model (rank-3 chirotopes, bounded triangles, case A/B constraints, symmetry breaking, redundant constraints). src/validate_fixed.py checks it against random straight-line arrangements; src/decode.py decodes a satisfying assignment.
• scripts/: run_cubes.py (solve cubes with streamed LRAT checks), check_cover.py, conquer.py (re-split unsolved cubes level by level), summary.py (closure check), recheck.py (re-check any part of the tree from these files), race_split.py and close_watch.py (the extra splits used for the last six cubes), cloud/ (server setup and result sync), progress_server.py (local progress page).
• build/k11B_lex_d8.icnf: the 238 cubes of the top split. The CNFs are not stored; they are regenerated byte for byte (step 1 below).
• results/: logs of every run, certified.txt, certified.sha256 and cubes_k11B_lex_d8.sha256 (hashes of every file of the tree).
• notes/: CASES.md (the case split as first written), PLAN.md, and papex-hypothesis-draft.md (the claim and plan written on 27 October 2026, before any result).

Requirements

Python 3.10 or later; CaDiCaL 3.0.1 as cadical on the PATH; the patched lrat-check built from checker/lrat-check.c (see checker/README.md: cc -std=c99 -DLONGTYPE -O2 -o checker/lrat-check checker/lrat-check.c); march_cu from CnC (commit 705b60c, built with -fcommon on GCC 10 or later) at tools/CnC/march_cu/march_cu. scripts/cloud/setup.sh builds all three on Ubuntu 24.04. Optional: cake_lpr (tanyongkiam/cake_lpr, tag v1.0.0); with the environment variable CAKE_LPR set to its binary, cover proofs must pass it as well.

Checking it

# 1. Regenerate the two formulas and compare with results/certified.sha256
mkdir -p build
python3 src/kobon_cnf.py 11 33 --simple --redundant --lex > build/k11_33_simple.lexred.cnf
python3 src/kobon_cnf.py 11 33 --case-b --lex > build/k11_33_caseB.lex.cnf
shasum -a 256 build/k11_33_simple.lexred.cnf build/k11_33_caseB.lex.cnf

# 2. Case A: about 4.5 hours and 23 GB of disk
cadical --lrat=true --binary=false build/k11_33_simple.lexred.cnf caseA.lrat
checker/lrat-check build/k11_33_simple.lexred.cnf caseA.lrat

# 3. Case B: closure of the recorded tree
python3 scripts/summary.py build/k11B_lex_d8.icnf results/cubes_k11B_lex_d8 \
    results/cubes_k11B_lex_d8.cover.out

# 4. Case B: re-solve leaves and re-check covers from these files
python3 -I scripts/recheck.py build/k11_33_caseB.lex.cnf build/k11B_lex_d8.icnf \
    results/cubes_k11B_lex_d8 --sample 50 --max-secs 120 --covers
#    --node c201/c63/c15 re-checks one subtree; --sample 0 re-checks every leaf (about 2,000 CPU hours)
#    --no-leaves --all-covers re-checks the cover of every split (minutes)

How this work was done

The model, the code, the computation and the paper were prepared by Claude Opus 5.5, an AI model, working for Papex Labs; a person at Papex Labs reviews and signs each version. The code was written from the published statements of the sources, not from the tools of Savchuk (arXiv:2507.07951). Before release, a separate Claude Opus 5.5 session, given the code and notes but not our conclusions, re-derived the hand arguments, tested them on 615 random straight-line arrangements, audited the whole tree and re-solved leaves and covers from scratch; it found no error. That does not replace review by a mathematician. The re-checks and text changes of version 2 were prepared by Claude Fable 5.2 and reviewed and signed in the same way.

License

Code: MIT (LICENSE). Paper, notes, cubes, results and logs: CC BY 4.0 (LICENSE-DATA.md).

Tables in this copy

hf/case_b_solves.jsonl has the 69,237 solve records of the case B tree in one file: every line of the 1,100 results.jsonl files under results/cubes_k11B_lex_d8/, unchanged, with the node it belongs to. hf/make_tables.py writes it from those files.

from datasets import load_dataset

solves = load_dataset("papexlabs/kobon-triangles", split="train")

To get every file (about 30 MB):

from huggingface_hub import snapshot_download

folder = snapshot_download("papexlabs/kobon-triangles", repo_type="dataset")

Field	Meaning
node	The node of the tree, as its folder under results/cubes_k11B_lex_d8/ (empty for the top split)
depth	How many splits below the top split the node is
cube	The cube's number in the node's sub.icnf (in build/k11B_lex_d8.icnf for the top split)
record	The line's position in the node's results.jsonl; when a cube has several records the latest counts
cube_length	Number of literals in the cube
status	UNSAT, or UNKNOWN when the solver reached its time limit and the cube was split again
check	VERIFIED when lrat-check accepted the streamed LRAT proof, empty for UNKNOWN
secs	Solver time in seconds

67,986 records are UNSAT and VERIFIED; 1,251 are UNKNOWN. The table is a list of solver runs, not the proof: scripts/summary.py checks that the tree closes. check is the verdict of the checker of the original runs, which does not check the last step of a proof; the correction at the top says what was re-checked with the patched checker.

Licence: the data, results, notes and paper are under CC BY 4.0 and the code under MIT (LICENSE-DATA.md, LICENSE).