rete-graph 0.3.2__tar.gz → 0.3.4__tar.gz

{rete_graph-0.3.2 → rete_graph-0.3.4}/Cargo.toml

@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "crates/rete-core",
+    "crates/rete-graph",
     "crates/rete-cli",
     "crates/rete-wasm",
     "crates/docgen",
@@ -14,10 +15,10 @@ members = [
 # release gates (--locked checks, feature matrix, coverage floors) stay
 # untouched by binding-only changes. Future clients (R, Go) follow the same
 # pattern — clients/ consumes crates/, never the other way around.
-exclude = ["fuzz", "clients/python", "clients/r/src/rust", "clients/java/ffi"]
+exclude = ["fuzz", "clients/python", "clients/r/src/rust", "clients/java/ffi", "clients/tauri/src-tauri"]
 
 [workspace.package]
-version = "0.3.2"
+version = "0.3.4"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/caviri/rete"
@@ -28,8 +29,25 @@ rust-version = "1.87"
 [workspace.dependencies]
 # RDF model + SPARQL, reused rather than reinvented (see docs/SPEC.md §2).
 # `rdf-star` enables quoted triples (`<< s p o >>`) in the parsers and SPARQL.
+# Oxigraph's own RFC 3987 IRI parser -- the crate its N-Triples reader
+# validates with. Already in this tree via `oxrdf`; named here so `rete-core`
+# can call it directly and decide validity the way the reference loader does.
+oxiri = "0.2"
 oxrdf = { version = "0.2", features = ["rdf-star"] }
 oxttl = { version = "0.1", features = ["rdf-star"] }
+# The RDF 1.2 Turtle/TriG reader, ALONGSIDE the 0.1 line above rather than
+# instead of it. The two are semver-incompatible, which is the whole reason they
+# coexist: 0.1 reads `<< s p o >>` as an RDF-star QUOTED TRIPLE, 0.2 reads the
+# same bytes as an RDF 1.2 REIFIER, and no single parser can mean both at once.
+# `--quoted-triple-syntax` says which one an input file means. Renamed because
+# one `[dependencies]` table cannot hold two entries called `oxttl`; it is the
+# same crate, two major lines, the way `oxrdf` 0.2 and 0.3 already sit in
+# Cargo.lock together.
+oxttl12 = { package = "oxttl", version = "0.2", features = ["rdf-12"] }
+# The RDF 1.2 term model the 0.2 parsers hand back. `oxttl` does not re-export
+# it, so naming it here is the only way to match on a `GraphName`; it adds no
+# code that `oxttl12` was not already pulling in.
+oxrdf12 = { package = "oxrdf", version = "0.3", features = ["rdf-12"] }
 oxrdfxml = "0.1"
 spargebra = { version = "0.3", features = ["rdf-star"] }
 serde_json = "1"

{rete_graph-0.3.2 → rete_graph-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rete-graph
-Version: 0.3.2
+Version: 0.3.4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -82,7 +82,7 @@ More:
 
 ```python
 g = rete.open("data/example.rete")            # local file, opened lazily too
-g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl")
+g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl"/"trig"/"rdfxml")
 g = rete.open(rete.build(rdflib_graph))       # or straight from an rdflib Graph/Dataset
 g = rete.open(url, headers={"Authorization": "Bearer ..."})   # authed hosts
 
@@ -128,6 +128,33 @@ reads at `batch_size=1`, versus 44 MB at the default 10 000), a large one
 speeds up a full walk. Scope with `graph=`: `rete.DEFAULT_GRAPH` for the
 unnamed default graph alone, or an IRI for one named graph.
 
+### RDF 1.2 and quoted triples
+
+The same `--quoted-triple-syntax` vocabulary and defaults as the CLI, in both
+directions:
+
+```python
+# Reading: what Turtle/TriG `<< s p o >>` means. "rdf-star" (default) = a quoted
+# triple, as before; "rdf12" = RDF 1.2 (`<<( s p o )>>` triple terms, `<< … >>`
+# reifiers, `{| … |}` annotations). N-Triples/N-Quads/RDF-XML ignore it.
+g = rete.open(rete.build(ttl_text, "ttl", quoted_triple_syntax="rdf12"))
+rete.Builder().add_file("data.trig", quoted_triple_syntax="rdf12")
+
+# Writing: to_nquads spells a quoted triple as the RDF 1.2 triple term
+# `<<( s p o )>>` by default, which pyoxigraph / Oxigraph 0.5 and Jena 5 read;
+# "rdf-star" writes rete's stored `<<s p o>>`. RDF 1.2 has no subject-position
+# triple term, so such a statement raises ValueError under "rdf12".
+g.to_nquads("out.nq")                                    # rdf12
+g.to_nquads("out.nq", quoted_triple_syntax="rdf-star")
+
+# The card says whether a file holds any, from its header (so old files answer):
+g.card()["signals"]["quoted_triples"]
+# {"present": True, "export_surfaces": ["rdf12", "rdf-star"], "export_default": "rdf12"}
+```
+
+The Pyodide wheel has no RDF 1.2 Turtle/TriG reader and refuses
+`quoted_triple_syntax="rdf12"` for those formats by name.
+
 ### Prepare a `.rete` step by step
 
 The lazy `Builder` configures a build — sources, embedded Dataset Card,

{rete_graph-0.3.2/clients/python → rete_graph-0.3.4}/README.md

@@ -54,7 +54,7 @@ More:
 
 ```python
 g = rete.open("data/example.rete")            # local file, opened lazily too
-g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl")
+g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl"/"trig"/"rdfxml")
 g = rete.open(rete.build(rdflib_graph))       # or straight from an rdflib Graph/Dataset
 g = rete.open(url, headers={"Authorization": "Bearer ..."})   # authed hosts
 
@@ -100,6 +100,33 @@ reads at `batch_size=1`, versus 44 MB at the default 10 000), a large one
 speeds up a full walk. Scope with `graph=`: `rete.DEFAULT_GRAPH` for the
 unnamed default graph alone, or an IRI for one named graph.
 
+### RDF 1.2 and quoted triples
+
+The same `--quoted-triple-syntax` vocabulary and defaults as the CLI, in both
+directions:
+
+```python
+# Reading: what Turtle/TriG `<< s p o >>` means. "rdf-star" (default) = a quoted
+# triple, as before; "rdf12" = RDF 1.2 (`<<( s p o )>>` triple terms, `<< … >>`
+# reifiers, `{| … |}` annotations). N-Triples/N-Quads/RDF-XML ignore it.
+g = rete.open(rete.build(ttl_text, "ttl", quoted_triple_syntax="rdf12"))
+rete.Builder().add_file("data.trig", quoted_triple_syntax="rdf12")
+
+# Writing: to_nquads spells a quoted triple as the RDF 1.2 triple term
+# `<<( s p o )>>` by default, which pyoxigraph / Oxigraph 0.5 and Jena 5 read;
+# "rdf-star" writes rete's stored `<<s p o>>`. RDF 1.2 has no subject-position
+# triple term, so such a statement raises ValueError under "rdf12".
+g.to_nquads("out.nq")                                    # rdf12
+g.to_nquads("out.nq", quoted_triple_syntax="rdf-star")
+
+# The card says whether a file holds any, from its header (so old files answer):
+g.card()["signals"]["quoted_triples"]
+# {"present": True, "export_surfaces": ["rdf12", "rdf-star"], "export_default": "rdf12"}
+```
+
+The Pyodide wheel has no RDF 1.2 Turtle/TriG reader and refuses
+`quoted_triple_syntax="rdf12"` for those formats by name.
+
 ### Prepare a `.rete` step by step
 
 The lazy `Builder` configures a build — sources, embedded Dataset Card,

{rete_graph-0.3.2 → rete_graph-0.3.4}/clients/python/Cargo.lock

@@ -379,6 +379,18 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "oxrdf"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4be15186205eb60ddbdc2fb47cb25df472c7f399bbe119b68c0972b6b6dd46ea"
+dependencies = [
+ "oxilangtag",
+ "oxiri",
+ "rand",
+ "thiserror",
+]
+
 [[package]]
 name = "oxrdfxml"
 version = "0.1.7"
@@ -387,7 +399,7 @@ checksum = "d8d4bf9c5331127f01efbd1245d90fd75b7c546a97cb3e95461121ce1ad5b1c8"
 dependencies = [
  "oxilangtag",
  "oxiri",
- "oxrdf",
+ "oxrdf 0.2.4",
  "quick-xml",
  "thiserror",
 ]
@@ -401,7 +413,20 @@ dependencies = [
  "memchr",
  "oxilangtag",
  "oxiri",
- "oxrdf",
+ "oxrdf 0.2.4",
+ "thiserror",
+]
+
+[[package]]
+name = "oxttl"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1d0fe19fa62a6a102f85b052bbd86e3cdc3360cd6a338d01bab1a6743bf1d8e"
+dependencies = [
+ "memchr",
+ "oxilangtag",
+ "oxiri",
+ "oxrdf 0.3.4",
  "thiserror",
 ]
 
@@ -602,16 +627,20 @@ checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
 
 [[package]]
 name = "rete-core"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "blake3",
  "getrandom 0.2.17",
  "md-5",
- "oxrdf",
+ "oxiri",
+ "oxrdf 0.2.4",
+ "oxrdf 0.3.4",
  "oxrdfxml",
- "oxttl",
+ "oxttl 0.1.8",
+ "oxttl 0.2.4",
  "regex-lite",
  "ruzstd",
+ "serde",
  "serde_json",
  "sha1",
  "sha2",
@@ -622,7 +651,7 @@ dependencies = [
 
 [[package]]
 name = "rete-python"
-version = "0.3.2"
+version = "0.3.4"
 dependencies = [
  "pyo3",
  "rete-core",
@@ -701,6 +730,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
  "serde_core",
+ "serde_derive",
 ]
 
 [[package]]
@@ -778,7 +808,7 @@ checksum = "8907e262be4b4b363218f4688f5654d423a958aa4b8d7c7a7f898be591fa474e"
 dependencies = [
  "oxilangtag",
  "oxiri",
- "oxrdf",
+ "oxrdf 0.2.4",
  "peg",
  "rand",
  "thiserror",

{rete_graph-0.3.2 → rete_graph-0.3.4}/clients/python/Cargo.toml

@@ -6,7 +6,7 @@ name = "rete-python"
 # Kept in lockstep with pyproject.toml's [project] version, and with the engine's
 # major.minor, by scripts/sync_versions.py (--check runs in CI). __version__ comes
 # from here (CARGO_PKG_VERSION), the wheel metadata from pyproject.
-version = "0.3.2"
+version = "0.3.4"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/caviri/rete"

{rete_graph-0.3.2 → rete_graph-0.3.4/clients/python}/README.md

@@ -54,7 +54,7 @@ More:
 
 ```python
 g = rete.open("data/example.rete")            # local file, opened lazily too
-g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl")
+g = rete.open(rete.build(nt_text))            # build a graph in memory ("nt"/"nq"/"ttl"/"trig"/"rdfxml")
 g = rete.open(rete.build(rdflib_graph))       # or straight from an rdflib Graph/Dataset
 g = rete.open(url, headers={"Authorization": "Bearer ..."})   # authed hosts
 
@@ -100,6 +100,33 @@ reads at `batch_size=1`, versus 44 MB at the default 10 000), a large one
 speeds up a full walk. Scope with `graph=`: `rete.DEFAULT_GRAPH` for the
 unnamed default graph alone, or an IRI for one named graph.
 
+### RDF 1.2 and quoted triples
+
+The same `--quoted-triple-syntax` vocabulary and defaults as the CLI, in both
+directions:
+
+```python
+# Reading: what Turtle/TriG `<< s p o >>` means. "rdf-star" (default) = a quoted
+# triple, as before; "rdf12" = RDF 1.2 (`<<( s p o )>>` triple terms, `<< … >>`
+# reifiers, `{| … |}` annotations). N-Triples/N-Quads/RDF-XML ignore it.
+g = rete.open(rete.build(ttl_text, "ttl", quoted_triple_syntax="rdf12"))
+rete.Builder().add_file("data.trig", quoted_triple_syntax="rdf12")
+
+# Writing: to_nquads spells a quoted triple as the RDF 1.2 triple term
+# `<<( s p o )>>` by default, which pyoxigraph / Oxigraph 0.5 and Jena 5 read;
+# "rdf-star" writes rete's stored `<<s p o>>`. RDF 1.2 has no subject-position
+# triple term, so such a statement raises ValueError under "rdf12".
+g.to_nquads("out.nq")                                    # rdf12
+g.to_nquads("out.nq", quoted_triple_syntax="rdf-star")
+
+# The card says whether a file holds any, from its header (so old files answer):
+g.card()["signals"]["quoted_triples"]
+# {"present": True, "export_surfaces": ["rdf12", "rdf-star"], "export_default": "rdf12"}
+```
+
+The Pyodide wheel has no RDF 1.2 Turtle/TriG reader and refuses
+`quoted_triple_syntax="rdf12"` for those formats by name.
+
 ### Prepare a `.rete` step by step
 
 The lazy `Builder` configures a build — sources, embedded Dataset Card,

rete_graph-0.3.4/clients/python/examples/graph-data-science.ipynb

@@ -0,0 +1,270 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "intro",
+   "metadata": {},
+   "source": "# Graph Data Science on RDF — the full algorithm catalog on a single `.rete` file\n\nGraph data science — centrality, community detection, embeddings, link\nprediction, GNNs — usually assumes a graph database with an analytics add-on\nbolted to it. This notebook runs the whole workflow over an **RDF graph in one\nfile**, with no server anywhere:\n\n1. **Project** — a SPARQL query pulls an edge list out of a single 1 MB\n   **`.rete`** file on object storage, read lazily over HTTP range requests\n   (only the byte ranges the query touches are downloaded);\n2. **Compute** — NetworkX, NumPy and scikit-learn run the standard\n   graph-algorithm catalog on the projection;\n3. **Write back** — the results become new triples in a *derived* `.rete` file.\n\nIf you come from a property-graph stack, this project → compute → write-back\nloop is the same architecture as Neo4j's Graph Data Science library — the next\ncell maps its catalog item for item. If you come from NetworkX or igraph,\nsteps 2–3 are home turf and step 1 replaces your CSV loader.\n\n**Where to run it** — the same cells work in both:\n\n- **in the browser** — [JupyterLite](https://caviri.github.io/rete/jupyterlite/lab/index.html?path=graph-data-science.ipynb):\n  the kernel is [Pyodide](https://pyodide.org) (Python compiled to WebAssembly),\n  nothing to install, no account;\n- **on any Jupyter server** — [Colab](https://colab.research.google.com/github/caviri/rete/blob/main/clients/python/examples/graph-data-science.ipynb),\n  [Binder](https://mybinder.org/v2/gh/caviri/rete/main?labpath=clients%2Fpython%2Fexamples%2Fgraph-data-science.ipynb),\n  or your own `jupyter lab` (`rete-graph` ships plain abi3 wheels).\n\nTwo optional cells (§10–11) want `scikit-network` / `torch`: where those are\nmissing they **skip with a printed note** rather than fail — Pyodide has\nneither, Binder preinstalls `scikit-network`, Colab ships `torch`. Everything\nelse runs everywhere.\n\n**The dataset**: [Mark Lombardi Networks](https://lombardinetworks.net) — 51\n*Narrative Structures*, the network drawings in which Lombardi (1951–2000) mapped\nglobal-finance scandals (BCCI, Iran–Contra, Harken Energy, the Vatican bank…) by\nhand: **2,934 actors** and **4,205 arcs whose line style carries the relationship\ntype**. He computed centrality by eye; we get to check his work.\n\nRun the cells top to bottom (`Shift+Enter`). Dataset license: CC BY-NC-SA 4.0."
+  },
+  {
+   "cell_type": "markdown",
+   "id": "catalog-map",
+   "metadata": {},
+   "source": "## The algorithm catalog, translated\n\nThe first column is the standard graph-data-science catalog — the algorithm\nnames you will meet in any analytics library (readers arriving from Neo4j GDS\nwill recognise their catalog item for item); the second is what runs here.\n\n| Algorithm | Here | Runs |\n|---|---|---|\n| Graph projection | SPARQL SELECT → DataFrame → NetworkX / CSR | anywhere |\n| Filtered / subgraph projection | `FILTER` / `VALUES` in the projection query | anywhere |\n| **Projection by ontology** *(no property-graph equivalent)* | `reason=True`: OWL `subPropertyOf` hierarchy widens the edge set | anywhere |\n| Degree Centrality | pure SPARQL `GROUP BY` — no export needed | anywhere |\n| PageRank, Article Rank | `nx.pagerank` | anywhere |\n| Betweenness (sampled) | `nx.betweenness_centrality(k=…)` | anywhere |\n| Closeness / Harmonic / Eigenvector | `nx.closeness_centrality`, … | anywhere |\n| HITS | `nx.hits` | anywhere |\n| Articulation Points, Bridges | `nx.articulation_points`, `nx.bridges` | anywhere |\n| Louvain, Modularity | `nx.community.louvain_communities` | anywhere |\n| Leiden | `sknetwork`/`leidenalg` | + `sknetwork` |\n| Label Propagation | `nx.community.label_propagation_communities` | anywhere |\n| WCC / SCC | `nx.connected_components`, `nx.strongly_connected_components` | anywhere |\n| Triangle Count / Clustering Coefficient | `nx.triangles`, `nx.average_clustering` | anywhere |\n| K-Core Decomposition | `nx.core_number` | anywhere |\n| K-1 Coloring | `nx.greedy_color` | anywhere |\n| K-Means / HDBSCAN (on embeddings) | `sklearn.cluster` | anywhere |\n| Conductance | `nx.conductance` | anywhere |\n| Node Similarity (Jaccard/Overlap/Cosine) | set ops / `scipy.spatial.distance` | anywhere |\n| K-Nearest Neighbors | `sklearn.neighbors.NearestNeighbors` | anywhere |\n| Dijkstra / A* / Yen / Bellman-Ford | `nx.shortest_path`, `nx.astar_path`, `nx.shortest_simple_paths` | anywhere |\n| BFS / DFS / All-pairs shortest path | `nx.bfs_tree`, `nx.all_pairs_shortest_path_length` | anywhere |\n| Spanning trees / Steiner / Max-flow | `nx.minimum_spanning_tree`, `nx.approximation.steiner_tree`, `nx.maximum_flow` | anywhere |\n| Topological sort / DAG longest path | `nx.topological_sort`, `nx.dag_longest_path` | anywhere |\n| Random Walk | a few lines of NumPy | anywhere |\n| **FastRP** node embeddings | ~15 lines of NumPy (below) | anywhere |\n| Node2Vec | random walks + `gensim` | + `gensim` |\n| GraphSAGE / GNN embeddings | PyTorch Geometric | + `torch` |\n| Adamic-Adar / Common Neighbors / Pref. Attachment / Resource Allocation | `nx.adamic_adar_index`, … | anywhere |\n| Node classification / regression pipelines | `sklearn` pipelines (below) | anywhere |\n| Link prediction pipelines | `sklearn` on pair features | anywhere |\n| Training methods (LogReg / RF / MLP) | `sklearn.linear_model`, `.ensemble`, `.neural_network` | anywhere |\n| Write-back of computed properties | bake results into a **derived `.rete`** (below) | anywhere |\n| Bulk-synchronous iteration (Pregel-style) | Python loop over the CSR / native frameworks | anywhere |\n\n**Runs**: *anywhere* = pure NetworkX / NumPy / scikit-learn / SPARQL — every\nruntime this notebook targets, the in-browser Pyodide kernel included.\n*+ `package`* = needs a compiled wheel Pyodide doesn't ship; any regular\nJupyter kernel runs it after a `pip install` (Binder preinstalls\n`scikit-network`, Colab ships `torch`).\n\n**Scale honesty:** NetworkX — in any runtime — is comfortable to ~10⁵–10⁶\nedges. Past that, hand the *same CSR matrix* to\n[scikit-network](https://scikit-network.readthedocs.io) and the same edge list to\n[PyTorch Geometric](https://pytorch-geometric.readthedocs.io) (both demoed at the\nend). Because `.rete` reads are lazy, you only ever download what you project."
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "install",
+   "metadata": {},
+   "outputs": [],
+   "source": "%pip install rete-graph pandas networkx scipy scikit-learn matplotlib\n\nimport sys, numpy as np, pandas as pd, networkx as nx\nimport rete_graph as rete\nprint(f\"rete-graph {rete.__version__} · networkx {nx.__version__} · platform {sys.platform!r}\")"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "open",
+   "metadata": {},
+   "outputs": [],
+   "source": "g = rete.open(\"https://data.graphplaza.com/lombardi/lombardi.rete\")\ns = g.stats()\nprint(f\"{g.quads:,} triples reachable; opened after fetching only \"\n      f\"{s['bytes']:,} of {s['fileLength']:,} bytes in {s['requests']} range requests\")\nprint(g.card()[\"title\"], \"—\", g.card()[\"license\"])\n\nPREFIXES = \"\"\"\nPREFIX lomb: <https://w3id.org/rete/lombardi/>\nPREFIX lo:   <http://www.lombardinetworks.net/lombardi.owl#>\nPREFIX skos: <http://www.w3.org/2004/02/skos/core#>\nPREFIX schema: <https://schema.org/>\n\"\"\""
+  },
+  {
+   "cell_type": "markdown",
+   "id": "project-md",
+   "metadata": {},
+   "source": "## 1 · Graph projection — one SPARQL query\n\nThe projection step pulls node and relationship tables out of storage into an\nin-memory graph. In this graph every drawn arc is *reified*: an `Arc` resource\nwith `lomb:source`, `lomb:target`, `lomb:arcType` (the line style — influence,\nmoney, blocked deal…) and `lomb:inDrawing`. One SPARQL query is the whole\nprojection — **including the filters**, which in a graph-analytics library\nwould be relationship-type and node-label projection config: we drop\nchronology arrows (`YearArrow`, …) and Lombardi's year-mark pseudo-actors\n(`lo:Year`), keeping only substantive relationships:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "project",
+   "metadata": {},
+   "outputs": [],
+   "source": "edges = g.query_df(PREFIXES + \"\"\"\nSELECT ?src ?tgt ?type ?drawing WHERE {\n  ?arc lomb:source ?src ; lomb:target ?tgt ;\n       lomb:arcType ?type ; lomb:inDrawing ?drawing .\n  FILTER(?type NOT IN (lo:YearArrow, lo:YearLine, lo:Final, lo:SingleNearby))\n  FILTER(?src != ?tgt)\n  FILTER NOT EXISTS { ?src a lo:Year }   FILTER NOT EXISTS { ?tgt a lo:Year }\n  FILTER NOT EXISTS { ?src a lo:YearFinal } FILTER NOT EXISTS { ?tgt a lo:YearFinal }\n}\"\"\")\n\nnames = g.query_df(PREFIXES + \"\"\"\nSELECT ?actor ?label WHERE { ?actor skos:prefLabel ?label ; lomb:actorId ?id }\"\"\")\nlabel = dict(zip(names[\"actor\"], names[\"label\"]))\n\nprint(f\"projected {len(edges):,} typed edges over {len(names):,} labelled actors\")\nedges[\"type\"].map(lambda t: t.split(\"#\")[-1]).value_counts().to_frame(\"arcs\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "reason-md",
+   "metadata": {},
+   "source": "### Projection by ontology — something property graphs cannot do\n\nEvery arc predicate (`lomb:rel/financialTransaction`, `lomb:rel/influenceControl`, …)\nis declared `rdfs:subPropertyOf lomb:connectedTo` in the file's own OWL ontology.\nAsk for the *super*-property with OWL 2 QL reasoning on, and the ontology **is**\nthe projection config — no re-projection, no duplication:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "reason",
+   "metadata": {},
+   "outputs": [],
+   "source": "plain    = len(g.query(PREFIXES + \"SELECT ?s ?o WHERE { ?s lomb:connectedTo ?o }\"))\nentailed = len(g.query(PREFIXES + \"SELECT ?s ?o WHERE { ?s lomb:connectedTo ?o }\", reason=True))\nprint(f\"asserted connectedTo edges: {plain:,}\")\nprint(f\"with subPropertyOf entailment: {entailed:,}  ← every typed arc, one query\")"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "build-graph",
+   "metadata": {},
+   "outputs": [],
+   "source": "G = nx.Graph()          # undirected, weight = number of parallel arcs\nD = nx.DiGraph()        # directed (arcs have direction: who controls whom)\nfor s_, t_ in zip(edges[\"src\"], edges[\"tgt\"]):\n    G.add_edge(s_, t_, weight=G[s_][t_][\"weight\"] + 1 if G.has_edge(s_, t_) else 1)\n    D.add_edge(s_, t_)\nprint(f\"projected graph: {G.number_of_nodes():,} nodes · {G.number_of_edges():,} edges\")\n\ndef top(scores, n=10):\n    \"\"\"Top-n of a score dict, with human names.\"\"\"\n    return pd.DataFrame(\n        [(label.get(k, k), round(v, 5)) for k, v in\n         sorted(scores.items(), key=lambda kv: -kv[1])[:n]],\n        columns=[\"actor\", \"score\"])"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "degree-md",
+   "metadata": {},
+   "source": "## 2 · Centrality\n\n**Degree centrality never needs an export** — it is a SPARQL `GROUP BY`,\ncomputed inside the engine over the reified arcs:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "degree",
+   "metadata": {},
+   "outputs": [],
+   "source": "deg = g.query_df(PREFIXES + \"\"\"\nSELECT ?actor (COUNT(?arc) AS ?degree) WHERE {\n  { ?arc lomb:source ?actor } UNION { ?arc lomb:target ?actor }\n}\nGROUP BY ?actor ORDER BY DESC(?degree) LIMIT 10\"\"\")\ndeg[\"actor\"] = deg[\"actor\"].map(label)\ndeg"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "centrality-md",
+   "metadata": {},
+   "source": "For the rest of the centrality family we use the projection. Betweenness is\nsampled (`k=400` pivots), the standard trick on graphs this size — it is still\nthe slowest cell, give it ~a minute. Lombardi's drawings reward it: betweenness\nfinds the *brokers* his drawings are literally about — BCCI, the Zurich shell\nKapital Beratung, the Harvard endowment:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "centrality",
+   "metadata": {},
+   "outputs": [],
+   "source": "pagerank    = nx.pagerank(D, alpha=0.85)\nbetweenness = nx.betweenness_centrality(G, k=400, seed=1)     # sampled, k pivots\ncloseness   = nx.closeness_centrality(G)\neigenvector = nx.eigenvector_centrality(G, max_iter=500)\nhubs, auths = nx.hits(D)\n\nsummary = pd.DataFrame({\n    \"pagerank\":    top(pagerank)[\"actor\"].values,\n    \"betweenness\": top(betweenness)[\"actor\"].values,\n    \"closeness\":   top(closeness)[\"actor\"].values,\n    \"eigenvector\": top(eigenvector)[\"actor\"].values,\n    \"hits-hubs\":   top(hubs)[\"actor\"].values,\n}, index=range(1, 11))\nprint(f\"articulation points (single points of failure): {len(list(nx.articulation_points(G))):,}\")\nsummary"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "community-md",
+   "metadata": {},
+   "source": "## 3 · Community detection\n\nLombardi drew each scandal as one drawing. If community detection works, it\nshould **rediscover the scandals** from the merged 51-drawing graph — and it\ndoes: Louvain lands at modularity **0.91** (an extremely well-clustered graph)\nwith ~70 communities, and the big ones read like his catalogue raisonné:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "community",
+   "metadata": {},
+   "outputs": [],
+   "source": "wcc = list(nx.connected_components(G))\nscc = list(nx.strongly_connected_components(D))\nlouvain = nx.community.louvain_communities(G, seed=42)\nlabelprop = list(nx.community.label_propagation_communities(G))\nprint(f\"WCC: {len(wcc)} components (largest {max(map(len, wcc)):,}) · \"\n      f\"SCC: {len(scc):,} · label-prop: {len(labelprop)} communities\")\nprint(f\"Louvain: {len(louvain)} communities · \"\n      f\"modularity {nx.community.modularity(G, louvain):.3f}\")\n\npd.DataFrame([\n    {\"size\": len(c),\n     \"members\": \", \".join(sorted(label.get(a, \"?\") for a in c)[:4]) + \" …\"}\n    for c in sorted(louvain, key=len, reverse=True)[:6]])"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "triangles",
+   "metadata": {},
+   "outputs": [],
+   "source": "tri = sum(nx.triangles(G).values()) // 3\nprint(f\"triangles: {tri:,} · average clustering coefficient: {nx.average_clustering(G):.3f}\")\ncore = nx.core_number(G)                                      # k-core decomposition\nkmax = max(core.values())\nmembers = sorted(label.get(n, n) for n, k in core.items() if k == kmax)\nprint(f\"max k-core: k={kmax} · {len(members)} actors in the graph's densest shell, e.g.:\")\nprint(\"  \" + \", \".join(members[:10]) + \" …\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "similarity-md",
+   "metadata": {},
+   "source": "## 4 · Node Similarity — with ground truth in the file\n\nNode similarity by neighbourhood overlap (Jaccard) is a staple of every\nanalytics catalog. Here we compare *drawings* by shared cast — and this\ndataset ships its own precomputed answer (`lomb:sharesActorsWith` overlap\nnodes carrying `lomb:jaccard`), so for once an algorithm demo can be\n**checked against the file itself**:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "similarity",
+   "metadata": {},
+   "outputs": [],
+   "source": "dep = g.query_df(PREFIXES + \"SELECT ?d ?actor WHERE { ?d lomb:depicts ?actor }\")\ntdf = g.query_df(PREFIXES + \"SELECT ?d ?name WHERE { ?d a lomb:Drawing ; schema:name ?name }\")\ntitle = dict(zip(tdf[\"d\"], tdf[\"name\"]))\ncast = {}\nfor d_, a_ in zip(dep[\"d\"], dep[\"actor\"]):\n    cast.setdefault(d_, set()).add(a_)\n\nshipped = g.query_df(PREFIXES + \"\"\"\nSELECT ?a ?b ?j WHERE {\n  ?ov lomb:betweenDrawing ?a, ?b ; lomb:jaccard ?j . FILTER(STR(?a) < STR(?b))\n}\"\"\")\nrows, agree = [], 0\nfor a_, b_, j_ in zip(shipped[\"a\"], shipped[\"b\"], shipped[\"j\"]):\n    ours = len(cast[a_] & cast[b_]) / len(cast[a_] | cast[b_])\n    agree += abs(ours - float(j_)) < 0.02\n    rows.append({\"drawing A\": title.get(a_, a_)[:34], \"drawing B\": title.get(b_, b_)[:34],\n                 \"ours\": round(ours, 3), \"shipped\": round(float(j_), 3)})\nprint(f\"our Jaccard agrees with the file's own on {agree}/{len(shipped)} drawing pairs\")\npd.DataFrame(sorted(rows, key=lambda r: -r[\"ours\"])[:8])"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "linkpred-md",
+   "metadata": {},
+   "source": "## 5 · Topological link prediction — which doubles as entity resolution\n\nAdamic-Adar, Common Neighbors, Preferential Attachment, Resource Allocation —\nNetworkX has all four classic link predictors as one-liners. The top\npredictions here split into two delightful categories:\n\n- **near-duplicates under different spellings** — \"FNN\" ↔ \"Financial News\n  Network\", \"Indian Springs St Bk\" ↔ \"Indian Springs State Bank\". The dataset's\n  own `lomb:sameNameAs` links duplicates with *identical* names (we checked:\n  250 of its 306 pairs are byte-equal labels), so link prediction **extends the\n  curators' entity resolution** to the spellings exact matching cannot catch;\n- **plausible ties Lombardi never drew as one arc** — \"Tory party\" ↔ \"Pergau\n  dam\" *is* the 1994 aid-for-arms affair."
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "linkpred",
+   "metadata": {},
+   "outputs": [],
+   "source": "from itertools import combinations\n# candidate pairs = non-adjacent nodes sharing >= 1 neighbour (the usual restriction)\ncand = set()\nfor n in G.nodes:\n    for u, v in combinations(G[n], 2):\n        if not G.has_edge(u, v):\n            cand.add((u, v) if u < v else (v, u))\nprint(f\"{len(cand):,} candidate pairs at distance 2\")\n\naa = sorted(nx.adamic_adar_index(G, cand), key=lambda x: -x[2])[:8]\nra = {(u, v): s_ for u, v, s_ in nx.resource_allocation_index(G, [p[:2] for p in aa])}\npa = {(u, v): s_ for u, v, s_ in nx.preferential_attachment(G, [p[:2] for p in aa])}\n\npd.DataFrame([{\"actor A\": label.get(u, u)[:30], \"actor B\": label.get(v, v)[:30],\n               \"adamic-adar\": round(s_, 2),\n               \"common nbrs\": len(list(nx.common_neighbors(G, u, v))),\n               \"resource-alloc\": round(ra[(u, v)], 2),\n               \"pref-attach\": pa[(u, v)]}\n              for u, v, s_ in aa])"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "paths-md",
+   "metadata": {},
+   "source": "## 6 · Path finding\n\nLombardi's most famous drawing connects George W. Bush to the bin Laden family\nthrough Texas oil money. Dijkstra agrees with him — and note the SPARQL\ncross-check: a *property path* answers reachability inside the engine, no\nexport needed (it runs over all `connectedTo` arcs, chronology included, hence\nthe larger count):"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "paths",
+   "metadata": {},
+   "outputs": [],
+   "source": "bush = next(n for n in G.nodes if \"George W. Bush\" in label.get(n, \"\"))\nosama = next(n for n in G.nodes if label.get(n, \"\") == \"Osama bin Laden\")\n\npath = nx.shortest_path(G, bush, osama)                        # Dijkstra\nprint(\"  →  \".join(label.get(n, n) for n in path))\n\nk_paths = []\nimport itertools\nfor p_ in itertools.islice(nx.shortest_simple_paths(G, bush, osama), 3):   # Yen's k-shortest\n    k_paths.append(\" → \".join(label.get(n, n) for n in p_))\nprint(\"\\nYen's 3 shortest:\", *k_paths, sep=\"\\n  \")\n\nreach = g.query(PREFIXES +\n    \"SELECT (COUNT(DISTINCT ?x) AS ?n) WHERE { <%s> (lomb:connectedTo|^lomb:connectedTo)+ ?x }\" % bush)\nprint(f\"\\nSPARQL property-path: {reach[0]['n'].value} actors reachable from Bush \"\n      f\"(NetworkX component: {len(nx.node_connected_component(G, bush)):,})\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fastrp-md",
+   "metadata": {},
+   "source": "## 7 · Node embeddings — FastRP is ~15 lines of NumPy\n\nFastRP (Chen et al. 2019), the workhorse node-embedding algorithm of the\nanalytics catalogs, is sparse random projection plus a weighted sum of powers\nof the normalized adjacency matrix. That is three matrix products — NumPy\nterritory. Same CSR matrix, and the customary iteration weights:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fastrp",
+   "metadata": {},
+   "outputs": [],
+   "source": "import scipy.sparse as sp\nnodes = list(G.nodes); nix = {n: i for i, n in enumerate(nodes)}\nr = [nix[u] for u, v in G.edges] + [nix[v] for u, v in G.edges]\nc = [nix[v] for u, v in G.edges] + [nix[u] for u, v in G.edges]\nA = sp.csr_matrix((np.ones(len(r)), (r, c)), shape=(len(nodes), len(nodes)))\n\ndeg_ = np.asarray(A.sum(1)).ravel(); deg_[deg_ == 0] = 1\nAn = sp.diags(1 / deg_) @ A                       # row-normalized adjacency\nrng = np.random.default_rng(42)\nR = rng.choice([-1.0, 0.0, 1.0], size=(len(nodes), 64), p=[1/6, 2/3, 1/6]) * np.sqrt(3)\nX1 = An @ R; X2 = An @ X1; X3 = An @ X2           # 1-, 2-, 3-hop views\nemb = X1 + 0.8 * X2 + 0.6 * X3                    # FastRP iteration weights\nemb /= np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12\nprint(\"FastRP embeddings:\", emb.shape)\n\n# K-Nearest Neighbors on the embeddings:\nfrom sklearn.neighbors import NearestNeighbors\nnn = NearestNeighbors(n_neighbors=5, metric=\"cosine\").fit(emb)\n_, ind = nn.kneighbors(emb[[nix[bush]]])\nprint(\"nearest to George W. Bush in embedding space:\",\n      \", \".join(label.get(nodes[j], \"?\") for j in ind[0][1:]))"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "plot",
+   "metadata": {},
+   "outputs": [],
+   "source": "import matplotlib.pyplot as plt\nfrom sklearn.decomposition import PCA\n\nxy = PCA(n_components=2).fit_transform(emb)\nbig6 = sorted(louvain, key=len, reverse=True)[:6]\nfig, ax = plt.subplots(figsize=(7, 5.5))\nax.scatter(xy[:, 0], xy[:, 1], s=3, c=\"#cccccc\", label=\"_\")\nfor i, comm in enumerate(big6):\n    ix = [nix[n] for n in comm if n in nix]\n    ax.scatter(xy[ix, 0], xy[ix, 1], s=6, label=f\"community {i} · {len(comm)} actors\")\nax.legend(fontsize=8, loc=\"best\"); ax.set_axis_off()\nax.set_title(\"FastRP embedding (PCA) coloured by Louvain community —\\neach cluster ≈ one Lombardi scandal\")\nplt.show()"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "nodeclass-md",
+   "metadata": {},
+   "source": "## 8 · The ML pipeline — node classification, honestly\n\nA node-classification pipeline is features + train/test split + a classifier.\nEvery actor here is typed `lo:Person` or `lo:Institution` — can structure alone\nrecover that? **Almost not**: FastRP-only scores ≈ the majority baseline.\n\nThe fix is the RDF advantage. In a property graph the arc *types* live in the\nprojection config; in RDF they are first-class data. Count each node's incident\narcs **by type** and the classifier works — and is interpretable: institutions\n*receive* `InfluenceControl` arcs, people *exert* them. Lombardi would nod."
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "nodeclass",
+   "metadata": {},
+   "outputs": [],
+   "source": "types_df = g.query_df(PREFIXES + \"\"\"\nSELECT ?actor ?cls WHERE {\n  ?actor a ?cls ; lomb:actorId ?id . FILTER(?cls IN (lo:Person, lo:Institution))\n}\"\"\")\ncls_map = dict(zip(types_df[\"actor\"], types_df[\"cls\"]))\n\narc_types = sorted(edges[\"type\"].unique()); tix = {t: i for i, t in enumerate(arc_types)}\nF = np.zeros((len(nodes), 2 * len(arc_types)))\nfor s_, t_, ty in zip(edges[\"src\"], edges[\"tgt\"], edges[\"type\"]):\n    F[nix[s_], tix[ty]] += 1                       # arcs OUT, by type\n    F[nix[t_], len(arc_types) + tix[ty]] += 1      # arcs IN,  by type\n\nkeep = [i for i, n in enumerate(nodes) if cls_map.get(n, \"\").endswith((\"#Person\", \"#Institution\"))]\ny = np.array([1 if cls_map[nodes[i]].endswith(\"#Person\") else 0 for i in keep])\n\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.preprocessing import StandardScaler\nbase = max(y.mean(), 1 - y.mean())\nacc_emb  = cross_val_score(LogisticRegression(max_iter=3000), emb[keep], y, cv=5).mean()\nXs = StandardScaler().fit_transform(F[keep])\nacc_feat = cross_val_score(LogisticRegression(max_iter=3000), Xs, y, cv=5).mean()\nprint(f\"majority baseline          {base:.3f}\")\nprint(f\"FastRP embeddings only     {acc_emb:.3f}   ← structure alone barely helps\")\nprint(f\"typed-edge features        {acc_feat:.3f}   ← RDF predicates are the signal\")\n\nlr = LogisticRegression(max_iter=3000).fit(Xs, y)\nfeat_names = [f\"out:{t.split('#')[-1]}\" for t in arc_types] + [f\"in:{t.split('#')[-1]}\" for t in arc_types]\npd.DataFrame(sorted(zip(feat_names, lr.coef_[0]), key=lambda kv: -abs(kv[1]))[:6],\n             columns=[\"feature\", \"coef (+person / −institution)\"]).round(2)"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "writeback-md",
+   "metadata": {},
+   "source": "## 9 · Write-back — immutably\n\nAn analytics server writes results back by mutating the database in place. A\n`.rete` file is immutable — so write-back means **deriving a new file**: bake\nthe computed scores into triples, build, and the analytics become\nSPARQL-queryable data (card and provenance included). This is the same builder\nthat made the original file:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "writeback",
+   "metadata": {},
+   "outputs": [],
+   "source": "XSD = \"http://www.w3.org/2001/XMLSchema#\"\ncomm_of = {n: i for i, c in enumerate(sorted(louvain, key=len, reverse=True)) for n in c}\nnt = []\nfor n in nodes:\n    nt.append(f'<{n}> <urn:gds:pagerank> \"{pagerank.get(n, 0):.6f}\"^^<{XSD}double> .')\n    nt.append(f'<{n}> <urn:gds:community> \"{comm_of.get(n, -1)}\"^^<{XSD}integer> .')\n\nderived = (rete.Builder()\n    .add(\"\\n\".join(nt))\n    .card(title=\"Lombardi centrality & communities — derived .rete\",\n          license=\"CC BY-NC-SA 4.0 (derived from lombardinetworks.net)\")\n    .example(\"SELECT ?actor ?pr WHERE { ?actor <urn:gds:pagerank> ?pr } ORDER BY DESC(?pr) LIMIT 5\",\n             title=\"Top actors by PageRank\")\n    .graph())\nprint(f\"derived graph: {derived.quads:,} triples — analytics as queryable RDF\")\n\ndf = derived.query_df(\"\"\"\nSELECT ?community (COUNT(?actor) AS ?actors) WHERE {\n  ?actor <urn:gds:community> ?community\n} GROUP BY ?community ORDER BY DESC(?actors) LIMIT 5\"\"\")\ndf"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "sknetwork-md",
+   "metadata": {},
+   "source": "## 10 · Same matrix, bigger engines — scikit-network\n\nThe CSR matrix `A` we built for FastRP is *exactly* what\n[scikit-network](https://scikit-network.readthedocs.io) consumes — its Louvain\nand PageRank are compiled and orders of magnitude faster than NetworkX, which is\nwhat you want past ~10⁶ edges. Its compiled wheels aren't available to the\nin-browser Pyodide kernel, where this cell skips with a note; Binder\npreinstalls it, and anywhere else `pip install scikit-network` lights it up:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "sknetwork",
+   "metadata": {},
+   "outputs": [],
+   "source": "try:\n    from sknetwork.ranking import PageRank\n    from sknetwork.clustering import Louvain\n    pr = PageRank().fit_predict(A)\n    communities = Louvain().fit_predict(A)\n    print(\"scikit-network PageRank top-5:\",\n          \", \".join(label.get(nodes[i], \"?\") for i in np.argsort(-pr)[:5]))\n    print(f\"scikit-network Louvain: {len(set(communities))} communities\")\nexcept ImportError:\n    print(\"scikit-network is not installed in this environment — skipping.\")\n    print(\"Run `pip install scikit-network` on any Jupyter server (Binder has it\")\n    print(\"preinstalled; the in-browser Pyodide kernel can't install it) and this\")\n    print(\"cell lights up; A (csr_matrix) and the edge list are already in shape.\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "pyg-md",
+   "metadata": {},
+   "source": "## 11 · The GNN bridge — PyTorch Geometric\n\nFor GNNs — GraphSAGE and friends — and for learned pipelines at scale, the\nopen ecosystem's tool is\n[PyTorch Geometric](https://pytorch-geometric.readthedocs.io). The projection\nDataFrame maps 1:1 onto PyG's two graph containers:\n\n- **`Data`** — `edge_index` is just our `src/tgt` columns factorized;\n- **`HeteroData`** — one relation per `arcType`, which is *exactly the RDF shape*:\n  `(\"actor\", \"FinancialTransaction\", \"actor\")`.\n\nVerified on this projection: a 2-layer GCN reaches **0.695** test accuracy on\nPerson-vs-Institution (baseline 0.576) — and, a lesson worth keeping, the\nhumble typed-edge logistic regression above (0.81) beats it at this scale.\nTorch isn't available to the in-browser kernel and is deliberately left out of\nthe Binder image (~800 MB of wheels); Colab already ships it, and anywhere\nelse `pip install torch torch_geometric` activates this cell:"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "pyg",
+   "metadata": {},
+   "outputs": [],
+   "source": "try:\n    import torch\n    from torch_geometric.data import Data, HeteroData\n    from torch_geometric.nn import GCNConv\n    import torch.nn.functional as Fn\n\n    ei = torch.tensor([[nix[s_] for s_ in edges[\"src\"]],\n                       [nix[t_] for t_ in edges[\"tgt\"]]], dtype=torch.long)\n    ei = torch.cat([ei, ei.flip(0)], dim=1)\n    X = torch.tensor(F, dtype=torch.float)                 # typed-edge features\n    y_all = torch.full((len(nodes),), -1, dtype=torch.long)\n    for i in keep:\n        y_all[i] = 1 if cls_map[nodes[i]].endswith(\"#Person\") else 0\n    data = Data(x=X, edge_index=ei, y=y_all)\n    print(data)\n\n    hetero = HeteroData(); hetero[\"actor\"].num_nodes = len(nodes)\n    for t_ in arc_types:\n        m = edges[\"type\"] == t_\n        hetero[\"actor\", t_.split(\"#\")[-1], \"actor\"].edge_index = torch.tensor(\n            [[nix[s_] for s_ in edges[\"src\"][m]], [nix[x] for x in edges[\"tgt\"][m]]])\n    print(\"hetero relations:\", [r for _, r, _ in hetero.edge_types])\n\n    class GCN(torch.nn.Module):\n        def __init__(self):\n            super().__init__()\n            self.c1, self.c2 = GCNConv(X.shape[1], 32), GCNConv(32, 2)\n        def forward(self, d):\n            return self.c2(Fn.relu(self.c1(d.x, d.edge_index)), d.edge_index)\n\n    torch.manual_seed(0)\n    lab = y_all >= 0\n    perm = torch.randperm(int(lab.sum()))\n    li = lab.nonzero(as_tuple=True)[0][perm]\n    tr, te = li[:int(0.7 * len(li))], li[int(0.7 * len(li)):]\n    model, opt = GCN(), None\n    opt = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)\n    for _ in range(120):\n        model.train(); opt.zero_grad()\n        Fn.cross_entropy(model(data)[tr], y_all[tr]).backward(); opt.step()\n    model.eval()\n    acc = (model(data).argmax(1)[te] == y_all[te]).float().mean().item()\n    print(f\"GCN test accuracy: {acc:.3f}\")\nexcept ImportError:\n    print(\"PyTorch (Geometric) is not installed in this environment — skipping.\")\n    print(\"On Colab torch is already there (`pip install torch_geometric` completes\")\n    print(\"it); elsewhere: pip install torch torch_geometric. Then this cell builds\")\n    print(\"Data, HeteroData and trains the GCN as-is.\")"
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a08f18b7",
+   "source": "## 12 · Close the loop — show the drawings\n\nEvery score above was computed from arcs Lombardi drew in pencil, and the file\nknows what the sheets look like. Each drawing is a `schema:VisualArtwork` that\n`lomb:depicts` its actors, and 17 of the 51 carry image links (all IRIs):\n`schema:image` — MoMA's photograph of the sheet at ≤1024 px — plus a 2000 px\n`lomb:momaImageFull`, while `lomb:imagePage` points at write-ups around the\nweb (those are pages, not images). Only the MoMA-photographed drawings have\nimage URLs, so we walk down the PageRank ranking and collect drawings until we\nhave six.\n\nOne last SPARQL query joins the analysis back to the art: *for the actors the\nalgorithms ranked highest, show me the drawings* — the score in the caption,\nLombardi's actual pencil lines above it. Where the notebook can reach the\nnetwork directly it embeds the image bytes; otherwise your browser loads the\nURL, and if an image ever fails to load the card degrades to its title and\nlinks instead of a broken grid.",
+   "metadata": {}
+  },
+  {
+   "cell_type": "code",
+   "id": "9acaff04",
+   "source": "import base64, html as html_mod\nfrom IPython.display import HTML, display\n\nart = g.query_df(PREFIXES + \"\"\"\nSELECT ?actor ?drawing ?title ?img ?full WHERE {\n  ?drawing a schema:VisualArtwork ;\n           lomb:depicts ?actor ;\n           schema:name  ?title ;\n           schema:image ?img .\n  OPTIONAL { ?drawing lomb:momaImageFull ?full }\n}\"\"\")\nby_actor = {}\nfor row in art.itertuples(index=False):\n    by_actor.setdefault(row.actor, []).append(row)\nprint(f\"{art['drawing'].nunique()} drawings with images, \"\n      f\"depicting {art['actor'].nunique():,} of our ranked actors\")\n\ndef as_data_uri(url, timeout=20):\n    \"\"\"Embed the image bytes if this runtime can fetch them (CPython can;\n    the Pyodide kernel has no socket layer, so there we return None and let\n    the browser's <img> load the URL itself).\"\"\"\n    try:\n        from urllib.request import urlopen, Request\n        with urlopen(Request(url, headers={\"User-Agent\": \"rete-gds-notebook\"}),\n                     timeout=timeout) as rsp:\n            ctype = rsp.headers.get(\"Content-Type\", \"\")\n            if not ctype.startswith(\"image/\"):\n                return None\n            return f\"data:{ctype};base64,{base64.b64encode(rsp.read()).decode()}\"\n    except Exception:\n        return None\n\n# walk down the PageRank ranking; first drawing we haven't shown yet wins\ncards, picked, seen = [], [], set()\nfor rank, actor in enumerate(sorted(pagerank, key=pagerank.get, reverse=True), 1):\n    for row in by_actor.get(actor, []):\n        if row.img in seen:\n            continue\n        seen.add(row.img)\n        full = row.full if isinstance(row.full, str) else row.img\n        esc = html_mod.escape\n        caption = (\n            f\"<b>#{rank} {esc(label.get(actor, actor))}</b> — \"\n            f\"PageRank {pagerank[actor]:.4f} · community {comm_of.get(actor, '?')}<br>\"\n            f\"<i>{esc(row.title)}</i><br>\"\n            f'<a href=\"{esc(row.drawing)}\">drawing page</a> · '\n            f'<a href=\"{esc(full)}\">full resolution</a>')\n        src = as_data_uri(row.img) or row.img\n        cards.append(\n            f'<figure style=\"margin:0;width:230px;font-size:11px;line-height:1.5\">'\n            f'<a href=\"{esc(full)}\"><img src=\"{esc(src)}\" alt=\"{esc(row.title)}\" '\n            f'style=\"width:100%;border:1px solid #999;border-radius:3px\" '\n            f'onerror=\"this.style.display=\\'none\\'\"></a>'\n            f'<figcaption>{caption}</figcaption></figure>')\n        picked.append({\"rank\": rank, \"actor\": label.get(actor, actor),\n                       \"pagerank\": round(pagerank[actor], 4),\n                       \"community\": comm_of.get(actor, -1),\n                       \"drawing\": row.title})\n        break                      # one drawing per actor\n    if len(cards) >= 6:\n        break\n\ndisplay(pd.DataFrame(picked).set_index(\"rank\"))\ndisplay(HTML('<div style=\"display:flex;flex-wrap:wrap;gap:14px\">' + \"\".join(cards) + \"</div>\"))\nprint(\"Drawings © the estate of Mark Lombardi; photographs via MoMA. CC BY-NC-SA 4.0 metadata.\")",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "outro",
+   "metadata": {},
+   "source": "---\n\n## What needs extra packages, and where this scales\n\n- **Leiden, Node2Vec, GraphSAGE, CELF** — same projection code, plus one\n  `pip install` (`sknetwork`/`leidenalg`, `gensim`, PyG) on any Jupyter server.\n- **Billions of edges** — don't stream them into a notebook kernel. The same\n  `.rete` files carry Parquet companions for bulk analytics, and any file is a\n  standard SPARQL 1.1 endpoint, so server-side tooling (property-graph stores\n  included — Neo4j reads RDF via neosemantics) can consume it.\n- **Write-back** here means *derive a new immutable file* — analytics results\n  stay versioned, citable data instead of mutated database state.\n\n**Where next:** [the playground](https://caviri.github.io/rete/playground.html)\n(this dataset is `lombardi`) · [Python API](https://caviri.github.io/rete/python.html) ·\n[agent frameworks over .rete](https://caviri.github.io/rete/agent-frameworks.html) ·\n[docs index](https://caviri.github.io/rete/)\n\nSource & issues: **<https://github.com/caviri/rete>**\n\n© 2026 Carlos Vivar Ríos — Apache License 2.0. Dataset: *Mark Lombardi\nNetworks* ([lombardinetworks.net](https://lombardinetworks.net)),\nCC BY-NC-SA 4.0; drawings © the estate of Mark Lombardi."
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (Pyodide)",
+   "language": "python",
+   "name": "python"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}