Datasets:

MathNetwork
/

MathlibGraph

license: apache-2.0
task_categories:
  - graph-ml
language:
  - en
tags:
  - mathematics
  - lean4
  - mathlib
  - dependency-graph
  - formal-verification
  - network-analysis
size_categories:
  - 100K<n<1M

MathlibGraph: The Multinetwork of Mathlib

Dependency graph of Mathlib (commit 534cf0b, 2 Feb 2026), the largest formal mathematics library for Lean 4 (v4.28.0-rc1).

Three dependency layers (declarations, modules, namespaces), each with nodes, edges, and precomputed network metrics.

Quick Stats

	Declarations	Modules	Namespaces (k=2)
Nodes	308,129	7,564	10,097
Edges	8,436,366	20,881	332,081 (weighted)
DAG depth	83	154	7 (after SCC condensation)
Louvain modularity	0.478	0.610	0.270
Synthesized edges	74.2%	—	—
In cycles	5,732 nodes	0 (DAG)	6,055 nodes (38 SCCs)

Files

Raw Data (v1)

File	Rows	Description
`mathlib_edges.csv`	8,436,366	Declaration dependency edges
`mathlib_nodes.csv`	317,655	Declarations before deduplication
`nodes.csv` / `edges.csv`	633K / 10.9M	Full environment (Lean + Std + Mathlib)
`mechanisms.ndjson`	—	Lean language mechanism extractions
`tactic_usage.ndjson`	—	Per-declaration tactic usage profiles

Three-Layer Graphs (v2)

Each layer has nodes.csv, edges.csv, and metrics.csv:

Folder	Nodes	Edges	Metrics	Description
`v2/declaration/`	308,129	(use root `mathlib_edges.csv`)	308,129 x 11	Theorems, definitions, and other named constants
`v2/module/`	7,564	20,881	7,564 x 10	Source files linked by `import` statements
`v2/namespace/`	10,097	332,081	10,097 x 11	Depth-2 dotted-name prefixes, weighted edges

v2/summary.json contains headline statistics for all three levels.

Quick Start

from datasets import load_dataset

# Declaration level
decl = load_dataset("MathNetwork/MathlibGraph",
                    data_files="v2/declaration/metrics.csv", split="train").to_pandas()
edges = load_dataset("MathNetwork/MathlibGraph",
                     data_files="mathlib_edges.csv", split="train").to_pandas()

# Module level
mod_nodes = load_dataset("MathNetwork/MathlibGraph",
                         data_files="v2/module/nodes.csv", split="train").to_pandas()
mod_edges = load_dataset("MathNetwork/MathlibGraph",
                         data_files="v2/module/edges.csv", split="train").to_pandas()

# Namespace level
ns_nodes = load_dataset("MathNetwork/MathlibGraph",
                        data_files="v2/namespace/nodes.csv", split="train").to_pandas()
ns_edges = load_dataset("MathNetwork/MathlibGraph",
                        data_files="v2/namespace/edges.csv", split="train").to_pandas()

Schema

v2/declaration/nodes.csv

Deduplicated from mathlib_nodes.csv (317,655 to 308,129 rows; 9,526 @[to_additive] mirrors removed).

Column	Type	Description
name	str	Fully qualified declaration name
kind	str	theorem, definition, abbrev, inductive, constructor, opaque, axiom, or quotient
module	str	Parent namespace (null for 30,944 Lean core declarations)

v2/declaration/metrics.csv

All columns from nodes.csv plus:

Column	Type	Description
namespace_depth2	str	First 2 dot-separated components (e.g., `Mathlib.Algebra`)
namespace_depth3	str	First 3 dot-separated components
in_degree	int	Declarations that depend on this one
out_degree	int	Declarations this one depends on
pagerank	float	PageRank (alpha=0.85)
betweenness	float	Betweenness centrality (k=500, seed=42)
community_id	int	Louvain community
dag_layer	int	Topological depth; -1 for 5,732 nodes in cycles
file_module	str	Source file module (from Lean environment, 278K coverage)
is_tactic_proof	bool	Whether the proof uses tactics (78,315 declarations)
tactic_count	int	Number of tactics used in the proof
top_tactic	str	Most frequently used tactic in this proof
is_instance	bool	Whether this is a typeclass instance (26,415 declarations)
instance_class	str	Which typeclass this instance implements
is_coercion	bool	Whether this is a coercion (241 declarations)
to_additive_pair	str	Name of the corresponding additive/multiplicative variant
def_height	float	Definitional height in the kernel (42,935 declarations)

