Certified SAT Verification of the Vertex Formulation of Erdős Problem #580 for Orders at Most 19

1. Introduction and Precise Scope

Erdős, Füredi, Loebl and Sós introduced a median-degree tree-embedding problem in 1995 [1]. The formulation currently displayed as Erdős Problem #580 asks whether an n-vertex graph in which at least $n/2$ vertices have degree at least $n/2$ must contain every tree on at most $n/2$ vertices [2]. For odd n, throughout this paper the degree threshold and the required number of high-degree vertices are interpreted with ceilings, while the tree order is interpreted with a floor.

The classical Loebl–Komlós–Sós conjecture is normally stated in terms of the number of edges of the embedded tree: if at least half of the vertices of a graph have degree at least k, then the graph should contain every tree with at most k edges. Important exact cases were proved by Bazgan, Li and Woźniak [3] and by Piguet and Stein [4]. Zhao proved Loebl’s $k=n/2$ case for all sufficiently large n [5]. The website formulation differs by one vertex from this classical statement: at $n=18$, it asks for trees on at most nine vertices, whereas the classical $k=9$ statement asks for trees with nine edges, which may have ten vertices.

Our main result is the following finite statement.

Theorem 1. 

Let $1\le n\le 19$, and let G be an n-vertex graph such that at least $\lceil n/2\rceil$ vertices of G have degree at least $\lceil n/2\rceil$. Then G contains every tree on at most $\lfloor n/2\rfloor$ vertices.

The public problem page records Zhao’s sufficiently-large-order theorem and labels the remaining task as a finite check, but it provides neither an explicit finite threshold nor a completed list of the remaining orders [2,5]. The present result does not complete that unspecified finite check. Its contribution is instead a fully explicit and independently auditable initial interval: every target tree through order 19 is covered, the unique nontrivial even host order 18 is reduced to four finite formulas, and the complete formulas and clausal refutations are deposited.

The significance of the computation is methodological as well as numerical. The tree classification is accompanied by generated witnesses for all 47 isomorphism types; the five exceptional trees are independently checked against their rooted cores; the SAT formulas are regenerated byte for byte; and a standalone audit reconstructs the base formula and every avoidance clause without importing the production generator. This provides a reusable certified workflow for extending the finite interval or attacking the stronger ten-vertex-tree case at $n=18$. No claim is made that this finite interval reaches Zhao’s threshold, and no absolute literature-priority claim is required for the theorem proved here.

The proof has four layers. First, all orders below 18 follow from known exact classes. Second, edge minimality reduces a hypothetical 18-vertex counterexample to a sharply structured host. Third, a finite classification reduces the 47 nine-vertex trees to five exceptional types and then to four rooted cores. Finally, four certified SAT refutations exclude reduced hosts avoiding those cores. The full software, formulas and certificates are archived in Zenodo record 21348157, version 1.0.2 [6]. The current package includes a repository-wide SHA-256 manifest, the complete CNF and DRUP files, independent solver results, and semantic audits of both the exceptional-tree reduction and the generated avoidance clauses.

2. Preliminaries and the Orders Below Eighteen

All graphs are finite, simple and undirected. An embedding of a graph H into a graph G is an injective map $\phi :V(H)\to V(G)$ that preserves edges. We write $H\subseteq G$ when such an embedding exists. The order of a graph is its number of vertices, and the length of a path is its number of edges.

We first record a simple monotonicity observation.

Lemma 1. 

Every tree on at most q vertices is a subgraph of a tree on exactly q vertices.

Proof. 

Starting from a tree T of order $t<q$, attach a new leaf to an arbitrary vertex, and repeat until the order is q. The original tree remains a subgraph at every step.    □

The exact results used below are the following.

• Piguet and Stein proved the Loebl–Komlós–Sós conjecture for every tree of diameter at most five [4].
• Bazgan, Li and Woźniak proved it for paths and for trees obtained by identifying the centre of a star with a vertex of a path [3]; see also the formulation in [4].
• For $k,\ell ,c\in \mathbb{N}$, let $\mathcal{T}(k,\ell ,c)$ be the class of trees with k edges obtained from a path of length $k-\ell$ by attaching two stars whose centres lie at distance c on the path. Piguet and Stein proved that, when $\ell \ge c$, every $T\in \mathcal{T}(k,\ell ,c)$ embeds whenever c is even or $\ell +c\ge \lfloor n/2\rfloor$ [4].

