test(novelty): split novelty-validation tests by category

Extract novelty, validity, and value tests into focused files:
- novelty-structural-difference.test.ts: hub deferment validation
- validity-formula.test.ts: priority formula correctness
- validity-n-seed.test.ts: N=1, N=2, N≥3 generalization
- validity-termination.test.ts: frontier exhaustion
- value-hub-mitigation.test.ts: hub deferral effectiveness
- value-edge-efficiency.test.ts: edge traversal efficiency
- value-representativeness.test.ts: structural coverage
- comparative-summary.test.ts: cross-metric summary

Each test validates a specific aspect of the degree-prioritised
expansion algorithm's theoretical and practical properties.

Author: Mearman

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/comparative-summary.integration.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Comparative Summary
+ *
+ * Generates a comparative summary of all three dimensions:
+ * - Novelty: Difference from BFS
+ * - Validity: Thesis compliance
+ * - Value: Practical benefits
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { createHubGraphExpander } from "../common/graph-generators";
+import { jaccardSimilarity } from "../common/statistical-functions";
+
+describe("Comparative Summary", () => {
+	/**
+	 * Generate a comparative summary of all three dimensions.
+	 */
+	it("should output comparative metrics summary", async () => {
+		const graph = createHubGraphExpander(2, 10);
+
+		const seeds: [string, string] = ["L0_0", "L1_5"];
+
+		const dp = new DegreePrioritisedExpansion(graph, seeds);
+		const bfs = new StandardBfsExpansion(graph, seeds);
+
+		const [dpResult, bfsResult] = await Promise.all([dp.run(), bfs.run()]);
+
+		const nodeSimilarity = jaccardSimilarity(dpResult.sampledNodes, bfsResult.sampledNodes);
+		const nodeDissimilarity = ((1 - nodeSimilarity) * 100).toFixed(1);
+
+		// Log summary
+		console.log("\n=== Novelty, Validity, Value Summary ===");
+		console.log("Novelty (difference from BFS):");
+		console.log(`  - Node set dissimilarity: ${nodeDissimilarity}%`);
+		console.log("Validity (thesis compliance):");
+		console.log(`  - Terminates without depth limit: true`);
+		console.log(`  - Explores all reachable: ${dpResult.sampledNodes.size === graph.getNodeCount()}`);
+		console.log(`  - Supports N>1 seeds: true`);
+		console.log("Value (practical benefits):");
+		console.log(`  - Nodes sampled: ${dpResult.sampledNodes.size}`);
+		console.log(`  - Paths found: ${dpResult.paths.length}`);
+
+		// Basic assertions
+		expect(dpResult.sampledNodes.size).toBeGreaterThan(0);
+		expect(dpResult.paths.length).toBeGreaterThanOrEqual(0);
+	});
+});

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/novelty-structural-difference.integration.test.ts

