FACTPROP

Popular Knowledge Propagates More Errors in LLM Knowledge Updating

Project page & demo · Research code · Graph schema

What is FACTPROP?

FACTPROP is a connected factual knowledge graph for studying how knowledge is structured and how factual updates propagate through large language models. The released builder generates factual candidates with an LLM and validates supported relations against Wikidata. Project materials describe the candidates as Wikipedia-derived, but the released pipeline does not ingest Wikipedia article text.

The release provides two ways to use the same graph:

1. knowledge_edges (recommended): a safe, columnar Parquet view of every forward factual connection, loadable without Python pickle.
2. factprop_graph_v1.pkl (canonical): the unchanged NetworkX checkpoint containing the complete graph and construction metadata.

The default Dataset Viewer shows each knowledge connection as:

subject ── relation ──▶ object_node_label

For example, an edge can also carry a natural-language question, a surface statement, construction-time confidence, and connectivity statistics.

At a glance

• 100,015 graph nodes
• 357,205 forward factual edges
• 75,357 auxiliary inverse traversal edges
• 432,562 stored directed edges in the canonical checkpoint
• 31 forward relation identifiers in knowledge_edges, plus 8 inverse-only identifiers in the checkpoint (39 stored relation types total)
• Natural-language question and surface fields on graph edges where available
• Wikidata QIDs where mappings are available
• Forward-edge in-degree and out-degree for connectivity analysis

The default Parquet split contains all 357,205 forward edges. It is not a sample and is not a predefined train/test split.

Which artifact should I use?

Goal	Recommended artifact	What it contains
Browse or analyze factual connections	knowledge_graph/knowledge_edges	All forward subject → relation → object edges and selected metadata
Use a DataFrame, Arrow, DuckDB, or Hugging Face Datasets	data/knowledge_edges.parquet	Compact tabular representation of forward graph topology
Inspect mapped, readable entities by popularity	entity_index/curated	Entity labels, QIDs, and forward object in-degree
Reproduce exact graph traversal or inspect evidence	factprop_graph_v1.pkl	Canonical NetworkX graph, inverse edges, evidence, and construction state
Verify files or pin a release	SHA256SUMS and a Hub revision	Published checksums and immutable commit history

What does “download the dataset” mean?

• load_dataset(..., split="knowledge_edges") downloads the complete forward connection table.
• hf download factprop/FACTPROP --repo-type dataset downloads the entire release, including the canonical graph checkpoint.
• load_dataset(..., split="curated") downloads only the curated entity summary; it is not the complete graph.

If your goal is to obtain all knowledge connections in an easy-to-use format, use knowledge_edges. If you also need inverse traversal edges, stored evidence, or construction metadata, download factprop_graph_v1.pkl.

Data model

Nodes

Node identifiers are graph-label strings. A node can represent:

• A mapped entity with a Wikidata QID.
• An unmapped entity label.
• A literal value such as a date.

The canonical checkpoint stores qid and qid_status as node attributes.

Forward knowledge edges

Each forward edge represents one stored factual connection:

(subject, relation, object_node_label)

The Parquet representation includes:

Field	Type	Meaning
edge_id	integer	Sequential table row ID starting at zero; not a graph-node ID
subject	string	Source node label
subject_qid	string or null	Subject Wikidata QID where available
relation	string	FACTPROP relation identifier
object_node_label	string	Canonical target-node label; use this field for display, filtering, and topology reconstruction
object_qid	string or null	Object Wikidata QID where available
object_type	string	entity, literal, or date_literal
question	string or null	Natural-language question associated with the fact
surface	string or null	Natural-language statement expressing the fact
group	string or null	Construction category such as Person, Work, or Event
confidence	float or null	Construction-time confidence; not a calibrated probability
subject_forward_out_degree	integer	Number of forward facts originating from the subject
object_forward_in_degree	integer	Number of forward facts pointing to the object

The table is sorted by descending object_forward_in_degree, making highly connected objects easy to inspect. object_node_label is the single target-node field and exactly matches the canonical checkpoint label.

Auxiliary inverse edges

The checkpoint also contains 75,357 edges whose is_inverse attribute is true. These support reverse traversal but must not be counted as additional original facts. They are excluded from knowledge_edges.