Proposition 1. 

The conclusion of 1 holds for $n\le 17$.

Proof. 

The one-vertex tree is contained in every nonempty host, so assume $t\ge 2$. Let T have $t\le \lfloor n/2\rfloor$ vertices and hence $t-1$ edges. The host hypothesis is stronger than the Loebl–Komlós–Sós degree condition with parameter $k=t-1\in \mathbb{N}$.

For $n\le 17$, one has $t\le 8$. Every tree on at most six vertices has diameter at most five. A seven-vertex tree of diameter six is the path $P_7$. An eight-vertex tree of diameter seven is $P_8$. Finally, an eight-vertex tree of diameter six consists of a seven-vertex diametral path and one additional leaf attached to an internal path vertex; hence it is a path-plus-star tree. The cited exact results cover all possibilities.    □

3. Reduction of a Minimal Counterexample at Order Eighteen

Assume, for a contradiction, that an 18-vertex counterexample exists. By 1, it is enough to consider a missing tree of order exactly nine. Choose a counterexample G with the minimum possible number of edges, and define

$$L=\{v\in V(G):d_G(v)\ge 9\},S=V(G)\setminus L.$$

Deleting edges cannot create a copy of the missing tree. Consequently, deleting any edge from G must destroy the degree hypothesis.

Lemma 2 

(Reduced-host lemma). A minimal counterexample satisfies

$$|L|=|S|=9,d_G(x)=9(x\in L),E(G[S])=⌀.$$

In particular, each vertex of S has degree at most eight.

Proof. 

If $|L|\ge 11$, deleting any edge lowers the degrees of at most two vertices. At least nine vertices would still have degree at least nine, contradicting edge minimality.

Suppose $|L|=10$. Deleting an edge must lower the number of vertices of degree at least nine from ten to at most eight. Hence both endpoints of every edge must lie in L and have degree exactly nine. Thus every edge lies in L, every vertex of L has degree nine, and $G[L]=K_{10}$. The complete graph $K_{10}$ contains every tree on nine vertices, a contradiction. Therefore $|L|=9$.

An edge inside S could be deleted without changing a degree in L, so S is independent. Finally, suppose $x\in L$ has degree greater than nine. For every edge $xy$ incident with x, deletion of $xy$ must make at least one of the nine vertices of L fall below degree nine. Since x remains of degree at least nine, the other endpoint y must lie in L and have degree exactly nine. But there are only eight other vertices of L, contradicting $d_G(x)>9$. Hence every vertex of L has degree exactly nine.    □

We call a graph satisfying the conclusion of 2 a reduced host.

4. Leaf Deletion and Rooted Cores

Let T be a tree on nine vertices. Denote its set of leaves by M, put $F=T-M$, and let

$$P=N_T(M)\cap V(F)$$

be the set of parents of the deleted leaves. We regard $(F,P)$ as a rooted core, with the vertices in P marked.

Lemma 3 

(Leaf-extension lemma). Let G be a reduced host. If F has an embedding φ into G satisfying $\phi (P)\subseteq L$, then φ extends to an embedding of T into G.

Proof. 

Put $r=|M|$. The embedded core occupies $9-r$ vertices. For a parent $p\in P$, the image $\phi (p)$ has degree nine and has at most $(9-r)-1$ neighbours among the other embedded core vertices. Hence it has at least

$$9-((9-r)-1)=r+1$$

unused neighbours.

For each deleted leaf m, let its candidate set be the unused neighbours of the image of its parent. Each candidate set has size at least $r+1$. If $X\subseteq M$ is nonempty, the union of the candidate sets for the leaves in X contains at least one such candidate set and therefore has size at least $r+1\ge |X|$. Hall’s theorem gives distinct representatives for all deleted leaves, completing the embedding.    □

5. Finite Classification of the Nine-Vertex Trees

The program classify_trees9.py uses NetworkX [7] to generate the non-isomorphic trees of order nine and to compare them with the exact classes summarized above. The output contains 47 trees in total, 42 covered by the cited exact theorems and five exceptional isomorphism types. The full type-by-type audit appears in Appendix A.

Proposition 2 

(Classification audit). Every tree on nine vertices is either covered by one of the exact results summarized above, or is isomorphic to one of the five trees in Table 2.

Proof. 

