Even graphs are edge-disjoint… to Near-perfect triangle packings…
TheoremEven graphs are edge-disjoint unions of cycles#
Decomposes every finite loopless edge set with even degree at each vertex into edge-disjoint simple cycles and derives a simultaneous fixed-point-free pairing of incident edges.
Quoted from the card LeanPool/projects/even-graph-cycle-decomposition.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 2 main results, each with its informal statement quoted from the card. The scan finds 2 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
Finset.exists_cycleDecomp(theorem; a main declaration), declared in LeanPool/EvenGraphCycles.lean, line 592: “Every finite loopless edge set whose degree is even at every vertex is the edge-disjoint union of simple cycles of length at least three.”Finset.exists_edge_pairing_of_even(theorem; a main declaration), declared in LeanPool/EvenGraphCycles.lean, line 725: “If every vertex has even degree, then the incident edges at every vertex admit a simultaneous fixed-point-free involutive pairing.”
Project
- Authors: Juan Pablo Traverso Gianini, Aristotle.
- Source: Reusable even-graph cycle decomposition accompanying Linear-Error Clique Partitions of Split Graphs via Structured Triangle Packing by Juan Pablo Traverso Gianini, https://github.com/jtraverso/erdos-81-chordal-clique-partitions/blob/b3423f3e8c8db7c2d1b279673293ef3079faf903/preprints/PAPER_III/05_formalization/lean_v1.4_freeze/Contrib/EvenGraphCycles.lean.
- Project repository: jtraverso/erdos-81-chordal-clique-partitions.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C45.
- In Lean Pool: LeanPool/EvenGraphCycles, from the card LeanPool/projects/even-graph-cycle-decomposition.yaml.
Sources
DefinitionExtended Demazure Product on ASP Permutations#
Formalizes the extended Demazure product on almost-sign-preserving integer permutations, including slipface models, residuals, greedy and stingy characterizations, reduction theorems, adjacent-transposition formulas, and 321-avoiding factorization results.
Quoted from the card LeanPool/projects/demazure-product.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 9 main results, each with its informal statement quoted from the card. The scan finds 9 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
LeanPool.DemazureProduct.AspPerm.star(def; a main declaration), declared in LeanPool/DemazureProduct/Submodular.lean, line 1063: “Defines the extended Demazure product on almost-sign-preserving permutations.”LeanPool.DemazureProduct.AspPerm.star_assoc(lemma), declared in LeanPool/DemazureProduct/Submodular.lean, line 1115: “Proves associativity of the extended Demazure product on almost-sign-preserving permutations.”LeanPool.DemazureProduct.Reduction.starGreedy(theorem), declared in LeanPool/DemazureProduct/Reduction.lean, line 116: “Characterizes the Demazure product as the Bruhat-maximum of ordinary products of smaller factors.”LeanPool.DemazureProduct.Reduction.reduce(theorem), declared in LeanPool/DemazureProduct/Reduction.lean, line 179: “Reduces inequalities against a Demazure product to ordinary products of Bruhat-smaller factors with fixed shift.”LeanPool.DemazureProduct.Reduction.lres_stingy(theorem), declared in LeanPool/DemazureProduct/Reduction.lean, line 294: “Gives the stingy characterization of the left residual as a Bruhat-minimum of ordinary products.”LeanPool.DemazureProduct.ReducedProducts.star_eq_mul_iff_reducedProduct(theorem), declared in LeanPool/DemazureProduct/ReducedProducts.lean, line 249: “Shows that the Demazure product equals ordinary multiplication exactly for reduced ASP products.”LeanPool.DemazureProduct.Transpositions.starSigma(theorem), declared in LeanPool/DemazureProduct/Transpositions.lean, line 861: “Proves the adjacent-transposition formula for multiplying an ASP permutation by a no-consecutive-pair involution.”LeanPool.DemazureProduct.ASP321a.dprod_eq_iff(theorem), declared in LeanPool/DemazureProduct/Avoiding321.lean, line 1439: “Characterizes Demazure factorizations of 321-avoiding ASP permutations by isolated inversion-set decompositions.”LeanPool.DemazureProduct.Tableaux.setValuedTableauEquivHeckeFactorization(def), declared in LeanPool/DemazureProduct/Tableaux.lean, line 1158: “Relates fixed-shift set-valued tableaux to Hecke factorizations of 321-avoiding ASP permutations.”
Project
- Authors: Nathan Pflueger.
- Source: An extended Demazure product on integer permutations via min-plus matrix multiplication by Nathan Pflueger, arXiv:2206.14227.
- Project repository: npflueger/demazure.
- Provenance: mix, which in Lean Pool's terms means people and AI “both contributed substantially” to its Lean proofs.
- License: Apache-2.0.
- MSC2020: 05E05, 20F55.
- In Lean Pool: LeanPool/DemazureProduct, from the card LeanPool/projects/demazure-product.yaml.
Sources
TheoremFinite hypergraph rounding and the asymptotic triangle-packing gap#
Formalizes a finite ceiling-carrying nibble theorem for uniform hypergraphs that are near-regular outside a small exceptional set and have suitably bounded codegrees, and derives the uniform subquadratic gap between fractional and integral triangle packing in finite graphs, together with its fractional-cover formulation.
Quoted from the card LeanPool/projects/asymptotic-triangle-packing.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 3 main results, each with its informal statement quoted from the card. The scan finds 3 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
LeanPool.AsymptoticTrianglePacking.nearRegularNibbleTheorem(theorem), declared in LeanPool/AsymptoticTrianglePacking/Main.lean, line 1722: “For every uniformity and positive error tolerance, sufficiently large finite uniform hypergraphs with bounded codegrees, near-regular degrees outside a small exceptional set, and a global degree ceiling admit a matching covering the prescribed fraction of their vertices.” Its source, as the card gives it: “Finite near-regular hypergraph nibble theorem used in the Paper III development.”LeanPool.AsymptoticTrianglePacking.trianglePackingGap(theorem; a main declaration), declared in LeanPool/AsymptoticTrianglePacking/Main.lean, line 1742: “For every positive error tolerance, all sufficiently large finite graphs have fractional triangle-packing optimum at most their integral triangle-packing optimum plus the error tolerance times the square of the number of vertices.” Its source, as the card gives it: “Paper III AX1, fractional-integral triangle-packing gap.”LeanPool.AsymptoticTrianglePacking.triangleCoverPackingGap(theorem), declared in LeanPool/AsymptoticTrianglePacking/Main.lean, line 1752: “For every positive error tolerance, all sufficiently large finite graphs have fractional triangle-cover optimum at most their integral triangle-packing optimum plus the error tolerance times the square of the number of vertices.” Its source, as the card gives it: “Paper III AX1, cover-side formulation.”
Project
- Authors: Juan Pablo Traverso Gianini, Aristotle.
- Source: Asymptotic triangle cover--packing development accompanying Linear-Error Clique Partitions of Split Graphs via Structured Triangle Packing by Juan Pablo Traverso Gianini, https://github.com/jtraverso/erdos-81-chordal-clique-partitions/tree/main/preprints/PAPER_III.
- Project repository: jtraverso/erdos-81-chordal-clique-partitions.
- Provenance: mix, which in Lean Pool's terms means people and AI “both contributed substantially” to its Lean proofs.
- License: Apache-2.0.
- MSC2020: 05C70, 05C35.
- In Lean Pool: LeanPool/AsymptoticTrianglePacking, from the card LeanPool/projects/asymptotic-triangle-packing.yaml.
Sources
TheoremFinite max-flow / min-cut#
Develops finite networks with real nonnegative capacities, proves cut-flow weak duality and maximum-flow attainment, and derives max-flow/min-cut equality by an augmenting-path argument.
Quoted from the card LeanPool/projects/finite-max-flow-min-cut.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 3 main results, each with its informal statement quoted from the card. The scan finds 3 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
Contrib.MaxFlowMinCut.maxflow_eq_mincut(theorem; a main declaration), declared in LeanPool/MaxFlowMinCut.lean, line 706: “Every finite network with real nonnegative capacities and distinct source and sink admits a feasible flow and a source-sink cut whose flow value equals the cut capacity.”Contrib.MaxFlowMinCut.value_le_capacity(theorem), declared in LeanPool/MaxFlowMinCut.lean, line 458: “The value of every feasible flow is at most the capacity of every source-sink cut.”Contrib.MaxFlowMinCut.max_flow_exists(theorem), declared in LeanPool/MaxFlowMinCut.lean, line 575: “Every finite network with real nonnegative capacities admits a maximum-value feasible flow.”
Project
- Authors: Juan Pablo Traverso Gianini, Aristotle.
- Source: Reusable max-flow/min-cut component accompanying Linear-Error Clique Partitions of Split Graphs via Structured Triangle Packing by Juan Pablo Traverso Gianini, https://github.com/jtraverso/erdos-81-chordal-clique-partitions/blob/b3423f3e8c8db7c2d1b279673293ef3079faf903/preprints/PAPER_III/05_formalization/lean_v1.4_freeze/Contrib/MaxFlowMinCut.lean.
- Project repository: jtraverso/erdos-81-chordal-clique-partitions.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C21, 90C35.
- In Lean Pool: LeanPool/MaxFlowMinCut, from the card LeanPool/projects/finite-max-flow-min-cut.yaml.
Sources
TheoremFrontierMath Ramsey Hypergraphs#
Formalizes lower bounds for the Brian-Larson hypergraph extremal function H(n), including a uniform 26/25 improvement over the recursive benchmark k_n for n ≥ 15 and a Lubell-frame asymptotic lower bound.
Quoted from the card LeanPool/projects/frontiermath-open-hypergraphs.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 7 main results, each with its informal statement quoted from the card. The scan finds 7 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
HypergraphLowerBound.thm_main_H_lower_bound(theorem; a main declaration), declared in LeanPool/FrontierMathOpenHypergraphs/Uniform.lean, line 2487: “Proves H(n) ≥ 26 * k(n) / 25 for every n ≥ 15.” Its source, as the card gives it: “Epoch AI FrontierMath, A Ramsey-style Problem on Hypergraphs.”HypergraphLowerBound.uniform_26_25(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Uniform.lean, line 702: “Proves the uniform recursive construction bound A(n) ≥ 26 * k(n) / 25 for every n ≥ 15.”HypergraphLowerBound.frame_recurrence(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Substitution.lean, line 705: “The substitution-frame recurrence that combines block witnesses and a valid support frame into a larger witness.”HypergraphLowerBound.lubell_is_frame(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Lubell.lean, line 526: “Proves that the Lubell support family forms a valid frame for every arity t ≥ 2.”HypergraphLowerBound.fixed_t_bound(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Lubell.lean, line 1264: “Derives a fixed-t lower bound for the exact witness supremum from Lubell frames.”HypergraphLowerBound.asymptotic_lower_bound(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Lubell.lean, line 1935: “Proves the asymptotic lower bound liminf H(n) / k(n) ≥ 2 * log 2.”HypergraphLowerBound.thm_asymptotic(theorem), declared in LeanPool/FrontierMathOpenHypergraphs/Lubell.lean, line 2012: “States the asymptotic consequence in terms of H(n) divided by n log n.”
Project
- Authors: Dean Cureton.
- Source: Choosing between incompatible ideals by Will Brian, Paul B. Larson, doi:10.1016/j.ejc.2021.103349, arXiv:1908.10914.
- Project repository: math-inc/FrontierMathOpen-Hypergraphs.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C65, 05D10, 03E02.
- In Lean Pool: LeanPool/FrontierMathOpenHypergraphs, from the card LeanPool/projects/frontiermath-open-hypergraphs.yaml.
Sources
DefinitionFundamental groups of finite connected graphs#
Constructs the standard interval-cell realization of a finite connected directed multigraph and proves that its topological fundamental group is a free group of rank E - V + 1. The proof uses an explicit spanning-tree basis and develops a verified path-lifting cover, a contraction of the covering tree, root-change equivalences, the tree/triviality criterion, and the corresponding free-abelian result.
Quoted from the card LeanPool/projects/finite-graph-fundamental-group.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 6 main results, each with its informal statement quoted from the card. The scan finds 6 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
FiniteGraphFreeGroup.graphTopologicalFundamentalGroupEquiv(def; a main declaration), declared in LeanPool/FiniteGraphFundamentalGroup/TopologicalComparison.lean, line 1747: “For a finite weakly connected directed multigraph, the topological fundamental group of its interval-cell quotient realization at any vertex is explicitly isomorphic to the free group on E + 1 - V generators.”FiniteGraphFreeGroup.graphCombinatorialToTopologicalEquiv(def), declared in LeanPool/FiniteGraphFundamentalGroup/TopologicalComparison.lean, line 1738: “The endomorphism group at a vertex in the graph's free groupoid is explicitly isomorphic to the topological fundamental group of the interval-cell realization.”FiniteGraphFreeGroup.graphCoverProjection_isCovering(theorem), declared in LeanPool/FiniteGraphFundamentalGroup/Cover.lean, line 135: “The canonical path-lifting projection from rooted free-groupoid paths to graph vertices is a quiver covering, with bijective maps on every incoming and outgoing edge star.”FiniteGraphFreeGroup.graphRealization_tree_simplyConnected(theorem), declared in LeanPool/FiniteGraphFundamentalGroup/TreeContraction.lean, line 402: “The interval-cell realization of a directed arborescence is simply connected, via an explicit continuous contraction to its root.”FiniteGraphFreeGroup.graphFundamentalGroup_subsingleton_iff_cycleRank_zero(theorem), declared in LeanPool/FiniteGraphFundamentalGroup/Consequences.lean, line 160: “The combinatorial fundamental group is trivial exactly when the graph's cycle rank E + 1 - V is zero.”FiniteGraphFreeGroup.graphFundamentalGroupFreeAbelianizationEquiv(def), declared in LeanPool/FiniteGraphFundamentalGroup/Consequences.lean, line 197: “The additive abelianization of the graph fundamental group is the free abelian group on E + 1 - V generators.”
Project
- Authors: Arthur Freitas Ramos, David Hulak, Ruy de Queiroz.
- Source: Algebraic Topology, Additional Topic 1.A: Graphs and Free Groups by Allen Hatcher, https://pi.math.cornell.edu/~hatcher/AT/AT.pdf.
- Project repository: Arthur742Ramos/finite-graph-fundamental-group, at commit dd57e3ab.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C25, 55Q05, 20F65.
- In Lean Pool: LeanPool/FiniteGraphFundamentalGroup, from the card LeanPool/projects/finite-graph-fundamental-group.yaml.
Sources
TheoremGenus-Zero Pairings and Catalan Numbers#
Formalizes the finite combinatorics behind the genus-zero term of the Wigner semicircle law: a pairing of Fin (2n), viewed as a fixed-point-free involution, has genus zero (total cycle count of the rotation product maximal) exactly when it is noncrossing, and these genus-zero pairings are counted by the Catalan number Cₙ. The Catalan recurrence is obtained from an explicit equivalence decomposing a noncrossing pairing by the partner of vertex 0 into independent inside and outside pairings.
Quoted from the card LeanPool/projects/semicircle-catalan.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 3 main results, each with its informal statement quoted from the card. The scan finds 3 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
card_noncrossingPairing_eq_catalan(theorem; a main declaration), declared in LeanPool/SemicircleCheck/CatalanRecurrence.lean, line 2053: “The number of noncrossing pairings on 2n points equals the Catalan number catalan n.”Pairing.genus_zero_count(theorem; a main declaration), declared in LeanPool/SemicircleCheck/CatalanRecurrence.lean, line 2081: “The number of genus-zero pairings of Fin (2n) equals the Catalan number catalan n.”Pairing.genus_zero_iff_noncrossing(theorem), declared in LeanPool/SemicircleCheck/GenusNoncrossing.lean, line 1096: “A pairing has genus zero if and only if it is noncrossing.”
Project
- Authors: Wondermonger-daydreaming.
- Source: semicircle-catalan: genus-zero pairings and the Catalan moments of the Wigner semicircle law by Wondermonger-daydreaming.
- Project repository: Wondermonger-daydreaming/semicircle-catalan.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05A15, 05A18.
- In Lean Pool: LeanPool/SemicircleCheck, from the card LeanPool/projects/semicircle-catalan.yaml.
Sources
TheoremGeometric Four-Colorings of the Moser Lattice and Ring#
Formalizes the two explicit parity colorings from Dúcz's 2026 note on the Moser lattice. The development derives the exact quadratic norm formula, proves that the integer-coordinate embedding is faithful, proves both colorings proper and geometric on the entire lattice, and descends them through localization by powers of three to the Moser ring. As a structural corollary, every unit-distance graph realized entirely in the Moser ring is four-colorable. The uniqueness classification of geometric four-colorings and the chromatic number of the full Euclidean plane are not claimed.
Quoted from the card LeanPool/projects/moser-lattice-colorings.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 2 main results, each with its informal statement quoted from the card. The scan finds 2 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
LeanPool.MoserLatticeColorings.MoserRing.both_colorings_are_geometric(theorem; a main declaration), declared in LeanPool/MoserLatticeColorings/Ring.lean, line 392: “The two parity maps defined by Dúcz descend to proper four-colorings of the full Moser ring, and equality of colors for each map depends only on Euclidean distance.” Its source, as the card gives it: “Theorem 3.1 and the Moser-ring extension following it.”LeanPool.MoserLatticeColorings.MoserRing.graph_colorable_four_of_moserRing_realization(theorem), declared in LeanPool/MoserLatticeColorings/Ring.lean, line 402: “Every abstract graph with a realization in the Moser ring that sends each edge to a unit-distance pair is four-colorable.” Its source, as the card gives it: “Corollary of the geometric four-coloring of the Moser ring.”
Project
- Authors: Egor Lyfar.
- Source: A note on geometric colorings of the Moser lattice by Ákos Dúcz, arXiv:2606.12325.
- Project repository: lyfar/moser-lattice-colorings-lean.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15.
- In Lean Pool: LeanPool/MoserLatticeColorings, from the card LeanPool/projects/moser-lattice-colorings.yaml.
Sources
TheoremGraph removal and extremal stability#
Formalizes the graph removal lemma for every fixed graph, Füredi's sharp stability inequality and Erdős–Simonovits stability for colourable forbidden graphs. A bridge theorem shows that near-extremal graphs with few labelled forbidden copies are close to a complete multipartite graph.
Quoted from the card LeanPool/projects/graph-removal-extremal-stability.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 4 main results, each with its informal statement quoted from the card. The scan finds 4 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
TuranStability.furedi(theorem), declared in LeanPool/RemovalExtremalStability/TuranStability.lean, line 48: “A clique-free graph near Turán's edge bound has a large colourable subgraph.” Its source, as the card gives it: “Füredi's stability theorem.”TuranStability.stability(theorem; a main declaration), declared in LeanPool/RemovalExtremalStability/TuranStability.lean, line 192: “An L-free graph near the Turán density for a (p+1)-colourable L is close in edit distance to a complete p-partite graph.” Its source, as the card gives it: “Erdős–Simonovits stability theorem.”RemovalLemma.graph_removal(theorem; a main declaration), declared in LeanPool/RemovalExtremalStability/GraphRemoval.lean, line 66: “Few labelled copies of any fixed graph H can be destroyed by deleting few edges.” Its source, as the card gives it: “Conlon–Fox, Graph removal lemmas, Theorem 1.1 (https://arxiv.org/pdf/1211.3487v1); Erdős–Frankl–Rödl (1986), Theorems 1.5 and 1.5′, are related precursors; formal source https://github.com/jtraverso/graph-removal-lemma/tree/589cf03ef1e4c80ea8cdd6be77778232c62dd37c.”RemovalExtremalStability.stability_of_few_copies(theorem), declared in LeanPool/RemovalExtremalStability/FewCopiesStability.lean, line 26: “A graph near the Turán density with few labelled L copies is close in edit distance to a complete multipartite graph.”
Project
- Authors: Juan Pablo Traverso Gianini.
- Source: Füredi and Erdős–Simonovits stability; general graph removal lemma by Juan Pablo Traverso Gianini.
- Project repository: jtraverso/turan-stability, at commit 3eb99033.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C35.
- In Lean Pool: LeanPool/RemovalExtremalStability, from the card LeanPool/projects/graph-removal-extremal-stability.yaml.
Sources
TheoremThe Hajnal–Szemerédi theorem on equitable vertex colourings#
Every finite simple graph of maximum degree at most r admits a proper colouring with r + 1 colours whose class sizes differ by at most one. When the vertex count is s(r + 1), every class can have exactly s vertices. The proof follows the Kierstead–Kostochka argument, preserving finite-subgraph and arbitrary-palette recolouring, reachability, terminal-class and discharging infrastructure. The polynomial-time algorithm from Section 3 is outside the imported scope.
Quoted from the card LeanPool/projects/hajnal-szemeredi.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 3 main results, each with its informal statement quoted from the card. The scan finds 3 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
HajnalSzemeredi.hajnalSzemeredi(theorem; a main declaration), declared in LeanPool/HajnalSzemeredi/Final.lean, line 88: “Every finite simple graph whose vertex degrees are at most r has a proper colouring by Fin (r + 1) such that the size of any colour class is at most the size of any other colour class plus one.”HajnalSzemeredi.hajnalSzemeredi_exact(theorem; a main declaration), declared in LeanPool/HajnalSzemeredi/Final.lean, line 49: “If a finite simple graph has s(r + 1) vertices and every vertex degree is at most r, it has a proper colouring by Fin (r + 1) with every class of size s.”HajnalSzemeredi.core(theorem), declared in LeanPool/HajnalSzemeredi/Main.lean, line 168: “For any finite vertex subset S and finite natural-number palette P of size r + 1, if S has s(r + 1) vertices and every vertex has at most r neighbours within S, there is a proper colouring of S in P with all classes of size s.”
Project
- Authors: Juan Pablo Traverso Gianini.
- Source: A short proof of the Hajnal–Szemerédi theorem on equitable colouring by H. A. Kierstead, A. V. Kostochka, doi:10.1017/S0963548307008619.
- Project repository: jtraverso/hajnal-szemeredi, at commit ba34061e.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15, 05C35.
- In Lean Pool: LeanPool/HajnalSzemeredi, from the card LeanPool/projects/hajnal-szemeredi.yaml.
Sources
TheoremHard-sphere Mayer NBC identity and fork-packing volume bound#
A kernel-checked Lean formalization of the exact no-broken-circuit volume identity for hard-sphere Mayer cluster integrals and the stronger dimension-three fork-packing upper bound for each tree-owned NBC region. The development proves finite broken-circuit cancellation, the measurable finite-region decomposition, the anchored Euclidean product-measure theorem, and its explicit flat-coordinate transport. Its geometric result is the attachment-aware estimate Vol(NBC_T) <= (17/32)^hardSphereNu T * hardSphereKappa^(k-1), where hardSphereNu T is the maximum cardinality of a packing of pairwise vertex-disjoint, order-compatible forks in T. A formal fork is an ordered triple (a,b,c) with a < b < c, center a, leaves b,c, and tree edges {a,b} and {a,c}. The central contribution is the complete pointwise-to-integral bridge together with the orientation-aware measure-preserving factorization that realizes the per-fork volume suppression.
Quoted from the card LeanPool/projects/hs-virial-nbc-identity.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 2 main results, each with its informal statement quoted from the card. The scan finds 2 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
PalomarHS.main_result(theorem; a main declaration), declared in LeanPool/HardSphereNBC/Solution.lean, line 28: “The absolute hard-sphere Mayer coefficient, multiplied by the factorial, equals the sum of nonnegative no-broken-circuit region volumes over spanning trees.”PalomarHS.nbc_region_real_volume_le_fork_factor(theorem; a main declaration), declared in LeanPool/HardSphereNBC/Solution.lean, line 107: “For a spanning tree in three dimensions, its no-broken-circuit region has volume at most (17/32) to the maximum disjoint compatible-fork packing size times the unit-ball volume to the number of tree edges.”
Project
- Authors: ukiyois, OpenCode agent sessions.
- Project repository: ukiyois/hs-virial-nbc-identity, at commit fd0a1e73.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15, 82B05.
- In Lean Pool: LeanPool/HardSphereNBC, from the card LeanPool/projects/hs-virial-nbc-identity.yaml.
Sources
TheoremHäggkvist–Janssen list edge colouring of complete graphs#
Proves that arbitrary lists of at least n colours on the edges of a complete graph with n vertices admit a proper list edge colouring. The proof constructs and proves uniqueness of the local rank certificate, identifies a nonzero extended-star polynomial coefficient, and applies Mathlib's combinatorial Nullstellensatz. This is an alternative proof presentation, not a literal translation of the article's argument. The conclusion uses Mathlib's actual edge type and line-graph colouring, with no certificate hypothesis and no restriction on the colour universe. This formalizes a classical theorem, not a new bound or a solution of the general list-edge conjecture.
Quoted from the card LeanPool/projects/list-edge-coloring-complete.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists one main result, with its informal statement quoted from the card. The scan finds its declaration in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
LeanPool.ListEdgeColoringComplete.exists_listEdgeColoring_complete(theorem; a main declaration), declared in LeanPool/ListEdgeColoringComplete/Main.lean, line 80: “For every finite vertex type V, arbitrary colour type and finite list on each edge of the complete graph, if every list has cardinality at least the number of vertices, there is a proper colouring of the line graph choosing a colour from each list. This includes orders zero and one.” Its source, as the card gives it: “Häggkvist–Janssen (1997), Theorems 1.1 and 3.1, complete-graph case.”
Project
- Authors: Juan Pablo Traverso Gianini.
- Source: New Bounds on the List-Chromatic Index of the Complete Graph and Other Simple Graphs by Roland Häggkvist, Jeannette Janssen, doi:10.1017/S0963548397002927.
- Project repository: jtraverso/haggkvist-janssen, at commit 26d7b2ee.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15.
- In Lean Pool: LeanPool/ListEdgeColoringComplete, from the card LeanPool/projects/list-edge-coloring-complete.yaml.
Sources
TheoremKahn–Kalai expectation-threshold theorem#
Formalizes Tran and Vu's short proof of the Park–Pham theorem resolving the Kahn–Kalai expectation-threshold conjecture. For an ℓ-bounded family of subsets of a finite ground set, it proves the strengthened covering theorem with the explicit constant L = 1000 and derives the threshold bound p_c(F) ≤ K q(F) log₂ ℓ with the explicit witness K = 100000. The supporting library develops finite-set cover cost, level-density, double-counting, binomial-tail, and numeric estimates.
Quoted from the card LeanPool/projects/kahn-kalai.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 2 main results, each with its informal statement quoted from the card. The scan finds 2 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
KahnKalai.covering_theorem(theorem; a main declaration), declared in LeanPool/KahnKalai.lean, line 34: “If ℓ ≤ N, p lies in [0, 1], and an ℓ-bounded family H has cover cost at least 1/2 - 2^(-(ℓ+2)), then its upset has at least (2/3 + 2^(-(ℓ+2))) choose(N, m) members of cardinality m, where m = floor(1000 p N log₂(ℓ+1)). For m ≤ N this is the corresponding level-density bound; for N < m both cardinalities are zero.”KahnKalai.park_pham(theorem; a main declaration), declared in LeanPool/KahnKalai.lean, line 49: “There is an absolute positive constant K such that every ℓ-bounded finite family with ℓ at least two satisfies p_c(F) ≤ K q(F) log₂ ℓ; the proof supplies K = 100000.”
Project
- Authors: Dan Clemens Posch.
- Source: A Short Proof of Kahn-Kalai Conjecture by Phuc Tran, Van Vu, doi:10.37236/12266, arXiv:2303.02144.
- Project repository: dcposch/kahn-kalai-lean, at commit 641aa75f.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C80, 60C05.
- In Lean Pool: LeanPool/KahnKalai, from the card LeanPool/projects/kahn-kalai.yaml.
Sources
TheoremKnown Bounds for the Hadwiger-Nelson Problem#
Formalizes the currently known bounds 5 <= chi(R^2) <= 7 for the chromatic number of the Euclidean plane. The upper bound constructs an explicit Isbell-style seven-coloring. The lower bound checks Parts' 481-vertex coloring certificate, develops a finite doubled triangular-lattice forcing gadget, proves its exact Euclidean embedding, and closes the four-color contradiction with a spindle construction. The exact chromatic number remains open.
Quoted from the card LeanPool/projects/hadwiger-nelson-bounds.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 3 main results, each with its informal statement quoted from the card. The scan finds 3 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
HadwigerNelsonBounds.hadwiger_nelson_known_bounds(theorem; a main declaration), declared in LeanPool/HadwigerNelsonBounds/PartsSpindle.lean, line 122: “The chromatic number of the unit-distance graph on the Euclidean plane lies between five and seven, inclusive.”HadwigerNelsonBounds.unitDistanceGraph_not_colorable_four(theorem), declared in LeanPool/HadwigerNelsonBounds/PartsSpindle.lean, line 85: “The unit-distance graph on the Euclidean plane admits no proper coloring with four colors.”HadwigerNelsonBounds.chromaticNumber_le_seven(theorem), declared in LeanPool/HadwigerNelsonBounds/IsbellColoring.lean, line 204: “An explicit Isbell-style coloring proves that the unit-distance graph on the Euclidean plane is colorable with seven colors.”
Project
- Authors: Egor Lyfar.
- Source: A human-verifiable proof of the chromatic number of the plane being at least 5 by Jaan Parts, arXiv:2010.12661, https://www.erdosproblems.com/508.
- Project repository: lyfar/hadwiger-nelson-bounds-lean.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15, 52C10.
- In Lean Pool: LeanPool/HadwigerNelsonBounds, from the card LeanPool/projects/hadwiger-nelson-bounds.yaml.
Sources
TheoremKolokolnikov's ACMAX conjecture#
Proves that every simple graph on n ≥ 4 vertices with 2(n−2) edges has algebraic connectivity at most 2, attained by the complete bipartite graph K₂,ₙ₋₂. Develops Laplacian test-vector bounds, sparse cut certificates, and non-backtracking walk estimates used in the proof.
Quoted from the card LeanPool/projects/acmax-conjecture.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 4 main results, each with its informal statement quoted from the card. The scan finds 4 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
ACMax.acmax_conjecture(theorem; a main declaration), declared in LeanPool/ACMax.lean, line 42: “For n ≥ 4, the algebraic connectivity of K₂,ₙ₋₂ is 2, and every simple graph on Fin n with exactly 2(n−2) edges has algebraic connectivity at most 2. Algebraic connectivity is the second-smallest eigenvalue of the combinatorial Laplacian, defined using Mathlib's ordered spectrum.”ACMax.algConn_mul_sq_le(theorem), declared in LeanPool/ACMax/Spectral/RayleighUpper.lean, line 29: “For a graph on any nonempty finite vertex type and any real vector whose coordinates sum to zero, algebraic connectivity times the squared norm is at most the Laplacian quadratic form.”ACMax.algConn_le_two_of_testvector(theorem), declared in LeanPool/ACMax/Spectral/TestVector.lean, line 31: “A nonzero real vector with coordinate sum zero and Laplacian quadratic form at most twice its squared norm certifies algebraic connectivity at most 2.”ACMax.algConn_completeBipartite_two(theorem), declared in LeanPool/ACMax/Spectral/AlgConnK2.lean, line 24: “For n ≥ 4, the complete bipartite graph with parts of sizes 2 and n−2 has algebraic connectivity exactly 2.”
Project
- Authors: Zeru Zhu, Jinzheng Li, Yuanjie Ren.
- Source: Maximizing algebraic connectivity for certain families of graphs, Conjecture 1.5 by Theodore Kolokolnikov, doi:10.1016/j.laa.2014.12.023, arXiv:1412.6147.
- Project repository: MerLeanProver/ACMaxConjecture, at commit 78736ca2.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C50, 05C35.
- In Lean Pool: LeanPool/ACMax, from the card LeanPool/projects/acmax-conjecture.yaml.
Sources
DefinitionLine-graph colourings and matching decompositions#
Connects Mathlib line-graph colourings to palette-indexed partitions of actual graph edges into Mathlib matching subgraphs. Both conversions are inverse, preserve each matching exactly, and allow empty colours without a default colour or a finiteness assumption. An edge equivalence yields exact edge accounting: natural-number counts require only finite edges and a finite palette, while indexed cardinal counts allow arbitrary vertices, edges, and palettes. This is classical representation interoperability, not a new colouring bound or a claim of priority.
Quoted from the card LeanPool/projects/line-graph-colouring-matching.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 6 main results, each with its informal statement quoted from the card. The scan finds 6 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
SimpleGraph.lineGraphColoringEquivMatchingDecomposition(def; a main declaration), declared in LeanPool/GraphColouringMatching/Basic.lean, line 201: “Proper colourings of the line graph on any palette are equivalent to partitions of the original edges into matching subgraphs indexed by that palette, with empty classes permitted.” Its source, as the card gives it: “New adapter proved in GraphColouringMatching/Basic.lean, using Mathlib's existing lineGraph, Coloring and Subgraph.IsMatching.”SimpleGraph.MatchingDecomposition.edgeMatching_lineGraphColoring(theorem), declared in LeanPool/GraphColouringMatching/Basic.lean, line 163: “Converting a matching decomposition to a colouring and extracting one colour class returns exactly its original matching subgraph.”SimpleGraph.MatchingDecomposition.edgeEquivSigma(def), declared in LeanPool/GraphColouringMatching/Basic.lean, line 111: “Original graph edges are in bijection with the disjoint union of the edge types of the palette-indexed matching subgraphs.”SimpleGraph.MatchingDecomposition.card_edges_eq_sum(theorem), declared in LeanPool/GraphColouringMatching/Finite.lean, line 26: “For a finite edge set and finite palette, the number of graph edges equals the sum of the numbers of edges in its matching classes, even when the vertex set is infinite.”SimpleGraph.MatchingDecomposition.cardinal_edges_eq_sum(theorem), declared in LeanPool/GraphColouringMatching/Cardinal.lean, line 27: “Without any finiteness assumption on vertices, edges, or colours, the cardinality of the graph edge set equals the indexed cardinal sum of the matching-class edge cardinalities, with a universe lift on the graph edge cardinality when required.” Its source, as the card gives it: “Cardinal.lean applies Mathlib's indexed cardinal sum to the existing edgeEquivSigma; no infinite graph-colouring theorem is assumed.”SimpleGraph.lineGraph_colorable_iff_matchingDecomposition(theorem), declared in LeanPool/GraphColouringMatching/Basic.lean, line 215: “The line graph is k-colourable if and only if the graph edges decompose into k matchings, allowing unused colours.”
Project
- Authors: Juan Pablo Traverso Gianini.
- Source: Original Lean Pool graph-colouring and matching adapters, https://github.com/jtraverso/lean-pool/tree/4c1fddb73f9891afc2186f8f11066ea2a08fe4fc/LeanPool/GraphColouringMatching.
- Project repository: jtraverso/lean-pool, at commit 4c1fddb7.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15, 05C70.
- In Lean Pool: LeanPool/GraphColouringMatching, from the card LeanPool/projects/line-graph-colouring-matching.yaml.
Sources
TheoremLinear finite bipartization costs force countable graph colourings#
A graph whose every finite subgraph on m vertices can be made bipartite by deleting at most C m edges has a proper colouring by natural numbers. Consequently the maximum finite-subgraph bipartization cost h_G(n), divided by n, tends to infinity for every graph that is not countably colourable, including every graph with chromatic cardinal aleph-one. The development preserves finite edge costs, rooted-pattern extension costs, closure chains, probability laws on Boolean products, finite minimax, Hilbert-space classes, and colouring along well-founded orders. It answers the limit question of Erdős Problem 111; it does not determine the exact growth of h_G.
Quoted from the card LeanPool/projects/erdos111-bipartization.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 4 main results, each with its informal statement quoted from the card. The scan finds 4 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
Erdos111.countably_colorable_of_linear(theorem; a main declaration), declared in LeanPool/Erdos111.lean, line 42: “For any real C, if each finite subgraph H of G has bipartization number at most C times its number of vertices, G admits a proper colouring by natural numbers. Vertex types may inhabit any universe.”Erdos111.tendsto_of_not_countably_colorable(theorem), declared in LeanPool/Erdos111.lean, line 49: “If G has no proper colouring by natural numbers, h_G(n)/n tends to positive infinity along the whole natural-number sequence.”Erdos111.erdos_111(theorem), declared in LeanPool/Erdos111.lean, line 55: “For every graph of chromatic cardinal aleph-one, h_G(n)/n tends to positive infinity. Here h_G(n) is the largest number of edge deletions needed to bipartize a subgraph on n vertices.”Erdos111.exists_unitVector_classes(theorem), declared in LeanPool/Erdos111/HilbertClasses.lean, line 85: “In any real Hilbert space, unit vectors can be partitioned into countably many classes, each with a positive lower bound for one plus the inner product of any two vectors in that class.”
Project
- Authors: Jacob Parish.
- Source: Graphs whose finite subgraphs have linear bipartization cost are countably colorable by Plasma AI, proof, problem.
- Project repository: plasma-ai/erdos-111, at commit de72caf0.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C15, 05C63, 03E05.
- In Lean Pool: LeanPool/Erdos111, from the card LeanPool/projects/erdos111-bipartization.yaml.
Sources
TheoremMaxima of Coxeter frieze patterns are Fibonacci numbers#
Formalizes the claim that the sequence of maxima of values of (Coxeter) arithmetic frieze patterns is the Fibonacci sequence, using a correspondence between arithmetic frieze patterns and n-flutes.
Quoted from the card LeanPool/projects/frieze-patterns.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 4 main results, each with its informal statement quoted from the card. The scan finds 4 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
main3(theorem; a main declaration), declared in LeanPool/FriezePatterns/Chapter3.lean, line 536: “Proves that the maximum value of an arithmetic frieze pattern of width n is exactly the n-th Fibonacci number, and that this bound is attained.”FluteBounded(theorem; a main declaration), declared in LeanPool/FriezePatterns/Chapter2.lean, line 679: “Proves that every entry of an n-flute is bounded above by the n-th Fibonacci number.”glideSymm(theorem; a main declaration), declared in LeanPool/FriezePatterns/Chapter1.lean, line 145: “Proves the glide-reflection symmetry of Coxeter frieze patterns.”translationInvariance(theorem; a main declaration), declared in LeanPool/FriezePatterns/Chapter1.lean, line 188: “Proves the (n+1)-periodicity (horizontal translation invariance) of Coxeter frieze patterns.”
Project
- Authors: Antoine de Saint-Germain, Akselai, Jon Cheah, Bockman Cheung, Eaton Liu.
- Source: On upper bounds in frieze patterns by Antoine de Saint-Germain, doi:10.1080/00150517.2024.2430958, arXiv:2407.16717.
- Project repository: Antoine-dSG/frieze_patterns.
- Provenance: human, which in Lean Pool's terms means its Lean proofs were “written by people”.
- License: Apache-2.0.
- MSC2020: 05E15, 11B39, 13F60.
- In Lean Pool: LeanPool/FriezePatterns, from the card LeanPool/projects/frieze-patterns.yaml.
Sources
TheoremNash-Williams–Tutte tree packing and arboricity#
A finite simple graph on a nonempty vertex type has k edge-disjoint spanning trees exactly when every partition into m nonempty parts has at least k(m − 1) crossing edges. The development also proves the Nash-Williams characterization of covering the edges by k forests, and that every finite nonempty 2k-edge-connected simple graph has k edge-disjoint spanning trees. It preserves the general forest exchange lemma and supporting reachability and edge-counting infrastructure, using Mathlib's graph definitions.
Quoted from the card LeanPool/projects/nash-williams-tutte.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 4 main results, each with its informal statement quoted from the card. The scan finds 4 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
NashWilliamsTutte.tree_packing(theorem; a main declaration), declared in LeanPool/NashWilliamsTutte/Theorems.lean, line 42: “A finite simple graph on a nonempty vertex type has k pairwise edge-disjoint spanning trees if and only if every vertex partition into m nonempty parts has at least k(m − 1) crossing edges.”NashWilliamsTutte.arboricity(theorem; a main declaration), declared in LeanPool/NashWilliamsTutte/Theorems.lean, line 116: “A finite simple graph is the union of k forests if and only if every nonempty finite vertex set S induces at most k(|S| − 1) edges.”NashWilliamsTutte.exists_trees_of_isEdgeConnected(theorem), declared in LeanPool/NashWilliamsTutte/Theorems.lean, line 191: “Every finite simple graph on a nonempty vertex type that remains connected after deletion of fewer than 2k edges has k pairwise edge-disjoint spanning trees.”NashWilliamsTutte.exists_forests_core(theorem), declared in LeanPool/NashWilliamsTutte/Auxiliary.lean, line 407: “Every finite simple graph G contains k pairwise edge-disjoint forests and a subgraph H such that intersecting each forest with H preserves the connected components of H, and the forests cover every edge of G outside H.”
Project
- Authors: Juan Pablo Traverso Gianini.
- Source: Edge-disjoint spanning trees of finite graphs, doi:10.1112/jlms/s1-36.1.445.
- Project repository: jtraverso/nash-williams-trees, at commit 101e4884.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05C05, 05C70, 05C40.
- In Lean Pool: LeanPool/NashWilliamsTutte, from the card LeanPool/projects/nash-williams-tutte.yaml.
Sources
TheoremNear-perfect triangle packings from sum-zero triples#
Records a reusable formalization byproduct accompanying Paper III: pairwise edge-disjoint triangles in any finite complete graph such that every vertex is incident to at most three uncovered edges, using a cyclic-group sum-zero triple system, with a bridge to Mathlib's SimpleGraph API.
Quoted from the card LeanPool/projects/erdos81-paper-iii-sum-zero-triangles.yaml of LeanPool/lean-pool at commit 2b205bf9, Apache-2.0.
Main results
The card lists 2 main results, each with its informal statement quoted from the card. The scan finds 2 of their declarations in the project's files at commit 2b205bf9. A found declaration links its page in Lean Pool's documentation, which Lean Pool rebuilds daily from its main branch, and its line at this commit.
SumZeroTriangles.exists_simpleGraph_triangle_packing(theorem; a main declaration), declared in LeanPool/Erdos81PaperIIIContrib/SimpleGraph.lean, line 98: “For every finite vertex type, its complete simple graph has a family of pairwise edge-disjoint triangle graphs whose uncovered graph has degree at most three at every vertex.”SumZeroTriangles.exists_triangle_packing_clique(theorem), declared in LeanPool/Erdos81PaperIIIContrib/SumZeroTriangles.lean, line 374: “Every finite complete graph has a family of pairwise edge-disjoint triangles leaving uncovered degree at most three at every vertex.”
Project
- Authors: Juan Pablo Traverso Gianini, Aristotle, Vasily Ilin.
- Source: SumZeroTriangles.lean, a reusable formalization byproduct accompanying Linear-Error Clique Partitions of Split Graphs via Structured Triangle Packing by Aristotle, https://github.com/jtraverso/erdos-81-chordal-clique-partitions/blob/main/preprints/PAPER_III/05_formalization/lean_v1.4_freeze/Contrib/SumZeroTriangles.lean.
- Project repository: jtraverso/erdos-81-chordal-clique-partitions.
- Provenance: AI, which in Lean Pool's terms means its Lean proofs were “mostly produced by an AI system”.
- License: Apache-2.0.
- MSC2020: 05B07, 05C70.
- In Lean Pool: LeanPool/Erdos81PaperIIIContrib, from the card LeanPool/projects/erdos81-paper-iii-sum-zero-triangles.yaml.
Sources
Loading dependency explorer…
The dependency explorer needs JavaScript and its graph data.