Improve connected graph usability documentation

Co-authored-by: Cursor <cursoragent@cursor.com>

README.md

@@ -1,5 +1,5 @@
 ---
-pretty_name: FACTPROP — Factual Graph and Entity Index
+pretty_name: FACTPROP — Connected Factual Knowledge Graph
 language:
   - en
 size_categories:
@@ -7,8 +7,11 @@ size_categories:
 tags:
   - knowledge-graph
   - knowledge-updating
+  - graph-analysis
+  - factual-knowledge
+  - question-answering
+  - retrieval
   - factprop
-  - tabular
 configs:
   - config_name: knowledge_graph
     default: true
@@ -25,112 +28,340 @@ configs:
 
 **Popular Knowledge Propagates More Errors in LLM Knowledge Updating**
 
-[Project page & demo](https://factprop.github.io/FACTPROP/) · [Research code](https://github.com/factprop/FACTPROP)
+[Project page & demo](https://factprop.github.io/FACTPROP/) · [Research code](https://github.com/factprop/FACTPROP) · [Graph schema](GRAPH.md)
 
-## Overview
+## What is FACTPROP?
 
-FACTPROP is a factual graph for studying how knowledge updates affect connected facts in large language models. This release includes the original `factprop_graph_v1.pkl` graph checkpoint, a browsable table of 357,205 forward knowledge edges, and the **entity popularity index** used by the project’s browser explorer.
+FACTPROP is a connected factual knowledge graph for studying how knowledge is structured and how factual updates propagate through large language models. It was constructed from Wikipedia-derived factual candidates with Wikidata validation.
 
-The dataset viewer opens on `knowledge_edges`, where every row shows a `subject → relation → object` connection. The `curated` split provides a compact entity-level view sorted by structural popularity. Download `factprop_graph_v1.pkl` to obtain the complete NetworkX graph, including forward facts, auxiliary inverse traversal edges, questions, surface statements, evidence, confidence, and construction metadata.
+The release provides two ways to use the same graph:
 
-## Contents
+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.
 
-| File | Description |
-| --- | --- |
-| `factprop_graph_v1.pkl` | Original graph checkpoint (125,274,720 bytes), unchanged |
-| `GRAPH.md` | Checkpoint structure and graph loading guide |
-| `load_graph.py` | Download, verify, and load the graph |
-| `data/knowledge_edges.parquet` | Derived table of all forward `subject → relation → object` knowledge connections |
-| `data/entities_curated.parquet` | Viewer-ready entity summary: mapped, readable labels sorted by structural popularity |
-| `data/entities_curated.jsonl` | Equivalent JSONL representation of the curated entity summary |
-| `data/entities.jsonl` | One unchanged record per graph node, including numeric and unresolved labels |
-| `browser-index.json` | Unchanged index used by the project website |
-| `metadata/graph.json` | Graph counts, thresholds, export date, and source-graph checksum |
-| `metadata/release.json` | Source version and mapping statistics |
-| `SHA256SUMS` | File integrity checksums |
+The default Dataset Viewer shows each knowledge connection as:
 
-The `knowledge_edges` split contains all 357,205 forward edges from the checkpoint and excludes the 75,357 generated inverse traversal edges. It is sorted by descending object in-degree so highly connected knowledge is easy to inspect. Internal negative year literals are rendered as readable BCE dates—for example, `-3100` becomes `3100 BCE`—without changing the checkpoint.
+```text
+subject ── relation ──▶ object
+```
 
-The `curated` split contains records whose labels include at least one letter, do not begin with a negative numeric value, and whose QIDs match the standard `Q<number>` form. It is sorted by descending `forward_object_in_degree`. Records and scores are copied without modification, QID duplicates are not merged, and the split is intended only to improve browsing.
+For example, an edge can also carry a natural-language question, a surface statement, construction-time confidence, and connectivity statistics.
 
-The downloadable `data/entities.jsonl` file remains the complete 100,015-record entity index in its original order. The `curated` split is not a training or test split.
+## At a glance
 
-## Knowledge-edge fields
+- **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
 
-| Field | Meaning |
-| --- | --- |
-| `edge_id` | Sequential row identifier starting at zero; not a graph-node identifier |
-| `subject`, `relation`, `object` | Human-readable forward knowledge connection |
-| `subject_qid`, `object_qid` | Wikidata QIDs where available; literals have no QID |
-| `object_type` | `entity`, `literal`, or `date_literal` |
-| `question` | Natural-language question associated with the edge |
-| `surface` | Natural-language statement expressing the connection |
-| `group` | Construction category such as Person, Work, or Event |
-| `confidence` | Construction-time confidence value where available |
-| `subject_forward_out_degree` | Number of forward facts originating at the subject |
-| `object_forward_in_degree` | Number of forward facts pointing to the object; FACTPROP structural popularity |
+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, raw BCE labels, stored evidence, or construction metadata, download `factprop_graph_v1.pkl`.
 
-The Parquet table is a complete row-wise view of the forward graph topology and selected edge metadata, with BCE literals normalized for display. Use the checkpoint as the canonical source when exact raw labels, inverse edges, stored evidence, or construction state are required.
+## Data model
 
-## Entity-index fields
+### 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:
+
+```text
+(subject, relation, object)
+```
+
+The Parquet representation includes:
 
 | Field | Type | Meaning |
 | --- | --- | --- |
-| `label` | string | Original graph-node label |
-| `qid` | string or null | Wikidata QID where mapped |
-| `forward_object_in_degree` | integer | Number of forward factual edges pointing to this node |
-| `qid_node_count` | integer | Number of index records sharing this non-null QID; zero when QID is missing |
+| `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` | string | Target node label or readable literal |
+| `object_node_label` | string | Canonical checkpoint node label; use this field to reconstruct exact topology |
+| `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. For ordinary entities, `object` and `object_node_label` are identical. BCE literals use a readable `object` value while preserving the original negative checkpoint label in `object_node_label`.
+
+### Auxiliary inverse edges
 
-Graph-node labels, rather than QIDs, distinguish records. The added `qid_node_count` field describes mapping multiplicity; it does not alter the original scores.
+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
+### Structural popularity
 
-For an entity `o`, popularity counts incoming factual edges whose `is_inverse` attribute is not `true`. The index represents 357,205 forward edges; the original graph also stores 75,357 inverse edges, for 432,562 stored edges in total.
+FACTPROP defines structural popularity for an object node `o` as:
 
-This score measures connectivity in this graph version. It does not measure search traffic or public familiarity, and it does not predict a model’s error rate for a particular input.
+```text
+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**
 
-For example, `Apple Inc.` / `Q312` has degree **467**, while `Apple` / `Q89` has degree **4**.
+These are separate graph nodes.
 
-## Load the graph
+## Quick start: load every forward knowledge connection
 
-See [GRAPH.md](GRAPH.md) for the checkpoint schema. After installing `networkx` and `huggingface_hub`, run:
+Install the tabular dependencies:
 
 ```bash
-python load_graph.py
+python -m pip install datasets pyarrow
 ```
 
-The loader verifies the original file checksum before loading it. Only load pickle files from a trusted source.
-
-## Load the index
+Load the complete forward graph table:
 
 ```python
 from datasets import load_dataset
 
-edges = load_dataset("factprop/FACTPROP", "knowledge_graph", split="knowledge_edges")
-curated = load_dataset("factprop/FACTPROP", "entity_index", split="curated")
-matches = curated.filter(lambda row: row["qid"] == "Q312")
-print(matches[:])
+edges = load_dataset(
+    "factprop/FACTPROP",
+    "knowledge_graph",
+    split="knowledge_edges",
+)
+
+print(edges.num_rows)       # 357205
+print(edges.column_names)
 ```
 
-Each edge row can be interpreted directly:
+Inspect one connection:
 
 ```python
 row = edges[0]
-print(row["subject"], "--", row["relation"], "-->", row["object"])
+print(f'{row["subject"]} --{row["relation"]}--> {row["object"]}')
+print("Question:", row["question"])
+print("Statement:", row["surface"])
 print("Object connectivity:", row["object_forward_in_degree"])
 ```
 
-## Download the complete connected graph
+Pin the data revision for a reproducible experiment:
 
-To download the entire dataset repository, including the original graph checkpoint:
+```python
+edges = load_dataset(
+    "factprop/FACTPROP",
+    "knowledge_graph",
+    split="knowledge_edges",
+    revision="<commit-id>",
+)
+```
+
+## Common recipes
+
+### Find all displayed facts involving an entity
+
+```python
+entity = "Apple Inc."
+
+connected = edges.filter(
+    lambda row: row["subject"] == entity or row["object"] == entity
+)
+
+print(connected.select_columns(["subject", "relation", "object"])[:20])
+```
+
+For incoming facts only:
+
+```python
+incoming = edges.filter(lambda row: row["object"] == entity)
+print("Incoming forward facts:", incoming.num_rows)
+```
+
+### Filter by relation or knowledge category
+
+```python
+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
+
+```python
+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
 
 ```bash
+python -m pip install datasets networkx
+```
+
+```python
+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
+
+```python
+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
+
+```python
+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:
+
+```python
+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:
+
+```python
+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
+
+```bash
+python -m pip install huggingface_hub
+
 hf download factprop/FACTPROP \
   --repo-type dataset \
   --local-dir FACTPROP-data
 ```
 
-Or use Python:
+This downloads the complete release, including:
+
+```text
+FACTPROP-data/
+├── factprop_graph_v1.pkl
+├── data/
+│   ├── knowledge_edges.parquet
+│   ├── entities_curated.parquet
+│   ├── entities_curated.jsonl
+│   └── entities.jsonl
+├── metadata/
+├── GRAPH.md
+├── load_graph.py
+└── SHA256SUMS
+```
+
+### Download everything with Python
 
 ```python
 from huggingface_hub import snapshot_download
@@ -142,39 +373,152 @@ snapshot_download(
 )
 ```
 
-Downloading only a split through `load_dataset` retrieves its viewer table, not the full checkpoint. `FACTPROP-data/factprop_graph_v1.pkl` is the complete connected knowledge graph. Load only this trusted pickle after verifying its published SHA-256 checksum.
+### Download and verify only the graph checkpoint
 
-To retrieve the browser-format file:
+```bash
+python -m pip install networkx huggingface_hub
+python load_graph.py
+```
 
-```python
-import json
-from huggingface_hub import hf_hub_download
+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:
 
-path = hf_hub_download("factprop/FACTPROP", "browser-index.json", repo_type="dataset")
-with open(path, encoding="utf-8") as stream:
-    index = json.load(stream)
+```text
+437a434260edbb019c85575d65b4775cb2461f145e17966ee3acc8e4625ce7c8
 ```
 
-## Mapping coverage and limitations
+See [GRAPH.md](GRAPH.md) for the complete checkpoint schema.
 
+## Canonical checkpoint contents
+
+`factprop_graph_v1.pkl` contains a dictionary:
+
+```text
+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:
+
+```text
+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:
+
+```text
+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.
+
+For usability, `knowledge_edges` renders such objects as `3100 BCE` and marks them as `object_type="date_literal"`. The same row preserves `-3100` in `object_node_label`, allowing exact topology reconstruction. The canonical checkpoint and complete raw entity index also retain the original labels.
+
+## 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 is derived from 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 correspond to more than one graph-node record.
-- Some expected mappings, including the Java and Python programming languages, are absent.
-- A missing mapping does not imply low popularity or a score of zero. A known graph node may independently have a true degree of zero.
-- Multiple nodes with one QID must be reviewed separately. Do not automatically sum their degrees or take the maximum.
-- Numeric labels can represent literal values such as dates or identifiers. Negative numeric labels in this graph are BCE date literals, not negative row indices or negative popularity scores.
-- The `curated` split is a display filter, not a quality label. Use `data/entities.jsonl` and graph-edge context for research analysis.
-- The index supports node-level lookup; use `factprop_graph_v1.pkl` for graph traversal. The graph alone does not include every experiment input or output needed to reproduce all paper results.
+- 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:
+
+```bash
+shasum -a 256 -c SHA256SUMS
+```
+
+On Linux, use:
+
+```bash
+sha256sum -c SHA256SUMS
+```
+
+## File inventory
+
+| File | Purpose |
+| --- | --- |
+| `factprop_graph_v1.pkl` | Canonical connected NetworkX graph |
+| `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
 
-## Provenance and versions
+The graph was constructed from Wikipedia-derived factual candidates with Wikidata validation, as described by the FACTPROP project. The entity popularity index was exported from the unchanged paper graph. The source graph checksum is retained in `metadata/graph.json`.
 
-The files derive from the index already published in the [FACTPROP code repository](https://github.com/factprop/FACTPROP/tree/738ab3471f259340db6cacf404f1c0cf8063cfc3/website/data). That index was exported from the paper graph; its source checksum is retained in `metadata/graph.json`. The graph was constructed from Wikipedia-derived facts with Wikidata validation, as described in the paper.
+`knowledge_edges` contains every forward edge from the checkpoint. It changes only the user-facing display of negative BCE literals and preserves each canonical object label separately. 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.
 
-Entity labels, QIDs, and scores are preserved without remapping or aggregation. The `knowledge_edges` table changes only the display of negative year literals; topology and metrics are derived directly from the unchanged checkpoint. Proposed mapping corrections should be maintained separately from the original records.
+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
 
-A dataset-specific license has not yet been specified by the authors. This index release does not assign a new license to its upstream sources. No new license is assigned by this upload.
+A dataset-specific license has not yet been specified by the authors. This release does not assign a new license to its upstream sources. Review upstream source terms and obtain appropriate permission before redistribution or commercial use.
 
 ## Citation
 

SHA256SUMS

@@ -1,10 +1,10 @@
 8eebe4a8b875d1061c7b55947883b455fa1565fb6a6e39b8056c7160381d7cfc  GRAPH.md
-a5e9e8fdb6f9f146daa645a2c4c39b3efc04d01824f8051e9e2dcd1a292a2c80  README.md
+7b6739bdf987b260ee4355bd74c216d6c94d510fdd462a54a6735c8f7b9c96f0  README.md
 fa7d9aec01b9c98c09cebc941265e4351693b362ffb3048d2c86585e84d7800d  browser-index.json
 3a9211368ac52af6cd0647cb026c05cb62743804011b68624682e11df964c038  data/entities_curated.parquet
 010beb905ef89b491159a8d8b2b013ea55219d26c8545bed07f64010bfa9ffce  data/entities_curated.jsonl
 2c21f2aefb9cbcc749cd813412dd90fea440050eeb8efb3356de786ebeb501e6  data/entities.jsonl
-6fe12df06d87425f2c8a9d2c9e8fb805896190e3f40325b45be15f7d6e182b53  data/knowledge_edges.parquet
+58c0aadc93626731bac8ee26002e7b82fbc4919f0dc9ea6bf2b2c0b112c8d0a4  data/knowledge_edges.parquet
 437a434260edbb019c85575d65b4775cb2461f145e17966ee3acc8e4625ce7c8  factprop_graph_v1.pkl
 c73d0a4b3f6df2166ba960a64cd5d3522728f46c2597f4f6604cc65533b46888  load_graph.py
 29e825c9838eb795a18672eb6a569cc2b666cf6971b5bd911655113a138e94ad  metadata/graph.json

data/knowledge_edges.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6fe12df06d87425f2c8a9d2c9e8fb805896190e3f40325b45be15f7d6e182b53
-size 17291148
+oid sha256:58c0aadc93626731bac8ee26002e7b82fbc4919f0dc9ea6bf2b2c0b112c8d0a4
+size 18599971