The finite exhaustive procedure is given explicitly in Section 9. It enumerates all 47 non-isomorphic trees, applies graph-isomorphism tests to every member of the three exact classes, and produces the graph6 list in Appendix A. The three uniquely two-star cases have the explicit witnesses in Table 1, and the five unclassified graph6 strings are precisely those displayed in Table 2. Re-running the corrected classifier with NetworkX 3.6.1 reproduces the same counts, strings and witnesses. The Piguet–Stein alternative inequality is implemented as $\ell +c\ge \lfloor 18/2\rfloor =9$ for the 18-vertex host; this correction leaves the classification unchanged because the three trees assigned uniquely to this route all have even c.    □

Table 1. Explicit witnesses for the three trees assigned uniquely to the two-star caterpillar route. The two entries in the star-leaf column are the numbers of pendant leaves attached at the two path centres.

Graph6	k	ℓ	c	Path length	Centres	Star leaves	Condition
HpH?GCA	8	4	4	4	(0,4)	(2,2)	c even
HpH?GD?	8	2	2	6	(1,3)	(1,1)	c even
Hp‘?GCC	8	2	2	6	(2,4)	(1,1)	c even

Table 1. Explicit witnesses for the three trees assigned uniquely to the two-star caterpillar route. The two entries in the star-leaf column are the numbers of pendant leaves attached at the two path centres.

Graph6	k	ℓ	c	Path length	Centres	Star leaves	Condition
HpH?GCA	8	4	4	4	(0,4)	(2,2)	c even
HpH?GD?	8	2	2	6	(1,3)	(1,1)	c even
Hp‘?GCC	8	2	2	6	(2,4)	(1,1)	c even

Table 2. The five exceptional trees and the rooted-core instances that cover them. A vector records the numbers of additional leaves attached along a five-vertex path, up to reversal.

Graph6	Structure	Rooted-core instance
HpIA?C@	path multiplicities $(2,1,0,0,1)$	path_support_014
HpH?GCC	path multiplicities $(2,0,0,1,1)$	path_support_014
Hp_I?C@	spider with arm lengths $(2,2,4)$	spider_224_core
Hp‘?GD?	path multiplicities $(1,1,1,0,1)$	path_support_0124
HpOGI?@	spider with arm lengths $(2,3,3)$	spider_233_core

Table 2. The five exceptional trees and the rooted-core instances that cover them. A vector records the numbers of additional leaves attached along a five-vertex path, up to reversal.

Graph6	Structure	Rooted-core instance
HpIA?C@	path multiplicities $(2,1,0,0,1)$	path_support_014
HpH?GCC	path multiplicities $(2,0,0,1,1)$	path_support_014
Hp_I?C@	spider with arm lengths $(2,2,4)$	spider_224_core
Hp‘?GD?	path multiplicities $(1,1,1,0,1)$	path_support_0124
HpOGI?@	spider with arm lengths $(2,3,3)$	spider_233_core

Table 3. Machine-auditable reduction of the five exceptional trees to four rooted cores. Vertex labels are obtained by decoding the graph6 strings with NetworkX 3.6.1.

Graph6	Deleted leaves	Marked parents	Rooted core
HpIA?C@	$3,4,5,8$	$0,2,7$	path_support_014
HpH?GCC	$3,4,7,8$	$2,5,6$	path_support_014
Hp_I?C@	$3,5,8$	$2,4,7$	spider_224_core
Hp‘?GD?	$3,4,7,8$	$0,1,2,6$	path_support_0124
HpOGI?@	$3,6,8$	$2,5,7$	spider_233_core

Table 3. Machine-auditable reduction of the five exceptional trees to four rooted cores. Vertex labels are obtained by decoding the graph6 strings with NetworkX 3.6.1.

Graph6	Deleted leaves	Marked parents	Rooted core
HpIA?C@	$3,4,5,8$	$0,2,7$	path_support_014
HpH?GCC	$3,4,7,8$	$2,5,6$	path_support_014
Hp_I?C@	$3,5,8$	$2,4,7$	spider_224_core
Hp‘?GD?	$3,4,7,8$	$0,1,2,6$	path_support_0124
HpOGI?@	$3,6,8$	$2,5,7$	spider_233_core

Deleting all leaves from the five exceptional trees produces four rooted cores. They are shown in Figure 1; filled vertices are the marked parents required to lie in L.

6. SAT Encoding

Fix a reduced host with

$$L=\{0,\dots ,8\},S=\{9,\dots ,17\}.$$