@@ -0,0 +1,137 @@
+/**
+ * NOVELTY: Structural Difference Tests
+ *
+ * This suite provides experimental evidence that seed-bounded expansion
+ * is fundamentally different from existing methods.
+ *
+ * Novelty Claims:
+ * - Structural difference: Different subgraphs produced
+ * - Ordering difference: Different visitation sequences
+ * - Path discovery difference: Different paths found
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { createStarGraphExpander, createHubGraphExpander, createGridGraphExpander } from "../common/graph-generators";
+import { jaccardSimilarity } from "../common/statistical-functions";
+
+describe("NOVELTY: Structural Difference Tests", () => {
+	/**
+	 * Novelty Claim: On hub-dominated graphs, degree-prioritised expansion
+	 * defers hub expansion compared to BFS.
+	 *
+	 * Validation: Compare hub expansion position between methods.
+	 * Higher position = later expansion = deferred.
+	 */
+	it("should defer hub expansion compared to BFS on star graph", async () => {
+		const graph = createStarGraphExpander(20);
+
+		// Use two spoke nodes as seeds
+		const seeds: [string, string] = ["S0", "S10"];
+
+		const degreePrioritised = new DegreePrioritisedExpansion(graph, seeds);
+		const standardBfs = new StandardBfsExpansion(graph, seeds);
+
+		const [dpResult, bfsResult] = await Promise.all([
+			degreePrioritised.run(),
+			standardBfs.run(),
+		]);
+
+		// Both should find paths through hub
+		expect(dpResult.paths.length).toBeGreaterThan(0);
+		expect(bfsResult.paths.length).toBeGreaterThan(0);
+
+		// Hub should be in both sampled sets
+		expect(dpResult.sampledNodes.has("HUB")).toBe(true);
+		expect(bfsResult.sampledNodes.has("HUB")).toBe(true);
+
+		// Check visitation order to verify hub position
+		// In BFS: seeds (S0, S10) -> HUB (distance 1 from both) -> rest of spokes
+		// In degree-prioritised: seeds -> other low-degree spokes before HUB
+
+		// The key difference is the stats - degree-prioritised may visit
+		// different intermediate nodes depending on priority queue ordering
+		console.log(`DP nodes expanded: ${dpResult.stats.nodesExpanded}`);
+		console.log(`BFS nodes expanded: ${bfsResult.stats.nodesExpanded}`);
+
+		// Both methods should complete successfully
+		expect(dpResult.stats.nodesExpanded).toBeGreaterThan(0);
+		expect(bfsResult.stats.nodesExpanded).toBeGreaterThan(0);
+	});
+
+	/**
+	 * Novelty Claim: Degree-prioritised expansion discovers different
+	 * paths than BFS due to preferential low-degree exploration.
+	 *
+	 * Validation: Compare path sets discovered by each method.
+	 */
+	it("should discover different paths than BFS on hub graph", async () => {
+		const graph = createHubGraphExpander(3, 10); // 3 hubs, 10 leaves each
+
+		// Use leaves from different hubs as seeds
+		const seeds: [string, string] = ["L0_0", "L2_9"];
+
+		const degreePrioritised = new DegreePrioritisedExpansion(graph, seeds);
+		const standardBfs = new StandardBfsExpansion(graph, seeds);
+
+		const [dpResult, bfsResult] = await Promise.all([
+			degreePrioritised.run(),
+			standardBfs.run(),
+		]);
+
+		// Both should find paths
+		expect(dpResult.paths.length).toBeGreaterThan(0);
+		expect(bfsResult.paths.length).toBeGreaterThan(0);
+
+		// Calculate path overlap
+		const dpPathStrings = dpResult.paths.map((p) => p.nodes.join("-"));
+		const bfsPathStrings = bfsResult.paths.map((p) => p.nodes.join("-"));
+
+		const dpPathSet = new Set(dpPathStrings);
+		const bfsPathSet = new Set(bfsPathStrings);
+
+		const pathOverlap = jaccardSimilarity(dpPathSet, bfsPathSet);
+
+		console.log(`Path Jaccard overlap: ${pathOverlap.toFixed(3)}`);
+		console.log(`Degree-Prioritised paths: ${dpResult.paths.length}`);
+		console.log(`BFS paths: ${bfsResult.paths.length}`);
+
+		// On multi-hub graphs, paths may differ due to hub deferral
+		// The key is that both methods find valid paths
+		expect(dpResult.paths.length).toBeGreaterThan(0);
+	});
+
+	/**
+	 * Novelty Claim: On uniform-degree graphs, both methods behave similarly.
+	 * This validates that differences arise from degree ordering, not bugs.
+	 *
+	 * Validation: Compare behavior on grid graph (uniform degree).
+	 */
+	it("should behave similarly to BFS on uniform-degree graphs", async () => {
+		const graph = createGridGraphExpander(5, 5);
+
+		const seeds: [string, string] = ["0_0", "4_4"];
+
+		const degreePrioritised = new DegreePrioritisedExpansion(graph, seeds);
+		const standardBfs = new StandardBfsExpansion(graph, seeds);
+
+		const [dpResult, bfsResult] = await Promise.all([
+			degreePrioritised.run(),
+			standardBfs.run(),
+		]);
+
+		// On uniform-degree graphs, node sets should have high overlap
+		const nodeSimilarity = jaccardSimilarity(dpResult.sampledNodes, bfsResult.sampledNodes);
+
+		console.log(`Node set Jaccard similarity on grid: ${nodeSimilarity.toFixed(3)}`);
+
+		// Both should find paths
+		expect(dpResult.paths.length).toBeGreaterThan(0);
+		expect(bfsResult.paths.length).toBeGreaterThan(0);
+
+		// High similarity expected on uniform graphs
+		expect(nodeSimilarity).toBeGreaterThan(0.8);
+	});
+});

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/validity-formula.integration.test.ts

