README.md

---
license: other
license_name: icj-mixed-per-layer
license_link: LICENSE
language:
  - en
tags:
  - legal
  - international-law
  - icj
  - citation-graph
  - knowledge-graph
  - embeddings
pretty_name: ICJ Citation Graph
size_categories:
  - 1M<n<10M
configs:
  - config_name: chunks
    default: true
    data_files: parquet/chunks-*.parquet
  - config_name: documents
    data_files: parquet/documents.parquet
  - config_name: cases
    data_files: parquet/cases.parquet
  - config_name: provisions
    data_files: parquet/provisions.parquet
---

# ICJ Citation Graph

The International Court of Justice's public record as a graph: 199 of the Court's 200 cases, from Corfu Channel in 1947 to 2026, in three layers.

- Decisions (2,407): judgments, orders, and advisory opinions, plus the separate and dissenting opinions the judges append.
- Written pleadings (2,114): the memorials, counter-memorials, applications, and declarations of intervention the parties filed, in 194 of the cases.
- Oral records (1,875): verbatim hearing transcripts, in 163.

6,396 documents in all, parsed into structured text and split into about 1.1 million searchable passages. Every passage carries a `Qwen3-Embedding-8B` vector (open-weight, 4096-dim, unit-normalized) for semantic search. The decision layer also has the full citation graph: each decision linked to its case, the earlier cases it cites, the provisions it invokes, and the judges who sat.

## Which form to grab

| Form | Files | Layers | Needs |
|---|---|---|---|
| Graph, decisions | `dumps/icj-decisions.dump` (4.2 GB) | decisions | Neo4j 5.26 |
| Graph, full | `dumps/icj-full.dump` (13.7 GB) | all three | Neo4j 5.26 |
| Portable, decisions | `dataset/` (JSONL + npy, 1.0 GB) | decisions | numpy for vectors |
| Portable, all layers | `dataset_layered/` | all three, filter by `layer` | numpy for vectors |
| Columnar, all layers | `parquet/` (8.3 GB) | all three, vectors inline | anything that reads Parquet |

Embeddings ship in every form: node properties in the dumps, one `embeddings_<layer>.npy` per layer in the portable sets, an `embedding` column in Parquet. Nothing needs re-embedding. Embed your queries with the same model or the scores are meaningless.

## Quick start

```python
from datasets import load_dataset
docs   = load_dataset("Madeleinex/chicken-graph", "documents", split="train")
chunks = load_dataset("Madeleinex/chicken-graph", "chunks", split="train")
```

Parquet is the format this page's viewer and SQL console read natively, and the one form where the vectors are a real column rather than a sidecar:

```python
import duckdb
duckdb.sql("""
  SELECT case_id, title, para, text
  FROM 'parquet/chunks-*.parquet' c JOIN 'parquet/documents.parquet' d
    ON c.document_id = d.id
  WHERE c.layer = 'pleadings' AND text ILIKE '%provisional measures%'
  LIMIT 10
""")
```

`case_id` is a zero-padded string (`"001"`). Parquet preserves that; a JSONL reader that infers types will turn it into an integer and drop the padding, so pass `dtype={"case_id": "string"}`.

A runnable walkthrough (load, join, reconstruct a document, semantic search) is in [`notebooks/dataset_demo.ipynb`](notebooks/dataset_demo.ipynb).

## Portable files

`dataset/` holds the decision layer; `dataset_layered/` holds all three with a `layer` field (`decision` / `pleadings` / `oral`) on every `documents.jsonl` and `chunks.jsonl` row. Filter to any subset in one line:

```python
import pandas as pd
docs = pd.read_json("dataset_layered/documents.jsonl", lines=True, dtype={"case_id": "string"})
pleadings = docs[docs.layer == "pleadings"]   # 2,114 filings; oral -> 1,875
```

### `cases.jsonl` (199 rows)

```json
{"case_id": "070", "name": "Military and Paramilitary Activities in and against Nicaragua (Nicaragua v. United States of America)", "year_start": 1984, "year_end": 1991, "icj_documents": {"decision": 8, "pleadings": 8, "oral": 3, "other": 4}}
```