Structural popularity

FACTPROP defines structural popularity for an object node o as:

number of incoming edges to o where is_inverse is not true

This is the object_forward_in_degree field in the edge table and forward_object_in_degree in the entity index.

It measures connectivity inside this graph version. It does not measure web traffic, public familiarity, cultural importance, or the error probability of a particular model.

For example:

• Apple Inc. / Q312: forward object in-degree 467
• Apple / Q89: forward object in-degree 4

These are separate graph nodes.

Quick start: load every forward knowledge connection

Install the tabular dependencies:

python -m pip install datasets pyarrow

Load the complete forward graph table:

from datasets import load_dataset

edges = load_dataset(
    "factprop/FACTPROP",
    "knowledge_graph",
    split="knowledge_edges",
)

print(edges.num_rows)       # 357205
print(edges.column_names)

Inspect one connection:

row = edges[0]
print(f'{row["subject"]} --{row["relation"]}--> {row["object_node_label"]}')
print("Question:", row["question"])
print("Statement:", row["surface"])
print("Object connectivity:", row["object_forward_in_degree"])

Pin the data revision for a reproducible experiment:

edges = load_dataset(
    "factprop/FACTPROP",
    "knowledge_graph",
    split="knowledge_edges",
    revision="<commit-id>",
)

Common recipes

Find all facts involving an entity

entity = "Apple Inc."

connected = edges.filter(
    lambda row: (
        row["subject"] == entity or row["object_node_label"] == entity
    )
)

print(
    connected.select_columns(
        ["subject", "relation", "object_node_label"]
    )[:20]
)

For incoming facts only:

incoming = edges.filter(lambda row: row["object_node_label"] == entity)
print("Incoming forward facts:", incoming.num_rows)

Filter by relation or knowledge category

birth_facts = edges.filter(lambda row: row["relation"] == "BirthDate")
work_facts = edges.filter(lambda row: row["group"] == "Work")

Use questions and statements for retrieval or QA research

qa_edges = edges.filter(
    lambda row: row["question"] is not None and row["surface"] is not None
)

qa_view = qa_edges.select_columns(
    ["subject", "relation", "object", "question", "surface"]
)

Do not assume these rows are independent examples. Split by connected entities or graph components when entity leakage would invalidate an evaluation.

Reconstruct the forward graph with NetworkX

python -m pip install datasets networkx

import networkx as nx
from datasets import load_dataset

edges = load_dataset(
    "factprop/FACTPROP",
    "knowledge_graph",
    split="knowledge_edges",
)

graph = nx.DiGraph()
for row in edges:
    graph.add_edge(
        row["subject"],
        row["object_node_label"],
        relation=row["relation"],
        question=row["question"],
        surface=row["surface"],
        confidence=row["confidence"],
        group=row["group"],
    )

print(graph.number_of_nodes())  # 100015
print(graph.number_of_edges())  # 357205
print(graph.in_degree("Apple Inc."))  # 467

Using object_node_label reconstructs all 100,015 nodes and all 357,205 canonical forward edges. It does not restore the excluded inverse traversal edges, stored evidence, or checkpoint construction state. Use factprop_graph_v1.pkl when those are required.

Explore a local multi-hop neighborhood

entity = "Apple Inc."
undirected_view = graph.to_undirected(as_view=True)

distance = nx.single_source_shortest_path_length(
    undirected_view,
    entity,
    cutoff=2,
)

one_hop = [node for node, hops in distance.items() if hops == 1]
two_hop = [node for node, hops in distance.items() if hops == 2]

Directed and undirected distances answer different research questions. Record the chosen convention; do not assume this generic example reproduces a specific FACTPROP paper protocol.

Analyze relation and connectivity distributions

from collections import Counter

relation_counts = Counter(edges["relation"])
group_counts = Counter(value for value in edges["group"] if value is not None)

For the complete node-level degree distribution, load the unchanged entity index directly:

from datasets import load_dataset
from huggingface_hub import hf_hub_download

path = hf_hub_download(
    "factprop/FACTPROP",
    "data/entities.jsonl",
    repo_type="dataset",
)

all_nodes = load_dataset("json", data_files=path, split="train")

Curated entity index

The optional curated split is intended for readable entity-level browsing:

