@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Isomorphism-DInKnWIy.mjs

@@ -0,0 +1,390 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { i as rdf } from "./Vocab-DceKywpq.mjs";
+import { D as isBlankNode, E as loop, j as isVariable, k as isNamedNode, r as Formula, s as Statement, t as Collection } from "./Model-DlPzRYhF.mjs";
+import { a as record, i as increment, n as count, o as single, r as followList, t as append } from "./lists-D-OpQ0Ir.mjs";
+import * as Arr from "effect/Array";
+import { dual } from "effect/Function";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Order from "effect/Order";
+// src/n3/Isomorphism.ts
+/**
+* Isomorphism of N3 formulas.
+*
+* Two formulas are isomorphic when they are equal up to a consistent
+* renaming of blank nodes and of variables (alpha-equivalence). Unlike the
+* core RDF isomorphism, blank nodes and variables may occur in any position
+* (including predicates), and the comparison recurses into nested formulas.
+*
+* Well-formed explicit RDF lists (`rdf:first`/`rdf:rest` chains of blank
+* nodes) are normalised to collections first, so `( 1 2 )` is isomorphic to
+* the equivalent blank node chain produced by RDF-only syntaxes such as
+* N-Triples.
+*
+* @since 0.1.0
+*/
+var Isomorphism_exports = /* @__PURE__ */ __exportAll({
+	bijection: () => bijection,
+	isomorphic: () => isomorphic
+});
+const isNode = (atom) => atom.charCodeAt(0) !== 61;
+const kindOf = (atom) => atom.slice(0, 2);
+const RDF_FIRST = rdf.first.value;
+const RDF_REST = rdf.rest.value;
+const RDF_NIL = `=${rdf.nil.key}`;
+/** The separator of the atoms in a tuple's key (no atom contains it). */
+const SEP = "
";
+/** Whether a term contains a blank node or a variable (in any nested formula or collection). */
+const hasNodes = (t) => t instanceof Statement ? hasNodes(t.subject) || hasNodes(t.predicate) || hasNodes(t.object) : t instanceof Formula ? t.statements.some(hasNodes) : t instanceof Collection ? t.items.some(hasNodes) : isBlankNode(t) || isVariable(t);
+/** Counts the occurrences of each blank node label (plain refinements: it visits every term). */
+const countBlanks = (self, out) => {
+	if (self instanceof Statement) {
+		countBlanks(self.subject, out);
+		countBlanks(self.predicate, out);
+		countBlanks(self.object, out);
+	} else if (self instanceof Formula) self.statements.forEach((st) => countBlanks(st, out));
+	else if (self instanceof Collection) self.items.forEach((i) => countBlanks(i, out));
+	else if (isBlankNode(self)) increment(out, self.value);
+};
+/**
+* Rewrites well-formed `rdf:first`/`rdf:rest` chains of blank nodes into
+* collections, so that explicit RDF lists compare equal to `( … )`.
+*/
+const normalizeLists = (root) => {
+	const occ = MutableHashMap.empty();
+	countBlanks(root, occ);
+	const normalizeFormula = (f) => {
+		const first = MutableHashMap.empty();
+		const rest = MutableHashMap.empty();
+		const other = MutableHashMap.empty();
+		const restTargets = MutableHashSet.empty();
+		f.statements.forEach((st) => {
+			if (!isBlankNode(st.subject)) return;
+			const b = st.subject.value;
+			const p = isNamedNode(st.predicate) ? st.predicate.value : "";
+			if (p === RDF_FIRST) append(first, b, st);
+			else if (p === RDF_REST) append(rest, b, st);
+			else increment(other, b);
+			if (p === RDF_REST && isBlankNode(st.object)) MutableHashSet.add(restTargets, st.object.value);
+		});
+		const cellOf = (label, isHead) => !isHead && (count(other, label) > 0 || count(occ, label) !== 3) ? Option.none() : Option.zipWith(single(first, label), single(rest, label), (a, b) => [a, b]);
+		const heads = MutableHashMap.empty();
+		const consumed = /* @__PURE__ */ new WeakSet();
+		MutableHashMap.forEach(first, (_, h) => {
+			if (MutableHashSet.has(restTargets, h) || Option.isNone(cellOf(h, true))) return;
+			const o = count(other, h);
+			const total = count(occ, h);
+			if (!(o === 0 ? total <= 3 : total === 2 + o)) return;
+			const cells = followList(h, cellOf);
+			if (Option.isSome(cells)) record(heads, consumed, h, cells.value);
+		});
+		const term = (t) => normalizeTerm(t, heads);
+		return new Formula(f.statements.filter((st) => !consumed.has(st)).map((st) => new Statement(term(st.subject), term(st.predicate), term(st.object))));
+	};
+	const normalizeTerm = (t, heads) => {
+		if (isBlankNode(t)) {
+			const items = heads.backing.get(t.value);
+			return items === void 0 ? t : Arr.isReadonlyArrayEmpty(items) ? rdf.nil : new Collection(items.map((i) => normalizeTerm(i, heads)));
+		}
+		if (t instanceof Collection) return Arr.isReadonlyArrayEmpty(t.items) ? rdf.nil : new Collection(t.items.map((i) => normalizeTerm(i, heads)));
+		return t instanceof Formula ? normalizeFormula(t) : t;
+	};
+	return normalizeFormula(root);
+};
+const flatten = (self) => {
+	const out = MutableHashMap.empty();
+	let counter = 0;
+	const formulaNodes = MutableHashMap.empty();
+	const add = (t) => MutableHashMap.set(out, t.join(SEP), t);
+	const atom = (t) => {
+		if (isBlankNode(t)) return `b:${t.value}`;
+		if (isVariable(t)) return `v:${t.value}`;
+		if (t instanceof Collection) {
+			if (Arr.isReadonlyArrayEmpty(t.items)) return RDF_NIL;
+			if (!hasNodes(t)) return `=${t.key}`;
+			const l = `l:${counter++}`;
+			t.items.forEach((item, i) => add([
+				l,
+				`=#${i}`,
+				atom(item),
+				"=list"
+			]));
+			add([
+				l,
+				"=length",
+				`=${t.items.length}`,
+				"=list"
+			]);
+			return l;
+		}
+		if (t instanceof Formula) {
+			if (!hasNodes(t)) return `=${t.key}`;
+			const known = formulaNodes.backing.get(t.key);
+			if (known !== void 0) return known;
+			const g = `f:${counter++}`;
+			MutableHashMap.set(formulaNodes, t.key, g);
+			statements(t, g);
+			return g;
+		}
+		return `=${t.key}`;
+	};
+	const statements = (f, graph) => {
+		f.statements.forEach((st) => {
+			add([
+				atom(st.subject),
+				atom(st.predicate),
+				atom(st.object),
+				graph
+			]);
+		});
+	};
+	statements(normalizeLists(self), "=");
+	return Arr.fromIterable(MutableHashMap.values(out));
+};
+const hashString = (s) => {
+	let h = 2166136261;
+	loop((i) => {
+		if (i >= s.length) return false;
+		h = Math.imul(h ^ s.charCodeAt(i), 16777619);
+		return true;
+	});
+	return h >>> 0;
+};
+const mix = (h, v) => {
+	let x = Math.imul(h ^ v, 1540483477);
+	x ^= x >>> 15;
+	return Math.imul(x, 668265261) >>> 0;
+};
+/** The number of distinct colours in a colouring. */
+const countClasses = (c) => {
+	const sorted = c.toSorted();
+	return sorted.reduce((count, v, k) => k === 0 || v !== sorted[k - 1] ? count + 1 : count, 0);
+};
+/**
+* Iterative colour refinement: a node's colour is repeatedly refined by the
+* (multiset of) tuples it occurs in, and its positions in them, until the
+* partition is stable.
+*/
+const refine = (tuples) => {
+	const index = MutableHashMap.empty();
+	const nodes = [];
+	const byNode = [];
+	const fixed = MutableHashMap.empty();
+	const nT = tuples.length;
+	const nodeAt = new Int32Array(nT * 4);
+	const fixedAt = new Uint32Array(nT * 4);
+	const occurrences = [];
+	tuples.forEach((t, ti) => {
+		const seen = [];
+		const masks = [];
+		t.forEach((a, k) => {
+			if (!isNode(a)) {
+				let h = fixed.backing.get(a);
+				if (h === void 0) {
+					h = hashString(a);
+					MutableHashMap.set(fixed, a, h);
+				}
+				nodeAt[ti * 4 + k] = -1;
+				fixedAt[ti * 4 + k] = h;
+				return;
+			}
+			let n = index.backing.get(a);
+			if (n === void 0) {
+				n = nodes.length;
+				MutableHashMap.set(index, a, n);
+				nodes.push(a);
+				byNode.push([]);
+				occurrences.push([]);
+			}
+			nodeAt[ti * 4 + k] = n;
+			const j = seen.indexOf(n);
+			if (j < 0) {
+				seen.push(n);
+				masks.push(1 << k);
+			} else masks[j] = (masks[j] ?? 0) | 1 << k;
+		});
+		seen.forEach((n, j) => {
+			byNode[n]?.push(ti);
+			occurrences[n]?.push([ti, masks[j] ?? 0]);
+		});
+	});
+	const nN = nodes.length;
+	let colour = Uint32Array.from(nodes, (a) => hashString(kindOf(a)));
+	let classes = countClasses(colour);
+	const tupleHash = new Uint32Array(nT);
+	const valueAt = (p) => {
+		const n = nodeAt[p] ?? -1;
+		return n >= 0 ? colour[n] ?? 0 : fixedAt[p] ?? 0;
+	};
+	loop((round) => {
+		if (round > nN || classes >= nN) return false;
+		tupleHash.forEach((_, ti) => {
+			const at = ti * 4;
+			tupleHash[ti] = mix(mix(mix(mix(7, valueAt(at)), valueAt(at + 1)), valueAt(at + 2)), valueAt(at + 3));
+		});
+		const next = Uint32Array.from(occurrences, (occ, n) => mix(colour[n] ?? 0, occ.reduce((acc, [ti, mask]) => acc + mix(tupleHash[ti] ?? 0, mask) >>> 0, 0)));
+		const nextClasses = countClasses(next);
+		colour = next;
+		if (nextClasses === classes) return false;
+		classes = nextClasses;
+		return true;
+	});
+	return {
+		tuples,
+		nodes,
+		colour,
+		byNode,
+		nodeAt
+	};
+};
+const tupleKey = (t) => t.join(SEP);
+/** Groups a partition's nodes (by index, in order) by their colour. */
+const groupByColour = (p) => {
+	const groups = MutableHashMap.empty();
+	p.colour.forEach((c, n) => {
+		const g = groups.backing.get(c);
+		if (g === void 0) MutableHashMap.set(groups, c, [n]);
+		else g.push(n);
+	});
+	return groups;
+};
+const noNodes = [];
+/**
+* A renaming of the nodes of `a` to those of `b` under which the tuples are
+* the same, as `[node of a, node of b]` pairs: those mapped directly, in
+* order of first occurrence, then those found by backtracking.
+*/
+const bijectionTuples = (a, b) => {
+	if (a.length !== b.length) return Option.none();
+	const target = MutableHashMap.empty();
+	b.forEach((t) => MutableHashMap.set(target, tupleKey(t), true));
+	const targets = target.backing;
+	const aNodes = [];
+	if (!a.every((t) => {
+		if (!t.some(isNode)) return targets.has(tupleKey(t));
+		aNodes.push(t);
+		return true;
+	})) return Option.none();
+	const bNodes = b.filter((t) => t.some(isNode));
+	if (aNodes.length !== bNodes.length) return Option.none();
+	if (Arr.isReadonlyArrayEmpty(aNodes)) return Option.some([]);
+	const pa = refine(aNodes);
+	const pb = refine(bNodes);
+	if (pa.nodes.length !== pb.nodes.length) return Option.none();
+	const groupsA = groupByColour(pa);
+	const groupsB = groupByColour(pb);
+	const candidatesOf = (n) => groupsB.backing.get(pa.colour[n] ?? 0) ?? noNodes;
+	if (Iterable.some(groupsA, ([c, g]) => groupsB.backing.get(c)?.length !== g.length)) return Option.none();
+	const mapping = new Int32Array(pa.nodes.length).fill(-1);
+	const used = new Uint8Array(pb.nodes.length);
+	/** Position `p` of tuple `t` under the mapping (`''` while its node is unmapped). */
+	const mapped = (t, p) => {
+		const n = pa.nodeAt[p] ?? -1;
+		const atom = t[p & 3] ?? "";
+		if (n < 0) return atom;
+		const m = mapping[n] ?? -1;
+		return m < 0 ? "" : pb.nodes[m] ?? "";
+	};
+	const consistent = (node) => (pa.byNode[node] ?? noNodes).every((ti) => {
+		const t = pa.tuples[ti] ?? emptyTuple;
+		const at = ti * 4;
+		const s = mapped(t, at);
+		const p = mapped(t, at + 1);
+		const o = mapped(t, at + 2);
+		const g = mapped(t, at + 3);
+		if (s === "" || p === "" || o === "" || g === "") return true;
+		return targets.has(`${s}${SEP}${p}${SEP}${o}${SEP}${g}`);
+	});
+	const direct = [];
+	const ambiguous = [];
+	pa.nodes.forEach((_, n) => {
+		const candidates = candidatesOf(n);
+		const only = candidates[0] ?? 0;
+		if (candidates.length === 1) {
+			mapping[n] = only;
+			used[only] = 1;
+			direct.push(n);
+		} else ambiguous.push(n);
+	});
+	if (!direct.every(consistent)) return Option.none();
+	const order = Arr.sort(ambiguous, Order.mapInput(Order.Number, (n) => groupsA.backing.get(pa.colour[n] ?? 0)?.length ?? 0));
+	const next = new Int32Array(order.length);
+	let i = 0;
+	let node = 0;
+	let candidates = noNodes;
+	let found = false;
+	const tryNext = () => {
+		const k = next[i] ?? 0;
+		if (k >= candidates.length) return false;
+		next[i] = k + 1;
+		const candidate = candidates[k] ?? 0;
+		if (used[candidate] === 1) return true;
+		mapping[node] = candidate;
+		used[candidate] = 1;
+		if (consistent(node)) {
+			found = true;
+			return false;
+		}
+		mapping[node] = -1;
+		used[candidate] = 0;
+		return true;
+	};
+	loop(() => {
+		if (i < 0 || i >= order.length) return false;
+		node = order[i] ?? 0;
+		const previous = mapping[node] ?? -1;
+		if (previous >= 0) {
+			mapping[node] = -1;
+			used[previous] = 0;
+		}
+		candidates = candidatesOf(node);
+		found = false;
+		loop(tryNext);
+		if (found) i++;
+		else {
+			next[i] = 0;
+			i--;
+		}
+		return true;
+	});
+	if (i !== order.length) return Option.none();
+	const pair = (n) => [pa.nodes[n] ?? "", pb.nodes[mapping[n] ?? 0] ?? ""];
+	return Option.some(Arr.appendAll(direct.map(pair), order.map(pair)));
+};
+const emptyTuple = [
+	"",
+	"",
+	"",
+	""
+];
+/** Renders an internal `b:` / `v:` node key as `_:label` / `?name`. */
+const renderNode = (a) => a.startsWith("b:") ? `_:${a.slice(2)}` : `?${a.slice(2)}`;
+/**
+* Finds a renaming of blank nodes and variables from `self` to `that` under
+* which the two formulas are equal. Keys of the returned map are
+* `_:label` / `?name` of `self`, values those of `that` (nodes generated for
+* collections and nested formulas are omitted).
+*
+* @since 0.1.0
+* @category isomorphism
+*/
+const bijection = (self, that) => Option.map(bijectionTuples(flatten(self), flatten(that)), (pairs) => {
+	const out = MutableHashMap.empty();
+	pairs.forEach(([k, v]) => {
+		if (!k.startsWith("l:") && !k.startsWith("f:")) MutableHashMap.set(out, renderNode(k), renderNode(v));
+	});
+	return out.backing;
+});
+/**
+* Whether two formulas are isomorphic: equal up to a consistent renaming of
+* blank nodes and variables, recursively through nested formulas.
+*
+* @since 0.1.0
+* @category isomorphism
+*/
+const isomorphic = dual(2, (self, that) => Option.isSome(bijectionTuples(flatten(self), flatten(that))));
+export { bijection as n, isomorphic as r, Isomorphism_exports as t };
+
+//# sourceMappingURL=Isomorphism-DInKnWIy.mjs.map

