test,bench: exercise the real lattice engine, not the compat shim (#27)

The benches and property tests that shipped in #26 only drove the IO-free
`affine` shim (println-only build_lattice/query_lattice), so they measured and
tested nothing about the actual algorithms. Re-point both at the real engine.

benches (criterion): condense (parametric SCC, ~37..2.3k nodes), zoom over a
deep containment forest, meet over deep chains, precedes end-to-end (condenses
internally per call), and ingest of this repo's own src/ tree.

property tests (proptest): quantify the laws the mod.rs fixtures only
spot-check -- P2a condensation is always a DAG with a well-formed component
map; P1a precedes is reflexive; P4 zoom is sound AND complete vs. an
independent descendant oracle; P1b meet is commutative and a genuine common
ancestor. Plus robustness: the engine never panics on wild input with cyclic
parents (exercises the ancestor-chain guard), and one retained proptest keeps
the shim's arbitrary-string resilience.

Verified: clippy --all-targets zero warnings; cargo test (13 + 6 properties)
green; cargo bench --no-run compiles.

https://claude.ai/code/session_01JNCDaWMB8NV6nAPrvmTg4w

Author: hyperpolymath

benches/git_reticulator_bench.rs

@@ -2,117 +2,115 @@
 // Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
 //
 // benches/git_reticulator_bench.rs
-// Criterion benchmarks for git-reticulator.
+// Criterion benchmarks for the git-reticulator lattice engine.
 //
-// Baselines measured:
-//   B1 - build_lattice with a short repo path and db URI
-//   B2 - query_lattice with a short zoom node and db URI
-//   B3 - build_lattice with a long (4 KiB) repo path
-//   B4 - query_lattice with a long (4 KiB) zoom node
-//   B5 - Sequential build-then-query pipeline
+// These measure the *real* algorithmic core (PROOF-NEEDS P1/P2/P4) rather than
+// the IO-free `affine` compat shim, so the numbers are behavioural baselines
+// for the algorithms a future AffineScript core must match:
+//   engine/condense  - Kosaraju SCC condensation, parametric over lattice size
+//   engine/zoom      - LOD descendant selection on a large containment forest
+//   engine/meet      - lowest-common-ancestor over deep ancestor chains
+//   engine/precedes  - node partial-order query (condenses internally per call)
+//   engine/ingest    - std-only filesystem walk of this repo's own `src/` tree
 
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
-use git_reticulator::lattice::affine;
+use git_reticulator::ingest;
+use git_reticulator::lattice::{Lattice, LatticeBuilder, SemanticLevel};
 
-// ---------------------------------------------------------------------------
-// B1: build_lattice — short inputs
-// ---------------------------------------------------------------------------
-fn bench_build_lattice_short(c: &mut Criterion) {
-    c.bench_function("build_lattice/short", |b| {
-        b.iter(|| {
-            affine::build_lattice(
-                black_box("github.com/hyperpolymath/git-reticulator"),
-                black_box("postgres://localhost:5432/reticulator"),
-            )
-        })
-    });
+/// Build a synthetic lattice of `modules` modules, each with `files_per` files,
+/// each with `defs_per` definitions (Module ⊃ File ⊃ Definition). Definitions
+/// are wired into a forward call-chain with periodic back-edges, so the SCC
+/// condensation has genuine cycles to collapse rather than a trivial DAG.
+fn synthetic(modules: usize, files_per: usize, defs_per: usize) -> Lattice {
+    let mut b = LatticeBuilder::new();
+    let mut defs = Vec::new();
+    for mi in 0..modules {
+        let m = b.add_keyword(
+            format!("mod{mi}"),
+            format!("/mod{mi}"),
+            SemanticLevel::Module,
+            None,
+        );
+        for fi in 0..files_per {
+            let f = b.add_keyword(
+                format!("file{mi}_{fi}"),
+                format!("/mod{mi}/file{fi}.rs"),
+                SemanticLevel::File,
+                Some(m),
+            );
+            for di in 0..defs_per {
+                let d = b.add_keyword(
+                    format!("def{mi}_{fi}_{di}"),
+                    format!("/mod{mi}/file{fi}.rs"),
+                    SemanticLevel::Definition,
+                    Some(f),
+                );
+                defs.push(d);
+            }
+        }
+    }
+    // forward call chain over every definition
+    for w in defs.windows(2) {
+        b.add_relationship(w[0], w[1], 1.0, "calls".into());
+    }
+    // periodic back-edges (every 4th def calls back 3 steps) → real SCCs
+    let mut i = 3;
+    while i < defs.len() {
+        b.add_relationship(defs[i], defs[i - 3], 1.0, "calls".into());
+        i += 4;
+    }
+    b.build()
 }
 
-// ---------------------------------------------------------------------------
-// B2: query_lattice — short inputs
-// ---------------------------------------------------------------------------
-fn bench_query_lattice_short(c: &mut Criterion) {
-    c.bench_function("query_lattice/short", |b| {
-        b.iter(|| {
-            affine::query_lattice(
-                black_box("module::lattice::affine"),
-                black_box("postgres://localhost:5432/reticulator"),
-            )
-        })
-    });
+fn bench_condense(c: &mut Criterion) {
+    let mut group = c.benchmark_group("engine/condense");
+    for &scale in &[1usize, 4, 16, 64] {
+        let lat = synthetic(scale, 4, 8); // ~37 nodes per scale unit
+        let n = lat.len();
+        group.bench_with_input(BenchmarkId::from_parameter(n), &lat, |b, lat| {
+            b.iter(|| black_box(lat.condense()))
+        });
+    }
+    group.finish();
 }
 
-// ---------------------------------------------------------------------------
-// B3: build_lattice — long inputs (4 KiB)
-// ---------------------------------------------------------------------------
-fn bench_build_lattice_long(c: &mut Criterion) {
-    let long_repo: String = "repo/".repeat(819); // ~4 KiB
-    let long_db:   String = "db://".repeat(819);
-
-    c.bench_function("build_lattice/long_4kib", |b| {
-        b.iter(|| affine::build_lattice(black_box(&long_repo), black_box(&long_db)))
+fn bench_zoom(c: &mut Criterion) {
+    let lat = synthetic(16, 8, 16); // ~2.2k nodes, deep containment forest
+    c.bench_function("engine/zoom_definitions_from_root", |b| {
+        b.iter(|| black_box(lat.zoom(black_box(0), SemanticLevel::Definition)))
     });
 }
 
-// ---------------------------------------------------------------------------
-// B4: query_lattice — long inputs (4 KiB)
-// ---------------------------------------------------------------------------
-fn bench_query_lattice_long(c: &mut Criterion) {
-    let long_node: String = "node::".repeat(682); // ~4 KiB
-    let long_db:   String = "db://".repeat(819);
-
-    c.bench_function("query_lattice/long_4kib", |b| {
-        b.iter(|| affine::query_lattice(black_box(&long_node), black_box(&long_db)))
+fn bench_meet(c: &mut Criterion) {
+    let lat = synthetic(8, 8, 16);
+    let last = lat.len() - 1;
+    c.bench_function("engine/meet_across_forest", |b| {
+        b.iter(|| black_box(lat.meet(black_box(1), black_box(last))))
     });
 }
 
-// ---------------------------------------------------------------------------
-// B5: Pipeline — build followed immediately by query
-// ---------------------------------------------------------------------------
-fn bench_pipeline(c: &mut Criterion) {
-    c.bench_function("pipeline/build_then_query", |b| {
-        b.iter(|| {
-            affine::build_lattice(
-                black_box("pipeline-repo"),
-                black_box("pipeline://db"),
-            );
-            affine::query_lattice(
-                black_box("pipeline-node"),
-                black_box("pipeline://db"),
-            );
-        })
+fn bench_precedes(c: &mut Criterion) {
+    // precedes() condenses internally on every call — bench that end-to-end cost.
+    let lat = synthetic(4, 4, 8);
+    let last = lat.len() - 1;
+    c.bench_function("engine/precedes_end_to_end", |b| {
+        b.iter(|| black_box(lat.precedes(black_box(0), black_box(last))))
     });
 }
 
-// ---------------------------------------------------------------------------
-// B6: Parametric — varying input lengths
-// ---------------------------------------------------------------------------
-fn bench_build_lattice_parametric(c: &mut Criterion) {
-    let mut group = c.benchmark_group("build_lattice/by_input_length");
-
-    for size in [8usize, 64, 256, 1024, 4096] {
-        let repo = "x".repeat(size);
-        let db   = "d".repeat(size);
-        group.bench_with_input(
-            BenchmarkId::from_parameter(size),
-            &(repo, db),
-            |b, (r, d)| b.iter(|| affine::build_lattice(black_box(r), black_box(d))),
-        );
-    }
-
-    group.finish();
+fn bench_ingest(c: &mut Criterion) {
+    // Real fixture: this repo's own source tree (always present in-tree).
+    c.bench_function("engine/ingest_src_tree", |b| {
+        b.iter(|| black_box(ingest::from_path(black_box("src"))))
+    });
 }
 
-// ---------------------------------------------------------------------------
-// Criterion entry points
-// ---------------------------------------------------------------------------
 criterion_group!(
     benches,
-    bench_build_lattice_short,
-    bench_query_lattice_short,
-    bench_build_lattice_long,
-    bench_query_lattice_long,
-    bench_pipeline,
-    bench_build_lattice_parametric,
+    bench_condense,
+    bench_zoom,
+    bench_meet,
+    bench_precedes,
+    bench_ingest,
 );
 criterion_main!(benches);