from datasets import load_dataset

entities = load_dataset(
    "factprop/FACTPROP",
    "entity_index",
    split="curated",
)

matches = entities.filter(lambda row: row["qid"] == "Q312")
print(matches[:])

Its fields are:

Field	Meaning
label	Original graph-node label
qid	Wikidata QID
forward_object_in_degree	Forward facts pointing to this node
qid_node_count	Number of graph-node records sharing this QID

The curated view requires a standard QID and a readable label. It excludes unresolved and numeric-only labels. It is therefore useful for browsing but must not be treated as the complete node set or as a quality-certified subset.

Download the canonical connected graph

Download everything with the Hugging Face CLI

python -m pip install huggingface_hub

hf download factprop/FACTPROP \
  --repo-type dataset \
  --local-dir FACTPROP-data

This downloads the complete release, including:

FACTPROP-data/
├── factprop_graph_v1.pkl
├── LICENSE_DATA
├── THIRD_PARTY_NOTICES.md
├── data/
│   ├── knowledge_edges.parquet
│   ├── entities_curated.parquet
│   ├── entities_curated.jsonl
│   └── entities.jsonl
├── metadata/
├── GRAPH.md
├── load_graph.py
└── SHA256SUMS

Download everything with Python

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="factprop/FACTPROP",
    repo_type="dataset",
    local_dir="FACTPROP-data",
)

Download and verify only the graph checkpoint

python -m pip install networkx huggingface_hub
python load_graph.py

The included loader downloads factprop_graph_v1.pkl, verifies SHA-256, and returns payload["graph"].

Python pickle loading can execute code. Load only the checkpoint from this trusted repository and verify:

437a434260edbb019c85575d65b4775cb2461f145e17966ee3acc8e4625ce7c8

See GRAPH.md for the complete checkpoint schema.

Canonical checkpoint contents

factprop_graph_v1.pkl contains a dictionary:

payload
├── graph              # NetworkX DiGraph
├── state
├── seed_entities
├── validator_state
└── scheduler_stats

The graph has 100,015 nodes and 432,562 stored directed edges. Edge attributes include:

relation, question, surface, evidence, confidence, group, is_inverse

Use is_inverse is not True when selecting original forward facts or reproducing FACTPROP popularity. Counting total NetworkX in-degree without this filter mixes forward facts with auxiliary traversal edges.

BCE dates and numeric labels

The canonical graph stores BCE year literals as negative internal labels:

Ancient Egypt --FoundingDate--> -3100

The edge surface expresses the readable meaning: approximately 3100 BCE. These values are date literals, not negative row IDs, negative connectivity, or corrupted entity indices.

To avoid two nearly identical target columns, knowledge_edges retains only the canonical object_node_label, such as -3100, and marks it as object_type="date_literal". Use the surface field when a human-readable BCE expression is needed.

Recommended uses

FACTPROP is suitable for:

• Knowledge updating and collateral-error propagation studies.
• Knowledge-graph topology and degree-distribution analysis.
• Entity connectivity and structural popularity research.
• Graph-aware retrieval and RAG experiments.
• Relation-conditioned factual QA dataset construction.
• Knowledge-editing neighborhood and multi-hop evaluation design.
• Robustness, forgetting, and rehearsal-strategy research.

The graph can serve as an empirical, real-world-derived factual network. It should not be described as a complete or statistically unbiased distribution of world knowledge.

Evaluation and split guidance

This release intentionally does not impose train, validation, or test splits. Appropriate splitting depends on the task.

For predictive experiments:

• Avoid random edge splits when the same entities on both sides would create leakage.
• Consider entity-disjoint, relation-aware, temporal, or connected-component splits.
• Keep knowledge-update targets separate from ripple evaluation facts.
• Record whether auxiliary inverse edges are included.
• Record how literals, missing QIDs, and duplicate QIDs are handled.
• Pin the dataset revision and publish generated split IDs.

Coverage, quality, and limitations