For every potential edge inside L or between L and S, introduce a primary Boolean variable $x_{uv}$, interpreted as true when $uv$ is present. There are

$$\left({\displaystyle \genfrac{}{}{0pt}{}{9}{2}}\right)+9·9=117$$

primary variables. Edges inside S are fixed absent.

For every $u\in L$, a totalizer cardinality encoding [8] imposes

$$\sum _{v\ne u}{x}_{uv}=9.$$

For every $s\in S$, the single clause

$$\underset{u\in L}{\bigvee }\neg x_{us}$$

imposes $d(s)\le 8$, because S is independent. The resulting base formula has 1377 variables after the introduction of cardinality auxiliaries and 3735 clauses.

Let $(F,P)$ be one of the four rooted cores. For every injective map $\phi :V(F)\to V(G)$ satisfying $\phi (P)\subseteq L$, add the avoidance clause

$$\underset{ab\in E(F)}{\bigvee }\neg x_{\phi (a)\phi (b)}.$$

(1)

If a core edge is mapped inside S, then the placement cannot be an embedding and no clause is needed. Duplicate clauses are removed. For the two spider cores, one automorphism exchanging equal arms is used only to suppress duplicate placements; it does not remove an isomorphism class of embeddings.

Denote the resulting formula by ${\Phi }_F$.

Proposition 3 

(Encoding correctness). The formula ${\Phi }_F$ is satisfiable if and only if there exists a reduced host avoiding every embedding of $(F,P)$ with the marked vertices mapped into L.

Proof. 

Given a model of ${\Phi }_F$, use the primary variables to define the edge set. The base formula gives degree exactly nine on L, degree at most eight on S, and no edges inside S. Every possible rooted-core placement satisfies an avoidance clause of the form (1), so at least one required core edge is absent.

Conversely, let a reduced host avoid the rooted core. Assign its edge indicators to the primary variables. Correctness of the totalizer encoding provides values for the auxiliary variables satisfying the degree constraints. Since every rooted-core placement is missing at least one required edge, every clause (1) is satisfied.    □

The four instance sizes are listed in Table 4.

7. Certified Unsatisfiability

The instances were generated with Python 3, NetworkX 3.6.1 and PySAT 1.9.dev5 [9]. Glucose 4.1 [10] produced a plain-text DRUP refutation for each formula. We recall the certificate principle.

Definition 1. 

Let Γ be a CNF formula. A clause C has the reverse unit propagation property with respect to Γ if unit propagation on

$$\Gamma \cup \{\{\neg \ell \}:\ell \in C\}$$

produces a contradiction.

Every RUP clause is logically implied by the current formula. Therefore, a sequence of RUP additions ending in the empty clause certifies unsatisfiability. DRUP is a subset of the DRAT proof format; see [11].

The deposited checker reads every proof addition and tests the RUP condition using MiniSat 2.2 [12] only as a unit-propagation engine. Deletion lines are ignored. The resulting validation is still sound as a semantic refutation: inductively, every retained derived clause is a logical consequence of the original CNF, and a unit-propagation conflict after negating a proposed clause proves that clause to be another consequence of the original CNF. The archived validation reaches the empty clause in every instance and reports the additions shown in Table 5. As an independent cross-check, the four original CNFs were also solved as unsat by CaDiCaL 1.5.3; CaDiCaL is documented in [13].

A solver-free regeneration of the published encoder reproduced all four archived CNFs byte for byte. Their SHA-256 digests, together with the digests of the four DRUP files, appear in Appendix B. A separate standalone audit imports no constants, core specifications, variable map or placement routine from the production generator. It independently defines the host partition and four rooted cores, reconstructs the PySAT totalizer variable map and all 3735 base clauses, exhaustively enumerates all injective rooted placements, and compares the archived formula clause by clause in exact order. For every instance, the variable count, base prefix, avoidance tail and complete formula agree exactly, and no duplicate avoidance clause occurs. The avoidance counts are 48384, 34776, 343224 and 343224. A second audit decodes each exceptional graph6 tree, deletes all leaves, marks their parents, and verifies a unique rooted isomorphism with the stated core. These checks test the semantic link between the graph problem and the generated formulas rather than merely re-running the same encoder.

Thus the following is a certificate-backed computational theorem.

Proposition 4. 

For each of the four rooted cores in Figure 1, the formula ${\Phi }_F$ is unsatisfiable. Consequently, every reduced host contains an embedding of that rooted core with all marked vertices in L.

Proof. 