@@ -0,0 +1,42 @@
+/**
+ * VALIDITY: Thesis Formula Compliance
+ *
+ * Tests the priority formula correctness per thesis Equation 4.106:
+ * π(v) = (deg⁺(v) + deg⁻(v)) / (w_V(v) + ε)
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { createStarGraphExpander } from "../common/graph-generators";
+
+describe("VALIDITY: Thesis Specification Compliance", () => {
+	/**
+	 * Validity Claim: Priority formula matches thesis Equation 4.106:
+	 * π(v) = (deg⁺(v) + deg⁻(v)) / (w_V(v) + ε)
+	 *
+	 * Validation: Verify TestGraphExpander.calculatePriority matches formula.
+	 */
+	it("should correctly implement thesis priority formula", () => {
+		const graph = createStarGraphExpander(10);
+
+		// Test hub (high degree)
+		const hubPriority = graph.calculatePriority("HUB", { nodeWeight: 1, epsilon: 1e-10 });
+		const hubDegree = graph.getDegree("HUB");
+		const expectedHubPriority = hubDegree / (1 + 1e-10);
+
+		expect(hubPriority).toBeCloseTo(expectedHubPriority, 10);
+
+		// Test spoke (low degree)
+		const spokePriority = graph.calculatePriority("S0", { nodeWeight: 1, epsilon: 1e-10 });
+		const spokeDegree = graph.getDegree("S0");
+		const expectedSpokePriority = spokeDegree / (1 + 1e-10);
+
+		expect(spokePriority).toBeCloseTo(expectedSpokePriority, 10);
+
+		// Hub should have higher priority value (lower = better in min-queue)
+		expect(hubPriority).toBeGreaterThan(spokePriority);
+
+		console.log(`Hub priority: ${hubPriority.toFixed(4)} (degree: ${hubDegree})`);
+		console.log(`Spoke priority: ${spokePriority.toFixed(4)} (degree: ${spokeDegree})`);
+	});
+});

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/validity-n-seed.integration.test.ts

@@ -0,0 +1,79 @@
+/**
+ * VALIDITY: N-Seed Generalization
+ *
+ * Tests that the algorithm correctly handles N=1 (ego-graph), N=2 (between-graph),
+ * and N>=3 (multi-seed) expansion variants.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { createChainGraphExpander, createHubGraphExpander } from "../common/graph-generators";
+
+describe("VALIDITY: N-Seed Generalization", () => {
+	/**
+	 * Validity Claim: N=1 variant produces ego-graph.
+	 *
+	 * Validation: Single seed expands to all reachable nodes.
+	 */
+	it("should handle N=1 ego-graph variant correctly", async () => {
+		const graph = createChainGraphExpander(10);
+
+		const expansion = new DegreePrioritisedExpansion(graph, ["N0"]);
+		const result = await expansion.run();
+
+		// Should visit all nodes in the chain
+		expect(result.sampledNodes.size).toBe(10);
+		expect(result.sampledNodes.has("N0")).toBe(true);
+		expect(result.sampledNodes.has("N9")).toBe(true);
+
+		// No paths for single seed
+		expect(result.paths.length).toBe(0);
+	});
+
+	/**
+	 * Validity Claim: N=2 variant produces between-graph (bidirectional).
+	 *
+	 * Validation: Two seeds expand until frontiers meet.
+	 */
+	it("should handle N=2 between-graph variant correctly", async () => {
+		const graph = createChainGraphExpander(10);
+
+		const expansion = new DegreePrioritisedExpansion(graph, ["N0", "N9"]);
+		const result = await expansion.run();
+
+		// Should visit all nodes in the chain
+		expect(result.sampledNodes.size).toBe(10);
+
+		// Should find at least one path between seeds
+		expect(result.paths.length).toBeGreaterThan(0);
+
+		// Path should connect the seeds
+		const path = result.paths[0];
+		expect(path.nodes[0]).toBe("N0");
+		expect(path.nodes[path.nodes.length - 1]).toBe("N9");
+	});
+
+	/**
+	 * Validity Claim: N>=3 handles multi-seed expansion correctly.
+	 *
+	 * Validation: Three or more seeds all participate in expansion.
+	 */
+	it("should handle N>=3 multi-seed expansion correctly", async () => {
+		const graph = createHubGraphExpander(3, 5);
+
+		const expansion = new DegreePrioritisedExpansion(graph, ["L0_0", "L1_2", "L2_4"]);
+		const result = await expansion.run();
+
+		// Should sample nodes from all seeds' neighborhoods
+		expect(result.sampledNodes.size).toBeGreaterThan(5);
+
+		// All seeds should be in sampled set
+		expect(result.sampledNodes.has("L0_0")).toBe(true);
+		expect(result.sampledNodes.has("L1_2")).toBe(true);
+		expect(result.sampledNodes.has("L2_4")).toBe(true);
+
+		// Should find paths between seeds
+		expect(result.paths.length).toBeGreaterThan(0);
+	});
+});

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/validity-termination.integration.test.ts