• The graph uses LLM-generated, Wikipedia-oriented factual candidates and Wikidata validation; it is not an exhaustive model of world knowledge.
• Construction choices—including seed entities, relation inventory, expansion policy, and validation coverage—shape the observed distribution.
• A stored edge should not be treated as permanently or universally correct. Facts can be time-sensitive, approximate, disputed, or affected by source limitations.
• confidence is a construction-time field, not a calibrated probability or human annotation score.
• 33,901 graph-node records have no QID mapping.
• 5,037 QIDs occur in more than one graph-node record.
• Missing QIDs do not imply missing nodes, low connectivity, or degree zero.
• Duplicate-QID nodes must be reviewed separately. Do not automatically sum their degrees or choose the maximum.
• Some expected mappings, including the Java and Python programming languages, are absent from the current mapping.
• The curated entity split is a display filter, not a gold quality label.
• Experiment inputs, model checkpoints, and complete paper outputs are not included.

These limitations are part of the released graph version. Mapping corrections should be maintained as separately reviewed records rather than silently replacing original nodes.

Reproducibility checklist

For a reproducible use of FACTPROP, record:

• Hub revision or commit ID.
• Checksum of each downloaded artifact.
• Whether knowledge_edges or the canonical checkpoint was used.
• Whether inverse edges were included.
• Directed or undirected traversal convention.
• QID deduplication policy.
• Literal/date normalization policy.
• Entity, relation, and graph-component split policy.
• Any filtering or mapping corrections.

Run checksum verification from the downloaded repository:

shasum -a 256 -c SHA256SUMS

On Linux, use:

sha256sum -c SHA256SUMS

File inventory

File	Purpose
factprop_graph_v1.pkl	Canonical connected NetworkX graph
LICENSE_DATA	Dataset license notice and attribution requirements
THIRD_PARTY_NOTICES.md	Upstream provenance and source-specific terms
data/knowledge_edges.parquet	All forward knowledge connections for safe, efficient analysis
data/entities_curated.parquet	Viewer-ready mapped entity summary
data/entities_curated.jsonl	Equivalent JSONL curated summary
data/entities.jsonl	Complete original-order entity index
browser-index.json	Index used by the FACTPROP website
GRAPH.md	Canonical checkpoint schema
load_graph.py	Checksum-verifying checkpoint loader
metadata/graph.json	Graph counts, thresholds, export date, and source checksum
metadata/release.json	Release and mapping statistics
SHA256SUMS	Artifact integrity checksums

Provenance and versioning

The released construction code uses gpt-4o-mini to generate candidate triplets and natural-language fields, then validates supported relations through Wikidata API and SPARQL queries. Project materials describe these candidates as Wikipedia-derived; the released builder does not directly ingest Wikipedia article text. The entity popularity index was exported from the unchanged paper graph, and its source checksum is retained in metadata/graph.json.

knowledge_edges contains every forward edge from the checkpoint and uses the canonical target label in object_node_label. Topology and connectivity metrics are derived directly from the canonical graph. No graph nodes, mappings, edge topology, or checkpoint metadata were changed for this release.

Use a Hub revision to freeze data. Proposed mapping corrections or enhanced versions should use a new versioned artifact rather than overwrite factprop_graph_v1.pkl.

License

FACTPROP is licensed under the Creative Commons Attribution 4.0 International License, subject to third-party rights and source-specific terms.

The license covers the FACTPROP authors' original graph compilation, generated natural-language metadata, derived tables, documentation, and applicable database rights. It does not relicense Wikidata content, third-party materials, names, trademarks, personality rights, or facts that are not protected by copyright.

When redistributing or adapting the dataset:

1. Credit the FACTPROP authors.
2. Cite the work below and link to this dataset repository.
3. Link to CC BY 4.0.
4. Indicate whether changes were made.

See LICENSE_DATA for the license notice and THIRD_PARTY_NOTICES.md for Wikidata, Wikipedia, and model-output provenance.

Citation

Until a public paper identifier is available, cite the dataset as:

@dataset{zhang2026factprop,
  title     = {FACTPROP: A Connected Factual Knowledge Graph},
  author    = {Yuji Zhang and Weibing Wang and Cheng Qian and Duo Zhou and
               Dilek Hakkani-Tür and Kathleen McKeown and Chengxiang Zhai and
               Heng Ji},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/factprop/FACTPROP},
  note      = {Dataset for ``Popular Knowledge Propagates More Errors in LLM
               Knowledge Updating''}
}