v2/module/nodes.csv

Column	Type	Description
module	str	Dotted module name (e.g., `Mathlib.Algebra.Group.Defs`)
decl_count	int	Declarations defined in this source file

v2/module/edges.csv

Column	Type	Description
source	str	Importing module
target	str	Imported module
is_exported	bool	Whether this is a public import (20,699 of 20,881)

v2/module/metrics.csv

Column	Type	Description
module	str	Module name
decl_count	int	Declarations in this module (full decl_module mapping, 499K coverage)
in_degree	int	Modules that import this one
out_degree	int	Modules this one imports
pagerank	float	PageRank on module import graph
betweenness	float	Betweenness centrality (exact)
dag_layer	int	Topological depth in module DAG
community_id	int	Louvain community
cohesion	float	Fraction of declaration edges staying within module
import_utilization_median	float	Median fraction of imported declarations used

v2/namespace/nodes.csv

Column	Type	Description
namespace	str	Depth-2 namespace (e.g., `Mathlib.Algebra`)
decl_count	int	Declarations in this namespace
in_cycle	bool	True if this namespace is in a strongly connected component
scc_id	int	SCC identifier (-1 if not in a cycle)

v2/namespace/edges.csv

Column	Type	Description
source	str	Source namespace
target	str	Target namespace
weight	int	Number of declaration-level edges between these namespaces

v2/namespace/metrics.csv

Column	Type	Description
namespace	str	Depth-2 namespace
decl_count	int	Declarations in this namespace
in_degree	int	Unweighted in-degree
out_degree	int	Unweighted out-degree
edge_weight_sum	int	Total declaration edges involving this namespace
pagerank	float	Weighted PageRank (alpha=0.85)
betweenness	float	Weighted betweenness (k=300, seed=42)
community_id	int	Louvain community (weighted undirected)
cross_ns_ratio	float	Fraction of edges crossing namespace boundaries
in_cycle	bool	In a strongly connected component (6,055 of 10,097)
scc_id	int	SCC identifier (-1 if acyclic)

Methodology

Extraction: lean4export (nodes) + lean-training-data (edges) + importGraph (module graph) + jixia (metadata)
Deduplication: by name, 317,655 to 308,129 rows (9,526 @[to_additive] mirrors)
Self-loops: 4,755 constructor self-references filtered
PageRank: alpha=0.85, max_iter=100, tol=1e-6
Betweenness: declaration k=500, namespace k=300, module exact; seed=42
Communities: Louvain, resolution=1.0, random_state=42, undirected projection
DAG layers: Kahn's algorithm; cycle nodes get layer=-1; namespace graph condensed via SCC
Namespace cycles: 6,055 of 10,097 namespaces in 38 SCCs (largest: 5,899 nodes)

Hold-Out Experiments

We validate the premise retrieval results with two levels of hold-out experiments to assess information leakage. In the original experiment, all network features (degree, PageRank, betweenness, community, DAG layer) are precomputed on the full graph. Hold-out experiments recompute features on a reduced graph to test whether full-graph computation inflates AUC.

Edge-level hold-out

Randomly remove 20% of edges, recompute all features on remaining 80% graph
Tests whether full-graph feature computation inflates AUC

Declaration-level hold-out

Split theorems 80/20, remove ALL edges (incoming and outgoing) of test theorems from training graph
Test theorems have zero degree in training graph
Simulates the real scenario: predicting premises for a brand new theorem

Results (Split 1, seed=42)

Method	AUC (original)	AUC (edge hold-out)	AUC (decl hold-out)
Random	0.499	0.497	0.500
Same module	0.563	0.562	0.563
Same namespace	0.590	0.590	0.592
Same community	0.768	0.755	0.500
Network features	0.991	0.988	0.978
All features	0.994	0.992	0.984

The community feature drops to random (0.500) in declaration-level hold-out because test declarations become isolated nodes with unique community IDs. Despite this, the combined network feature model retains AUC=0.978, confirming that degree, PageRank, and DAG position carry genuine predictive signal independent of information leakage.

Full 5-split results with mean and std are in experiments/holdout_decl_level.json (updated incrementally).

Experiment Files

File	Description
`experiments/premise_retrieval_results.json`	Original experiment: 6 methods, 4 metrics, 95% CI
`experiments/premise_retrieval_hard_negatives.json`	Hard negatives (same-community) variant
`experiments/holdout_edge_level.json`	Edge-level hold-out (1 split)
`experiments/holdout_decl_level.json`	Declaration-level hold-out (5 splits, incremental)

License

Apache 2.0