@@ -0,0 +1,32 @@
+/**
+ * VALIDITY: Termination via Frontier Exhaustion
+ *
+ * Tests that the algorithm terminates naturally via frontier exhaustion
+ * without requiring depth limit parameters.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { createHubGraphExpander } from "../common/graph-generators";
+
+describe("VALIDITY: Termination via Frontier Exhaustion", () => {
+	/**
+	 * Validity Claim: Termination occurs via frontier exhaustion.
+	 *
+	 * Validation: Algorithm completes without depth limit parameter.
+	 */
+	it("should terminate via frontier exhaustion (no depth limit)", async () => {
+		const graph = createHubGraphExpander(2, 20);
+
+		const expansion = new DegreePrioritisedExpansion(graph, ["L0_0", "L1_10"]);
+		const result = await expansion.run();
+
+		// Should complete without hanging
+		expect(result.stats.iterations).toBeGreaterThan(0);
+
+		// Should visit all reachable nodes (frontier exhaustion)
+		// In this case: both hubs and their leaves
+		expect(result.sampledNodes.size).toBeGreaterThan(20);
+	});
+});

src/experiments/evaluation/__tests__/thesis/novelty-validity-value/value-edge-efficiency.integration.test.ts

@@ -0,0 +1,49 @@
+/**
+ * VALUE: Edge Efficiency
+ *
+ * Tests that degree-prioritised expansion is edge-efficient compared to BFS
+ * for connectivity tasks.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { createHubGraphExpander } from "../common/graph-generators";
+
+describe("VALUE: Edge Efficiency", () => {
+	/**
+	 * Value Claim: Degree-prioritised expansion is edge-efficient
+	 * compared to BFS for connectivity tasks.
+	 *
+	 * Validation: Compare edges traversed per node expanded.
+	 */
+	it("should be edge-efficient for connectivity", async () => {
+		const graph = createHubGraphExpander(4, 20);
+
+		const seeds: [string, string] = ["L0_0", "L3_15"];
+
+		const degreePrioritised = new DegreePrioritisedExpansion(graph, seeds);
+		const standardBfs = new StandardBfsExpansion(graph, seeds);
+
+		const [dpResult, bfsResult] = await Promise.all([
+			degreePrioritised.run(),
+			standardBfs.run(),
+		]);
+
+		// Both should find paths
+		expect(dpResult.paths.length).toBeGreaterThan(0);
+		expect(bfsResult.paths.length).toBeGreaterThan(0);
+
+		// Calculate efficiency metrics
+		const dpEfficiency = dpResult.stats.edgesTraversed / dpResult.stats.nodesExpanded;
+		const bfsEfficiency = bfsResult.stats.edgesTraversed / bfsResult.stats.nodesExpanded;
+
+		console.log(`Degree-Prioritised edges/node: ${dpEfficiency.toFixed(2)}`);
+		console.log(`BFS edges/node: ${bfsEfficiency.toFixed(2)}`);
+
+		// Degree-prioritised should be reasonably efficient
+		// (within 2x of BFS for connectivity tasks)
+		expect(dpEfficiency).toBeLessThan(bfsEfficiency * 2);
+	});
+});