package/dist/Isomorphism-DInKnWIy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Isomorphism-DInKnWIy.mjs","names":["Model.Statement","Model.Formula","Model.Collection","Guards.isBlankNode","Guards.isVariable","Guards.isNamedNode","Lists.count","Lists.single","Lists.followList"],"sources":["../src/n3/Isomorphism.ts"],"sourcesContent":["/**\n * Isomorphism of N3 formulas.\n *\n * Two formulas are isomorphic when they are equal up to a consistent\n * renaming of blank nodes and of variables (alpha-equivalence). Unlike the\n * core RDF isomorphism, blank nodes and variables may occur in any position\n * (including predicates), and the comparison recurses into nested formulas.\n *\n * Well-formed explicit RDF lists (`rdf:first`/`rdf:rest` chains of blank\n * nodes) are normalised to collections first, so `( 1 2 )` is isomorphic to\n * the equivalent blank node chain produced by RDF-only syntaxes such as\n * N-Triples.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport { dual } from 'effect/Function';\nimport * as Iterable from 'effect/Iterable';\nimport * as MutableHashMap from 'effect/MutableHashMap';\nimport * as MutableHashSet from 'effect/MutableHashSet';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\nimport { rdf } from '../Vocab.ts';\nimport * as Guards from './internal/guards.ts';\nimport * as Lists from './internal/lists.ts';\nimport { loop } from './internal/loop.ts';\nimport * as Model from './Model.ts';\n\n// A flattened formula: 4-tuples (subject, predicate, object, graph) of atoms.\n// Atoms are either fixed (`=` + canonical key) or relabelable nodes\n// (`b:` blank node, `v:` variable, `f:` formula, `l:` collection). Formulas\n// and collections without blank nodes or variables are fixed atoms.\ntype Tuple = readonly [string, string, string, string];\n\nconst isNode = (atom: string): boolean => atom.charCodeAt(0) !== 0x3d; /* = */\nconst kindOf = (atom: string): string => atom.slice(0, 2);\n\nconst RDF_FIRST = rdf.first.value;\nconst RDF_REST = rdf.rest.value;\nconst RDF_NIL = `=${rdf.nil.key}`;\n\n/** The separator of the atoms in a tuple's key (no atom contains it). */\nconst SEP = '\\u0001';\n\n/** Whether a term contains a blank node or a variable (in any nested formula or collection). */\nconst hasNodes = (t: Model.N3Term | Model.Statement): boolean =>\n  t instanceof Model.Statement\n    ? hasNodes(t.subject) || hasNodes(t.predicate) || hasNodes(t.object)\n    : t instanceof Model.Formula\n      ? t.statements.some(hasNodes)\n      : t instanceof Model.Collection\n        ? t.items.some(hasNodes)\n        : Guards.isBlankNode(t) || Guards.isVariable(t);\n\n/** Counts the occurrences of each blank node label (plain refinements: it visits every term). */\nconst countBlanks = (\n  self: Model.N3Term | Model.Statement,\n  out: MutableHashMap.MutableHashMap<string, number>,\n): void => {\n  if (self instanceof Model.Statement) {\n    countBlanks(self.subject, out);\n    countBlanks(self.predicate, out);\n    countBlanks(self.object, out);\n  } else if (self instanceof Model.Formula) {\n    self.statements.forEach((st) => countBlanks(st, out));\n  } else if (self instanceof Model.Collection) {\n    self.items.forEach((i) => countBlanks(i, out));\n  } else if (Guards.isBlankNode(self)) {\n    Lists.increment(out, self.value);\n  }\n};\n\n/**\n * Rewrites well-formed `rdf:first`/`rdf:rest` chains of blank nodes into\n * collections, so that explicit RDF lists compare equal to `( … )`.\n */\nconst normalizeLists = (root: Model.Formula): Model.Formula => {\n  const occ = MutableHashMap.empty<string, number>();\n  countBlanks(root, occ);\n  const normalizeFormula = (f: Model.Formula): Model.Formula => {\n    const first = MutableHashMap.empty<string, Array<Model.Statement>>();\n    const rest = MutableHashMap.empty<string, Array<Model.Statement>>();\n    const other = MutableHashMap.empty<string, number>();\n    const restTargets = MutableHashSet.empty<string>();\n    f.statements.forEach((st) => {\n      if (!Guards.isBlankNode(st.subject)) return;\n      const b = st.subject.value;\n      const p = Guards.isNamedNode(st.predicate) ? st.predicate.value : '';\n      if (p === RDF_FIRST) Lists.append(first, b, st);\n      else if (p === RDF_REST) Lists.append(rest, b, st);\n      else Lists.increment(other, b);\n      if (p === RDF_REST && Guards.isBlankNode(st.object)) {\n        MutableHashSet.add(restTargets, st.object.value);\n      }\n    });\n    // A cell: one `rdf:first` and one `rdf:rest`; after the head, used only by the list\n    const cellOf = (label: string, isHead: boolean): Option.Option<Lists.Cell<Model.Statement>> =>\n      !isHead && (Lists.count(other, label) > 0 || Lists.count(occ, label) !== 3)\n        ? Option.none()\n        : Option.zipWith(Lists.single(first, label), Lists.single(rest, label), (a, b) => [a, b]);\n    const heads = MutableHashMap.empty<string, Array<Model.N3Term>>();\n    const consumed = new WeakSet<Model.Statement>();\n    MutableHashMap.forEach(first, (_, h) => {\n      if (MutableHashSet.has(restTargets, h) || Option.isNone(cellOf(h, true))) return;\n      const o = Lists.count(other, h);\n      const total = Lists.count(occ, h);\n      if (!(o === 0 ? total <= 3 : total === 2 + o)) return;\n      const cells = Lists.followList(h, cellOf);\n      if (Option.isSome(cells)) Lists.record(heads, consumed, h, cells.value);\n    });\n    const term = (t: Model.N3Term): Model.N3Term => normalizeTerm(t, heads);\n    return new Model.Formula(\n      f.statements\n        .filter((st) => !consumed.has(st))\n        .map((st) => new Model.Statement(term(st.subject), term(st.predicate), term(st.object))),\n    );\n  };\n  // Plain refinements rather than `Match`: it runs for every term.\n  const normalizeTerm = (\n    t: Model.N3Term,\n    heads: MutableHashMap.MutableHashMap<string, Array<Model.N3Term>>,\n  ): Model.N3Term => {\n    if (Guards.isBlankNode(t)) {\n      const items = heads.backing.get(t.value);\n      return items === undefined\n        ? t\n        : Arr.isReadonlyArrayEmpty(items)\n          ? rdf.nil\n          : new Model.Collection(items.map((i) => normalizeTerm(i, heads)));\n    }\n    if (t instanceof Model.Collection) {\n      return Arr.isReadonlyArrayEmpty(t.items)\n        ? rdf.nil\n        : new Model.Collection(t.items.map((i) => normalizeTerm(i, heads)));\n    }\n    return t instanceof Model.Formula ? normalizeFormula(t) : t;\n  };\n  return normalizeFormula(root);\n};\n\nconst flatten = (self: Model.Formula): Array<Tuple> => {\n  const out = MutableHashMap.empty<string, Tuple>();\n  let counter = 0;\n  const formulaNodes = MutableHashMap.empty<string, string>();\n  const add = (t: Tuple) => MutableHashMap.set(out, t.join(SEP), t);\n  // Plain refinements rather than `Match`: it runs for every term.\n  const atom = (t: Model.N3Term): string => {\n    if (Guards.isBlankNode(t)) return `b:${t.value}`;\n    if (Guards.isVariable(t)) return `v:${t.value}`;\n    if (t instanceof Model.Collection) {\n      if (Arr.isReadonlyArrayEmpty(t.items)) return RDF_NIL;\n      if (!hasNodes(t)) return `=${t.key}`;\n      const l = `l:${counter++}`;\n      t.items.forEach((item, i) => add([l, `=#${i}`, atom(item), '=list']));\n      add([l, '=length', `=${t.items.length}`, '=list']);\n      return l;\n    }\n    if (t instanceof Model.Formula) {\n      if (!hasNodes(t)) return `=${t.key}`;\n      // Formulas are values: equal formulas share one node.\n      const known = formulaNodes.backing.get(t.key);\n      if (known !== undefined) return known;\n      const g = `f:${counter++}`;\n      MutableHashMap.set(formulaNodes, t.key, g);\n      statements(t, g);\n      return g;\n    }\n    return `=${t.key}`;\n  };\n  const statements = (f: Model.Formula, graph: string) => {\n    f.statements.forEach((st) => {\n      add([atom(st.subject), atom(st.predicate), atom(st.object), graph]);\n    });\n  };\n  statements(normalizeLists(self), '=');\n  return Arr.fromIterable(MutableHashMap.values(out));\n};\n\nconst hashString = (s: string): number => {\n  let h = 0x811c9dc5;\n  loop((i) => {\n    if (i >= s.length) return false;\n    h = Math.imul(h ^ s.charCodeAt(i), 0x01000193);\n    return true;\n  });\n  return h >>> 0;\n};\n\nconst mix = (h: number, v: number): number => {\n  let x = Math.imul(h ^ v, 0x5bd1e995);\n  x ^= x >>> 15;\n  return Math.imul(x, 0x27d4eb2d) >>> 0;\n};\n\n/** The tuples' nodes, indexed in order of first occurrence, with their stable colours. */\ninterface Partition {\n  readonly tuples: ReadonlyArray<Tuple>;\n  readonly nodes: ReadonlyArray<string>;\n  readonly colour: Uint32Array;\n  /** Per node: the indices of the tuples it occurs in. */\n  readonly byNode: ReadonlyArray<ReadonlyArray<number>>;\n  /** Per tuple position: the index of its node (>= 0), or -1 for a fixed atom. */\n  readonly nodeAt: Int32Array;\n}\n\n/** The number of distinct colours in a colouring. */\nconst countClasses = (c: Uint32Array): number => {\n  const sorted = c.toSorted();\n  return sorted.reduce((count, v, k) => (k === 0 || v !== sorted[k - 1] ? count + 1 : count), 0);\n};\n\n/**\n * Iterative colour refinement: a node's colour is repeatedly refined by the\n * (multiset of) tuples it occurs in, and its positions in them, until the\n * partition is stable.\n */\nconst refine = (tuples: ReadonlyArray<Tuple>): Partition => {\n  const index = MutableHashMap.empty<string, number>();\n  const nodes: Array<string> = [];\n  const byNode: Array<Array<number>> = [];\n  const fixed = MutableHashMap.empty<string, number>();\n  const nT = tuples.length;\n  // Per tuple position: node index (>= 0) or -1, and the fixed hash.\n  const nodeAt = new Int32Array(nT * 4);\n  const fixedAt = new Uint32Array(nT * 4);\n  // Per node: the tuples it occurs in, with the bitmask of its positions in each.\n  const occurrences: Array<Array<readonly [tuple: number, mask: number]>> = [];\n  tuples.forEach((t, ti) => {\n    // The distinct nodes of the tuple, in order, with their position masks.\n    const seen: Array<number> = [];\n    const masks: Array<number> = [];\n    t.forEach((a, k) => {\n      if (!isNode(a)) {\n        let h = fixed.backing.get(a);\n        if (h === undefined) {\n          h = hashString(a);\n          MutableHashMap.set(fixed, a, h);\n        }\n        nodeAt[ti * 4 + k] = -1;\n        fixedAt[ti * 4 + k] = h;\n        return;\n      }\n      let n = index.backing.get(a);\n      if (n === undefined) {\n        n = nodes.length;\n        MutableHashMap.set(index, a, n);\n        nodes.push(a);\n        byNode.push([]);\n        occurrences.push([]);\n      }\n      nodeAt[ti * 4 + k] = n;\n      const j = seen.indexOf(n);\n      if (j < 0) {\n        seen.push(n);\n        masks.push(1 << k);\n      } else masks[j] = (masks[j] ?? 0) | (1 << k);\n    });\n    seen.forEach((n, j) => {\n      byNode[n]?.push(ti);\n      occurrences[n]?.push([ti, masks[j] ?? 0]);\n    });\n  });\n  const nN = nodes.length;\n  let colour = Uint32Array.from(nodes, (a) => hashString(kindOf(a)));\n  let classes = countClasses(colour);\n  const tupleHash = new Uint32Array(nT);\n  const valueAt = (p: number): number => {\n    const n = nodeAt[p] ?? -1;\n    return n >= 0 ? (colour[n] ?? 0) : (fixedAt[p] ?? 0);\n  };\n  loop((round) => {\n    if (round > nN || classes >= nN) return false;\n    tupleHash.forEach((_, ti) => {\n      const at = ti * 4;\n      tupleHash[ti] = mix(\n        mix(mix(mix(7, valueAt(at)), valueAt(at + 1)), valueAt(at + 2)),\n        valueAt(at + 3),\n      );\n    });\n    const next = Uint32Array.from(occurrences, (occ, n) =>\n      mix(\n        colour[n] ?? 0,\n        occ.reduce((acc, [ti, mask]) => (acc + mix(tupleHash[ti] ?? 0, mask)) >>> 0, 0),\n      ),\n    );\n    const nextClasses = countClasses(next);\n    colour = next;\n    if (nextClasses === classes) return false;\n    classes = nextClasses;\n    return true;\n  });\n  return { tuples, nodes, colour, byNode, nodeAt };\n};\n\nconst tupleKey = (t: Tuple): string => t.join(SEP);\n\n/** Groups a partition's nodes (by index, in order) by their colour. */\nconst groupByColour = (p: Partition): MutableHashMap.MutableHashMap<number, Array<number>> => {\n  const groups = MutableHashMap.empty<number, Array<number>>();\n  p.colour.forEach((c, n) => {\n    const g = groups.backing.get(c);\n    if (g === undefined) MutableHashMap.set(groups, c, [n]);\n    else g.push(n);\n  });\n  return groups;\n};\n\nconst noNodes: ReadonlyArray<number> = [];\n\n/**\n * A renaming of the nodes of `a` to those of `b` under which the tuples are\n * the same, as `[node of a, node of b]` pairs: those mapped directly, in\n * order of first occurrence, then those found by backtracking.\n */\nconst bijectionTuples = (\n  a: ReadonlyArray<Tuple>,\n  b: ReadonlyArray<Tuple>,\n): Option.Option<ReadonlyArray<readonly [string, string]>> => {\n  if (a.length !== b.length) return Option.none();\n  const target = MutableHashMap.empty<string, boolean>();\n  b.forEach((t) => MutableHashMap.set(target, tupleKey(t), true));\n  const targets = target.backing;\n  const aNodes: Array<Tuple> = [];\n  const fixedFound = a.every((t) => {\n    if (!t.some(isNode)) return targets.has(tupleKey(t));\n    aNodes.push(t);\n    return true;\n  });\n  if (!fixedFound) return Option.none();\n  const bNodes = b.filter((t) => t.some(isNode));\n  if (aNodes.length !== bNodes.length) return Option.none();\n  if (Arr.isReadonlyArrayEmpty(aNodes)) return Option.some([]);\n\n  const pa = refine(aNodes);\n  const pb = refine(bNodes);\n  if (pa.nodes.length !== pb.nodes.length) return Option.none();\n  const groupsA = groupByColour(pa);\n  const groupsB = groupByColour(pb);\n  const candidatesOf = (n: number): ReadonlyArray<number> =>\n    groupsB.backing.get(pa.colour[n] ?? 0) ?? noNodes;\n  if (Iterable.some(groupsA, ([c, g]) => groupsB.backing.get(c)?.length !== g.length)) {\n    return Option.none();\n  }\n\n  // Per node of `a`: the index of the node of `b` it is mapped to, or -1.\n  const mapping = new Int32Array(pa.nodes.length).fill(-1);\n  const used = new Uint8Array(pb.nodes.length);\n  /** Position `p` of tuple `t` under the mapping (`''` while its node is unmapped). */\n  const mapped = (t: Tuple, p: number): string => {\n    const n = pa.nodeAt[p] ?? -1;\n    const atom = t[p & 3] ?? '';\n    if (n < 0) return atom;\n    const m = mapping[n] ?? -1;\n    return m < 0 ? '' : (pb.nodes[m] ?? '');\n  };\n  const consistent = (node: number): boolean =>\n    (pa.byNode[node] ?? noNodes).every((ti) => {\n      const t = pa.tuples[ti] ?? emptyTuple;\n      const at = ti * 4;\n      const s = mapped(t, at);\n      const p = mapped(t, at + 1);\n      const o = mapped(t, at + 2);\n      const g = mapped(t, at + 3);\n      // Tuples with a node still unmapped are checked once it is\n      if (s === '' || p === '' || o === '' || g === '') return true;\n      return targets.has(`${s}${SEP}${p}${SEP}${o}${SEP}${g}`);\n    });\n  // Nodes in singleton classes are mapped directly.\n  const direct: Array<number> = [];\n  const ambiguous: Array<number> = [];\n  pa.nodes.forEach((_, n) => {\n    const candidates = candidatesOf(n);\n    const only = candidates[0] ?? 0;\n    if (candidates.length === 1) {\n      mapping[n] = only;\n      used[only] = 1;\n      direct.push(n);\n    } else ambiguous.push(n);\n  });\n  if (!direct.every(consistent)) return Option.none();\n  // Iterative backtracking over the ambiguous nodes, smallest classes first.\n  const order = Arr.sort(\n    ambiguous,\n    Order.mapInput(\n      Order.Number,\n      (n: number) => groupsA.backing.get(pa.colour[n] ?? 0)?.length ?? 0,\n    ),\n  );\n  const next = new Int32Array(order.length);\n  let i = 0;\n  // The node being placed, its candidates, and whether one was found\n  let node = 0;\n  let candidates = noNodes;\n  let found = false;\n  const tryNext = (): boolean => {\n    const k = next[i] ?? 0;\n    if (k >= candidates.length) return false;\n    next[i] = k + 1;\n    const candidate = candidates[k] ?? 0;\n    if (used[candidate] === 1) return true;\n    mapping[node] = candidate;\n    used[candidate] = 1;\n    if (consistent(node)) {\n      found = true;\n      return false;\n    }\n    mapping[node] = -1;\n    used[candidate] = 0;\n    return true;\n  };\n  loop(() => {\n    if (i < 0 || i >= order.length) return false;\n    node = order[i] ?? 0;\n    const previous = mapping[node] ?? -1;\n    if (previous >= 0) {\n      mapping[node] = -1;\n      used[previous] = 0;\n    }\n    candidates = candidatesOf(node);\n    found = false;\n    loop(tryNext);\n    if (found) i++;\n    else {\n      next[i] = 0;\n      i--;\n    }\n    return true;\n  });\n  if (i !== order.length) return Option.none();\n  const pair = (n: number): readonly [string, string] => [\n    pa.nodes[n] ?? '',\n    pb.nodes[mapping[n] ?? 0] ?? '',\n  ];\n  return Option.some(Arr.appendAll(direct.map(pair), order.map(pair)));\n};\n\nconst emptyTuple: Tuple = ['', '', '', ''];\n\n/** Renders an internal `b:` / `v:` node key as `_:label` / `?name`. */\nconst renderNode = (a: string) => (a.startsWith('b:') ? `_:${a.slice(2)}` : `?${a.slice(2)}`);\n\n/**\n * Finds a renaming of blank nodes and variables from `self` to `that` under\n * which the two formulas are equal. Keys of the returned map are\n * `_:label` / `?name` of `self`, values those of `that` (nodes generated for\n * collections and nested formulas are omitted).\n *\n * @since 0.1.0\n * @category isomorphism\n */\nexport const bijection = (\n  self: Model.Formula,\n  that: Model.Formula,\n): Option.Option<ReadonlyMap<string, string>> =>\n  Option.map(bijectionTuples(flatten(self), flatten(that)), (pairs) => {\n    const out = MutableHashMap.empty<string, string>();\n    pairs.forEach(([k, v]) => {\n      if (!k.startsWith('l:') && !k.startsWith('f:'))\n        MutableHashMap.set(out, renderNode(k), renderNode(v));\n    });\n    return out.backing;\n  });\n\n/**\n * Whether two formulas are isomorphic: equal up to a consistent renaming of\n * blank nodes and variables, recursively through nested formulas.\n *\n * @since 0.1.0\n * @category isomorphism\n */\nexport const isomorphic: {\n  (that: Model.Formula): (self: Model.Formula) => boolean;\n  (self: Model.Formula, that: Model.Formula): boolean;\n} = dual(2, (self: Model.Formula, that: Model.Formula): boolean =>\n  Option.isSome(bijectionTuples(flatten(self), flatten(that))),\n);\n"],"mappings":"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"}

package/dist/Isomorphism-DvSfZXLR.d.mts

@@ -0,0 +1,37 @@
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import * as Option from "effect/Option";
+declare namespace Isomorphism_d_exports {
+  export { bijection, isomorphic, relabel };
+}
+/**
+ * Finds a blank node bijection from `self` to `that` under which the two
+ * datasets are equal, if one exists.
+ *
+ * @since 0.1.0
+ * @category isomorphism
+ */
+declare const bijection: (self: Dataset, that: Dataset) => Option.Option<ReadonlyMap<string, string>>;
+/**
+ * Whether two datasets are isomorphic: equal up to a consistent renaming of
+ * blank nodes.
+ *
+ * @since 0.1.0
+ * @category isomorphism
+ */
+declare const isomorphic: {
+  (that: Dataset): (self: Dataset) => boolean;
+  (self: Dataset, that: Dataset): boolean;
+};
+/**
+ * Relabels blank nodes in a dataset with fresh labels `prefix0`, `prefix1`,
+ * … in a deterministic order derived from their structural signatures.
+ *
+ * Isomorphic datasets without automorphic blank nodes yield identical
+ * results; this is not a full canonicalisation algorithm.
+ *
+ * @since 0.1.0
+ * @category isomorphism
+ */
+declare const relabel: (self: Dataset, prefix?: string) => Dataset;
+export { relabel as i, bijection as n, isomorphic as r, Isomorphism_d_exports as t };
+//# sourceMappingURL=Isomorphism-DvSfZXLR.d.mts.map

package/dist/Isomorphism.d.mts

@@ -0,0 +1,2 @@
+import { i as relabel, n as bijection, r as isomorphic } from "./Isomorphism-DvSfZXLR.mjs";
+export { bijection, isomorphic, relabel };

package/dist/Isomorphism.mjs

@@ -0,0 +1 @@
+export { n as bijection, r as isomorphic, i as relabel } from "./Isomorphism-BmqxhKyJ.mjs";