The checked DRUP traces derive the empty clause from each formula. The semantic conclusion follows from 3.    □

8. Completion of the Proof

Theorem 2. 

Every 18-vertex graph with at least nine vertices of degree at least nine contains every tree on at most nine vertices.

Proof. 

By 1, it is enough to embed every tree on nine vertices. Suppose a counterexample exists and reduce it using 2. By 2, 42 tree types are covered by known exact results. Each of the remaining five trees has one of the four rooted cores in Figure 1. By 4, the reduced host contains the appropriate rooted core with the marked leaf-parents in L. The leaf-extension lemma, 3, extends that embedding to the full exceptional tree. This contradicts the existence of a counterexample.    □

Corollary 1. 

Every 19-vertex graph with at least ten vertices of degree at least ten contains every tree on at most nine vertices.

Proof. 

Delete an arbitrary vertex. At least nine of the original high-degree vertices remain, and each has degree at least nine in the resulting 18-vertex graph. Apply 2.    □

Combining proves 1.

9. Reproducibility Details

The finite computation is intentionally small enough to audit at the mathematical-object level. The classification procedure is:

• Generate the 47 non-isomorphic trees on nine vertices using networkx.nonisomorphictrees(9).
• Mark every tree of diameter at most five as class D.
• Enumerate every tree obtained from a path of length p and a star with $8-p$ leaves by identifying the star centre with a path vertex; mark any isomorphic tree as class P.
• Enumerate every two-star caterpillar in $\mathcal{T}(8,\ell ,c)$ with $\ell \ge c$ and with either c even or $\ell +c\ge 9$; mark any isomorphic tree as class C.
• Record the remaining graph6 strings as class E.

The priority labels in Appendix A are assigned in the order D, P, C, E; some covered trees belong to more than one exact class. This priority gives 32 trees in D, 7 in P, 3 in Cand 5 in E.

For the proof-critical archived files, the principal verification commands are

python -m pip install -r requirements.txt

sha256sum -c SHA256SUMS

mkdir -p reproduced/verification

python src/classify_trees9.py \

   --json reproduced/verification/classification.json \

   --detailed-json \

   reproduced/verification/classification_detailed.json \

   --tex reproduced/verification/classification_audit.tex

python src/audit_rooted_cores.py \

   --json reproduced/verification/rooted_core.json

python src/audit_cnf_semantics.py \

   --cert-dir certificates \

   --json reproduced/verification/cnf_semantics.json

python src/generate_and_solve.py \

   --generate-only \

   --out-dir reproduced/generated-cnfs \

   --results-json \

   reproduced/verification/cnf_regeneration.json \

   --reference-dir certificates

python src/independent_solve.py \

   --cert-dir certificates \

   --json reproduced/verification/independent_solve.json

python src/check_drup.py \

   --cert-dir certificates \

   --json reproduced/verification/proof_check.json

A portable rooted-core audit is included in the journal source and may be run as

python supplement/code/audit_rooted_cores.py \

   --json /tmp/rooted_core_recheck.json

The complete instances and traces are not duplicated in the journal source because they are approximately 56 MB in the public archive [6]. The journal source includes the corrected classifier, generator, certificate checker, independent-solver script, both semantic-audit scripts, machine-readable result summaries, and authoritative certificate hashes.

Remark 1 

(Computational release). The cited Zenodo record contains version 1.0.2. Its repository-wide SHA256SUMS manifest verifies every archived file other than the manifest itself. The four proof-critical CNFs and four DRUP traces are unchanged from the initial deposit. Version 1.0.2 corrects the Piguet–Stein alternative to the published threshold $\ell +c\ge \lfloor n/2\rfloor$ (equal to 9 here), generates the complete classification JSON and LaTeX table directly from the classifier, replaces the partial semantic audit by a standalone exact reconstruction of each complete CNF, and adds solver-free byte-for-byte CNF regeneration. These corrections leave the $42+5$ classification, every CNF and every proof certificate unchanged.

10. Limitations

The result is a finite verification of the literal vertex wording of the website problem. It does not establish the classical $n=18$ statement for all trees with nine edges, does not provide a new asymptotic method, and does not show that the verified interval joins Zhao’s unspecified sufficiently-large-n interval. The finite classification depends on graph enumeration and isomorphism testing, while the final four cases depend on CNF generation and proof checking. These dependencies are exposed through complete source code, exact formulas, clausal refutations and file digests.