A null `year_end` means the case is still pending (22 rows, exactly the ICJ's official pending list). `icj_documents` is a coverage snapshot of how many documents of each kind the ICJ site publishes for the case, scraped 2026-07-14; it describes what exists upstream, not what is in this release.

### `provisions.jsonl` (356 rows)

```json
{"key": "statute:article_36", "title": "Article 36", "level": "article", "instrument": "statute", "text": "1. The jurisdiction of the Court comprises all cases ..."}
```

`text` is the full article body, present on 346 of 356 (empty on chapter containers and a few keys pointing outside the four parsed instruments: UN Charter, ICJ Statute, Rules of Court, Practice Directions).

### `documents.jsonl` (2,407 decision rows; 6,396 in `dataset_layered/`)

```json
{
  "id": "ICJ_011_USNationalsMorocco_FRA_USA_1952-08-27_JUD_01_ME_00_EN",
  "case_id": "011",
  "title": "RIGHTS OF NATIONALS OF THE UNITED STATES OF AMERICA IN MOROCCO (FRANCE v. UNITED STATES OF AMERICA)",
  "document_type": "judgment", "lang": "EN", "issued_date": "1952-08-27",
  "applicant": "FRANCE", "respondent": "UNITED STATES OF AMERICA", "stage": "merits",
  "cited_cases": ["007", "008"],
  "cited_provisions": ["statute:article_38", "statute:article_40"]
}
```

`id`, `case_id`, `title`, `document_type`, `lang`, `filename`, `cited_cases`, `cited_provisions` are on every row. The rest appear when the document states them: `issued_date` on 1,429, `applicant`/`respondent` on 574/572 (raw header strings, often ALLCAPS; normalized country identities live in the graph's Country nodes). `cited_cases` and `cited_provisions` are the citation edges, so the whole graph is reconstructable from these files alone.

### `chunks.jsonl` + `embeddings_<layer>.npy`

```json
{"id": "166-20240131-jud-01-00-en:0", "document_id": "166-20240131-jud-01-00-en", "seq": 0, "para": null, "zone": "title", "text": "..."}
```

Chunks are cut on the unit each document uses: a pleading breaks at the paragraph number counsel gave it, a hearing at each speaker's turn (that label is in `para`; oral chunks are marked `zone: "turn"`). Legacy scans with no detectable structure (about 24% of pleadings chunks, 17% of oral) fall back to a fixed window with `para` empty.

Each `.npy` is a `float16` matrix, L2-normalized (so cosine similarity is a dot product). Row `i` is the `i`-th chunk of that layer in file order; the decision slice is byte-compatible with `dataset/embeddings.npy`.

```python
import json, numpy as np
emb = np.load("dataset/embeddings.npy", mmap_mode="r")   # (121438, 4096) float16
chunks = [json.loads(l) for l in open("dataset/chunks.jsonl")]
scores = emb.astype(np.float32) @ query_vector           # query embedded with Qwen3-Embedding-8B
```

## Ready-made graph (`dumps/`)

Two dumps: `icj-decisions.dump` (decisions) and `icj-full.dump` (all three layers). Both carry the `chunk_text` full-text index (all layers) and `case_name_embedding` vector index. `icj-decisions.dump` also ships its `chunk_embedding` vector index ready; `icj-full.dump` holds every chunk's vector as a property but leaves that index for you to `CREATE` on restore, since an HNSW over a million 4096-d vectors needs more memory than most machines have (or use the `.npy` with FAISS).

```bash
# load into a fresh volume (neo4j-admin loads <db>.dump, so name it neo4j.dump first)
cp dumps/icj-full.dump neo4j.dump        # or icj-decisions.dump for decisions only
docker run --rm -v icj_data:/data -v "$PWD":/backups:ro neo4j:5.26 \
  neo4j-admin database load neo4j --from-path=/backups --overwrite-destination=true

docker run -d --name icj-neo4j -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/choose-a-password -e NEO4J_server_memory_pagecache_size=2G \
  -v icj_data:/data neo4j:5.26

docker exec icj-neo4j cypher-shell -u neo4j -p choose-a-password \
  "MATCH (c:Case) RETURN count(c);"   # 200 for icj-full (199 + stub case 201), 199 for icj-decisions
```

```cypher
CALL db.index.vector.queryNodes('chunk_embedding', 10, $queryVector)   // query embedded with Qwen3-Embedding-8B
YIELD node, score RETURN node.id, node.text, score
```

Node counts for the decision graph (`icj-decisions.dump`):

| Node | Count | Key relationships |
|---|---|---|
| Case | 199 | Document -IN_CASE-> Case |
| Document | 2,407 | Document -CITES_CASE-> Case (6,070 edges) |
| Chunk | 121,438 | Chunk -PART_OF-> Document; `embedding` property, vector-indexed |
| Provision | 356 | Document -CITES-> Provision (7,699 edges); Provision -PART_OF-> Instrument |
| Instrument | 4 | UN Charter, ICJ Statute, Rules of Court, Practice Directions |
| Judge | 220 | Document -SAT_ON-> Judge |
| Country | 112 | Document -APPLICANT / -RESPONDENT-> Country |

`icj-full.dump` adds the pleadings and oral layers: Case 200, Document 6,396, Chunk 1,095,572. Citation edges are extracted from the decision layer only, so those counts match in both dumps. Citations were resolved to the right case by name and year, so same-named cases from different eras never cross-link.

The ten most-cited cases, over 6,070 case-to-case edges:

| Case | Name | Cited |
|---|---|---|
| 070 | Military and Paramilitary Activities (Nicaragua v. USA) | 292 |
| 091 | Application of the Genocide Convention (Bosnia v. Serbia) | 206 |
| 001 | Corfu Channel (UK v. Albania) | 162 |
| 008 | Interpretation of Peace Treaties | 149 |
| 064 | US Diplomatic and Consular Staff in Tehran | 138 |
| 104 | LaGrand (Germany v. USA) | 128 |
| 048 | Northern Cameroons | 127 |
| 016 | Anglo-Iranian Oil Co. | 115 |
| 050 | Barcelona Traction | 111 |
| 095 | Legality of the Threat or Use of Nuclear Weapons | 110 |

## Provenance and license

- Historical decisions (1947 to Oct 2023): the CD-ICJ corpus by Sean Fobbe ([Zenodo, DOI 10.5281/zenodo.3826444](https://doi.org/10.5281/zenodo.3826444)), CC0 1.0, 2,285 documents.
- Recent decisions (Oct 2023 to 2026) and all pleadings and oral records: retrieved from [icj-cij.org](https://www.icj-cij.org).
- Case 2 (1947) is absent; its ICJ page has returned a server error for years.

Terms are per layer, not one blanket license. Read [`LICENSE`](LICENSE) before reuse; in short:

| What | Terms |
|---|---|
| Decisions from CD-ICJ | CC0-1.0, passed through from upstream |
| Material retrieved from icj-cij.org (recent decisions, pleadings, oral) | No licence granted, since we hold none. Usage request: attribute the ICJ and this dataset, non-commercial, per the ICJ notice |
| The parsing, chunking, embeddings, graph, and tooling this project added | CC-BY-4.0 |

We claim no ownership of the underlying ICJ documents. The pleadings position is what we apply pending contact with the ICJ Registry, not a claim the material is licensed. Rights-holder requests will be honored.

## Limitations

- `is_ocr` marks 119 wholly OCR-derived documents; `ocr_page_count` flags 464 more with isolated pages replaced. OCR coverage on damaged-but-inked pages is imperfect: some dense pages are transcribed incompletely.
- 51 documents are `document_type: "unknown"` (scans too degraded to classify); their text is still searchable.
- `applicant`/`respondent` in `documents.jsonl` are raw header strings; the graph's Country nodes are deduplicated and split into individual states. 52 Judge nodes carry a comma (a role suffix, or a jointly-signed opinion parsed as one name); neither affects the citation network.
- `source_url` is an internal provenance path, not a public link.

If you downloaded before 2026-07-29, re-download: an OCR pass had invented text on 942 blank pages across 37 pleadings files (now removed, decision layer and its citations were never affected), and `is_ocr` was corrected on 13 documents.

## How it was built

Each PDF is rendered and read by an OCR model; a second pass classifies every line's role (title, paragraph, operative ruling, bench, signatures); a third extracts every citation of an earlier case and resolves it to a case id by name and year. Documents, passages, embeddings, and citation edges are written to Neo4j in one idempotent step.