quantum-spherifier 1.0.0

package/src/modules/QuantumKnowledgeGraph.js

@@ -0,0 +1,888 @@
+/**
+ * QuantumKnowledgeGraph.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Domain knowledge graph for quantum computing research. Tracks:
+ *   - Concepts (qubit modalities, QEC codes, algorithms, simulation methods)
+ *   - Their relationships (depends-on, enables, contradicts, improves, ...)
+ *   - Confidence scores and citation links to archived documents
+ *   - Resource-feasibility annotations (current / near-term / mid-term / far-term)
+ *
+ * The graph is seeded with the REAL state of quantum computing as of 2026:
+ *   - IBM Condor (1,121 superconducting qubits), Heron (133 qubits, tunable couplers)
+ *   - Google Willow (105 qubits, below-threshold QEC demonstrated, exponential suppression)
+ *   - IonQ Forte Enterprise (36 algorithmic qubits), Quantinuum H2 (56 trapped ions)
+ *   - QuEra Aquila (256 neutral atoms), Atom Computing (1,180 neutral atoms)
+ *   - PsiQuantum (photonic, targeting 1M qubits), Xanadu Borealis (216 squeezed modes)
+ *   - Microsoft Majorana 1 (topological qubit chip, 2024 announcement)
+ *
+ * Four research lines are encoded as top-level concept clusters:
+ *   1. Quantum Error Correction (QEC)
+ *   2. New qubit modalities
+ *   3. Quantum algorithms
+ *   4. Molecular simulation
+ *
+ * Used by:
+ *   - HypothesisGenerator (to find under-explored regions)
+ *   - ResourceFeasibilityChecker (to anchor claims to known hardware)
+ *   - PatentDraftAssistant (to verify novelty against prior art in the graph)
+ *   - ResearchLineRouter (to dispatch cycles to the appropriate research line)
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { v4 as uuidv4 } from 'uuid';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const RELATION_TYPES = Object.freeze([
+  'depends_on',
+  'enables',
+  'contradicts',
+  'improves',
+  'measured_by',
+  'qubit_modality_for',
+  'corrects',
+  'implements',
+  'simulates',
+  'decoheres_via',
+  'patent_prior_art_for',
+  'cross_links',      // quantum-spherifier: ensures nothing stays isolated
+]);
+
+const FEASIBILITY_TIERS = Object.freeze([
+  'current',         // demonstrated on real hardware today
+  'near_term',       // 1-3 years with current investments
+  'mid_term',        // 3-8 years, requires new infrastructure
+  'long_term',       // 8-20 years
+  'speculative',     // >20 years or unproven physics
+]);
+
+export const RESEARCH_LINES = Object.freeze([
+  'quantum_error_correction',
+  'new_qubit_modalities',
+  'quantum_algorithms',
+  'molecular_simulation',
+]);
+
+export class QuantumKnowledgeGraph extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.storagePath = opts.storagePath ?? join(process.cwd(), 'data', 'knowledge_graph.json');
+    this.nodes = new Map();
+    this.edges = new Map();
+    this.initialized = false;
+  }
+
+  async init() {
+    if (this.initialized) return;
+    if (existsSync(this.storagePath)) {
+      try {
+        const raw = readFileSync(this.storagePath, 'utf8');
+        const data = JSON.parse(raw);
+        for (const n of data.nodes ?? []) this.nodes.set(n.id, n);
+        for (const e of data.edges ?? []) this.edges.set(e.id, e);
+        this.emit('loaded', { nodes: this.nodes.size, edges: this.edges.size });
+      } catch (err) {
+        this.emit('error', { stage: 'load', error: err.message });
+        this._seedBaselineKnowledge();
+      }
+    } else {
+      this._seedBaselineKnowledge();
+      await this.persist();
+    }
+    this.initialized = true;
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────────
+
+  addNode(opts = {}) {
+    const id = opts.id ?? uuidv4();
+    const node = {
+      id,
+      label: opts.label ?? id,
+      kind: opts.kind ?? 'concept',
+      researchLine: RESEARCH_LINES.includes(opts.researchLine) ? opts.researchLine : null,
+      description: opts.description ?? '',
+      feasibility: FEASIBILITY_TIERS.includes(opts.feasibility) ? opts.feasibility : 'speculative',
+      tags: Array.isArray(opts.tags) ? opts.tags : [],
+      citations: Array.isArray(opts.citations) ? opts.citations : [],
+      parameters: opts.parameters ?? {},
+      confidence: typeof opts.confidence === 'number' ? opts.confidence : 0.5,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    };
+    this.nodes.set(id, node);
+    this.emit('nodeAdded', node);
+    return node;
+  }
+
+  addEdge(opts = {}) {
+    const id = opts.id ?? uuidv4();
+    if (!this.nodes.has(opts.from) || !this.nodes.has(opts.to)) {
+      throw new Error(`Edge endpoints must exist: from=${opts.from} to=${opts.to}`);
+    }
+    const edge = {
+      id,
+      from: opts.from,
+      to: opts.to,
+      type: RELATION_TYPES.includes(opts.type) ? opts.type : 'depends_on',
+      weight: typeof opts.weight === 'number' ? opts.weight : 0.5,
+      evidence: Array.isArray(opts.evidence) ? opts.evidence : [],
+      createdAt: Date.now(),
+    };
+    this.edges.set(id, edge);
+    this.emit('edgeAdded', edge);
+    return edge;
+  }
+
+  /** Find concepts with low connectivity — under-explored regions. */
+  findUnderExplored(limit = 10, researchLine = null) {
+    const degrees = new Map();
+    for (const node of this.nodes.values()) {
+      if (researchLine && node.researchLine !== researchLine) continue;
+      degrees.set(node.id, 0);
+    }
+    for (const edge of this.edges.values()) {
+      if (degrees.has(edge.from)) degrees.set(edge.from, degrees.get(edge.from) + 1);
+      if (degrees.has(edge.to)) degrees.set(edge.to, degrees.get(edge.to) + 1);
+    }
+    const sorted = [...degrees.entries()]
+      .sort((a, b) => a[1] - b[1])
+      .slice(0, limit)
+      .map(([id, deg]) => ({ node: this.nodes.get(id), degree: deg }));
+    return sorted;
+  }
+
+  /** Two-hop neighbours of a node — used for hypothesis generation. */
+  neighbourhood(nodeId, maxDepth = 2) {
+    if (!this.nodes.has(nodeId)) return [];
+    const visited = new Set([nodeId]);
+    const frontier = [nodeId];
+    const result = [];
+    for (let depth = 0; depth < maxDepth; depth++) {
+      const nextFrontier = [];
+      for (const id of frontier) {
+        for (const edge of this.edges.values()) {
+          let neighbourId = null;
+          if (edge.from === id && !visited.has(edge.to)) neighbourId = edge.to;
+          else if (edge.to === id && !visited.has(edge.from)) neighbourId = edge.from;
+          if (neighbourId) {
+            visited.add(neighbourId);
+            nextFrontier.push(neighbourId);
+            result.push({ node: this.nodes.get(neighbourId), depth: depth + 1, viaEdge: edge });
+          }
+        }
+      }
+      frontier.length = 0;
+      frontier.push(...nextFrontier);
+    }
+    return result;
+  }
+
+  /** Return nodes belonging to a given research line. */
+  byResearchLine(line) {
+    return [...this.nodes.values()].filter(n => n.researchLine === line);
+  }
+
+  /** Quick text search over node labels and descriptions. */
+  search(query) {
+    const q = (query ?? '').toLowerCase().trim();
+    if (!q) return [];
+    const results = [];
+    for (const node of this.nodes.values()) {
+      const haystack = `${node.label} ${node.description} ${node.tags.join(' ')}`.toLowerCase();
+      if (haystack.includes(q)) results.push(node);
+    }
+    return results;
+  }
+
+  /** Build a Mermaid graph string for visualisation. */
+  toMermaid(maxNodes = 60, researchLine = null) {
+    const lines = ['graph TD'];
+    const nodesToShow = (researchLine
+      ? this.byResearchLine(researchLine)
+      : [...this.nodes.values()]
+    ).slice(0, maxNodes);
+    const ids = new Set(nodesToShow.map(n => n.id));
+    for (const node of nodesToShow) {
+      const safe = node.id.replace(/[^a-zA-Z0-9_]/g, '_');
+      const label = node.label.replace(/"/g, "'");
+      lines.push(`  ${safe}["${label}"]`);
+    }
+    const edgeArrows = {
+      depends_on: '-->',
+      enables: '==>',
+      contradicts: '--x',
+      improves: '-->',
+      measured_by: '-->',
+      qubit_modality_for: '-->',
+      corrects: '==>',
+      implements: '-->',
+      simulates: '-->',
+      decoheres_via: '-.->',
+      patent_prior_art_for: '-.->',
+      cross_links: '~~~',
+    };
+    for (const edge of this.edges.values()) {
+      if (!ids.has(edge.from) || !ids.has(edge.to)) continue;
+      const a = edge.from.replace(/[^a-zA-Z0-9_]/g, '_');
+      const b = edge.to.replace(/[^a-zA-Z0-9_]/g, '_');
+      const arrow = edgeArrows[edge.type] ?? '-->';
+      lines.push(`  ${a} ${arrow}|${edge.type}| ${b}`);
+    }
+    return lines.join('\n');
+  }
+
+  async persist() {
+    const dir = dirname(this.storagePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const data = {
+      version: '1.0',
+      updatedAt: Date.now(),
+      nodes: [...this.nodes.values()],
+      edges: [...this.edges.values()],
+    };
+    writeFileSync(this.storagePath, JSON.stringify(data, null, 2));
+    this.emit('persisted', { path: this.storagePath });
+  }
+
+  stats() {
+    const byLine = {};
+    for (const line of RESEARCH_LINES) byLine[line] = this.byResearchLine(line).length;
+    return {
+      nodes: this.nodes.size,
+      edges: this.edges.size,
+      relationTypes: RELATION_TYPES.length,
+      feasibilityTiers: FEASIBILITY_TIERS.length,
+      byResearchLine: byLine,
+    };
+  }
+
+  // ── Seed baseline knowledge — real state of quantum computing (2026) ──────
+
+  _seedBaselineKnowledge() {
+    // ═══════════════════════════════════════════════════════════════════════
+    // HARDWARE ANCHORS — real machines that exist or are under construction
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'hw_ibm_condor',
+      label: 'IBM Condor (1,121 qubits)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'IBM\'s 1,121-superconducting-qubit processor (2023). Demonstrated heavy-hex topology; did not achieve quantum advantage but proved cryogenic control at kilo-qubit scale.',
+      feasibility: 'current',
+      tags: ['superconducting', 'transmon', 'heavy_hex', 'IBM'],
+      parameters: { qubitCount: 1121, modality: 'superconducting_transmon', topology: 'heavy_hex', gate2qFidelity: 0.995, T1_us: 300 },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'hw_ibm_heron',
+      label: 'IBM Heron (133 qubits, tunable couplers)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'IBM\'s Heron processor (2023-2024) with tunable couplers; 133 qubits, improved 2-qubit gate fidelity ~99.7%. Basis for IBM Quantum System Two.',
+      feasibility: 'current',
+      tags: ['superconducting', 'tunable_coupler', 'IBM'],
+      parameters: { qubitCount: 133, modality: 'superconducting', gate2qFidelity: 0.997, T1_us: 500 },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'hw_google_willow',
+      label: 'Google Willow (105 qubits, below-threshold QEC)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Google\'s Willow chip (Dec 2024) demonstrated exponential error suppression below the surface-code threshold. First time more qubits reduced errors. 105 qubits, distance-7 surface code.',
+      feasibility: 'current',
+      tags: ['superconducting', 'surface_code', 'below_threshold', 'Google'],
+      parameters: { qubitCount: 105, modality: 'superconducting', gate2qFidelity: 0.998, codeDistance: 7, errorSuppression: 'exponential' },
+      confidence: 0.97,
+    });
+    this.addNode({
+      id: 'hw_ionq_forte',
+      label: 'IonQ Forte Enterprise (36 algorithmic qubits)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'IonQ trapped-ion system; 36 algorithmic qubits (#AQ). All-to-all connectivity, long coherence (>10s), high-fidelity 2-qubit gates (~99.6%).',
+      feasibility: 'current',
+      tags: ['trapped_ion', 'ytterbium', 'all_to_all', 'IonQ'],
+      parameters: { algorithmicQubits: 36, modality: 'trapped_ion', gate2qFidelity: 0.996, T1_s: 10, connectivity: 'all_to_all' },
+      confidence: 0.93,
+    });
+    this.addNode({
+      id: 'hw_quantinuum_h2',
+      label: 'Quantinuum H2 (56 trapped ions)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Quantinuum H2 trapped-ion quantum computer; 56 fully-connected qubits, 99.87% 2-qubit gate fidelity. Demonstrated magic state distillation and non-Abelian topological states.',
+      feasibility: 'current',
+      tags: ['trapped_ion', 'barium', 'all_to_all', 'Quantinuum'],
+      parameters: { qubitCount: 56, modality: 'trapped_ion', gate2qFidelity: 0.9987, T1_s: 100, connectivity: 'all_to_all' },
+      confidence: 0.94,
+    });
+    this.addNode({
+      id: 'hw_quera_aquila',
+      label: 'QuEra Aquila (256 neutral atoms)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'QuEra\'s neutral-atom analog quantum simulator; 256 rubidium atoms, programmable Rydberg arrays. Available via AWS Braket.',
+      feasibility: 'current',
+      tags: ['neutral_atom', 'rydberg', 'rubidium', 'QuEra'],
+      parameters: { qubitCount: 256, modality: 'neutral_atom', gate2qFidelity: 0.98, T1_s: 1.5, programmableGeometry: true },
+      confidence: 0.90,
+    });
+    this.addNode({
+      id: 'hw_atom_computing',
+      label: 'Atom Computing (1,180 neutral atoms)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Atom Computing\'s 1,180-site neutral-atom quantum computer (2024); first to exceed 1,000 qubits. Strontium atoms, nuclear-spin qubits with 40s+ coherence.',
+      feasibility: 'current',
+      tags: ['neutral_atom', 'strontium', 'nuclear_spin', 'AtomComputing'],
+      parameters: { qubitCount: 1180, modality: 'neutral_atom', gate2qFidelity: 0.995, T1_s: 40, nuclearSpin: true },
+      confidence: 0.91,
+    });
+    this.addNode({
+      id: 'hw_psiquantum',
+      label: 'PsiQuantum (photonic, targeting 1M qubits)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'PsiQuantum photonic quantum computer using silicon photonics and fusion-based measurement. Targeting 1 million physical qubits in a cryogenic-free data centre. Manufacturing partnership with GlobalFoundries.',
+      feasibility: 'mid_term',
+      tags: ['photonic', 'fusion_based', 'silicon_photonics', 'PsiQuantum'],
+      parameters: { targetQubitCount: 1000000, modality: 'photonic', approach: 'fusion_measurement', fabPartner: 'GlobalFoundries' },
+      confidence: 0.55,
+    });
+    this.addNode({
+      id: 'hw_xanadu_borealis',
+      label: 'Xanadu Borealis (216 squeezed modes)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Xanadu\'s programmable photonic processor; 216 squeezed modes in a time-multiplexed loop. Demonstrated Gaussian boson sampling advantage (2022).',
+      feasibility: 'current',
+      tags: ['photonic', 'continuous_variable', 'GBS', 'Xanadu'],
+      parameters: { modes: 216, modality: 'photonic_cv', advantage: 'GBS_2022' },
+      confidence: 0.88,
+    });
+    this.addNode({
+      id: 'hw_microsoft_majorana1',
+      label: 'Microsoft Majorana 1 (topological qubit)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Microsoft\'s topological qubit prototype (2024). Based on Majorana zero modes in indium-arsenide/aluminium nanowires. Goal: hardware-protected qubits with intrinsically low error. First qubit demonstrated; not yet scalable.',
+      feasibility: 'long_term',
+      tags: ['topological', 'majorana', 'indium_arsenide', 'Microsoft'],
+      parameters: { qubitCount: 1, modality: 'topological', status: 'prototype', materials: 'InAs/Al' },
+      confidence: 0.50,
+    });
+    this.addNode({
+      id: 'hw_rigetti_ankaa',
+      label: 'Rigetti Ankaa-3 (84 qubits)',
+      kind: 'hardware',
+      researchLine: 'new_qubit_modalities',
+      description: 'Rigetti\'s Ankaa-3 superconducting processor; 84 qubits, square-lattice topology, improved 2-qubit gates (~99.5%). Available via Rigetti QCS.',
+      feasibility: 'current',
+      tags: ['superconducting', 'transmon', 'Rigetti'],
+      parameters: { qubitCount: 84, modality: 'superconducting', gate2qFidelity: 0.995, topology: 'square_lattice' },
+      confidence: 0.88,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // LINE 1 — QUANTUM ERROR CORRECTION
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'qec_surface_code',
+      label: 'Surface Code',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Topological QEC code on a 2D lattice of physical qubits. Threshold ~1% (10^-2). Below threshold (Google Willow), increasing code distance exponentially suppresses logical errors. Industry standard for superconducting platforms.',
+      feasibility: 'current',
+      tags: ['topological_code', '2D_lattice', 'threshold_1e-2', 'Google_Willow'],
+      parameters: { threshold: 0.01, codeDistanceDemo: 7, physicalToLogicalOverhead: 1000, platformFit: ['superconducting', 'neutral_atom'] },
+      confidence: 0.97,
+    });
+    this.addNode({
+      id: 'qec_color_code',
+      label: 'Color Code',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Topological code on a 3-colorable trivalent lattice. Transversal Clifford gates (simpler magic-state overhead) but higher threshold (~0.1%). Heavier qubit overhead than surface code.',
+      feasibility: 'near_term',
+      tags: ['topological_code', 'transversal_clifford', 'trivalent'],
+      parameters: { threshold: 0.001, advantage: 'transversal_clifford', overhead: 'higher_than_surface' },
+      confidence: 0.80,
+    });
+    this.addNode({
+      id: 'qec_qldpc',
+      label: 'Quantum LDPC (qLDPC) Codes',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Low-density parity-check quantum codes with constant-rate encoding. Theoretically reduce physical-to-logical overhead from O(d^2) to O(1). Recent breakthroughs (2023-2024) constructed good qLDPC codes; experimental implementation pending.',
+      feasibility: 'mid_term',
+      tags: ['LDPC', 'constant_rate', 'low_overhead', 'breakthrough_2023'],
+      parameters: { rate: 'constant', overheadReduction: 'O(d^2)_to_O(1)', status: 'theoretical_breakthrough' },
+      confidence: 0.70,
+    });
+    this.addNode({
+      id: 'qec_concatenated',
+      label: 'Concatenated Codes',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Recursive code composition (e.g., Steane-of-Steane). Mature theory; high overhead (~d^4). Useful for small logical-qubit demonstrations.',
+      feasibility: 'current',
+      tags: ['concatenation', 'high_overhead', 'mature'],
+      parameters: { overhead: 'O(d^4)', threshold: 0.001 },
+      confidence: 0.85,
+    });
+    this.addNode({
+      id: 'qec_magic_state_distillation',
+      label: 'Magic State Distillation (MSD)',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Protocol to produce high-fidelity T-states (|T⟩) from noisy copies. Required for universal computation with Clifford-only QEC. Bravyi-Kitaev 15-to-1 is standard; recent protocols reduce overhead.',
+      feasibility: 'current',
+      tags: ['T_state', 'non_clifford', 'Bravyi_Kitaev'],
+      parameters: { inputStates: 15, outputStates: 1, targetFidelity: 0.9999 },
+      confidence: 0.92,
+    });
+    this.addNode({
+      id: 'qec_bacon_shor',
+      label: 'Bacon-Shor Code',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'Subsystem code tolerating biased noise. Effective for systems with dominant dephasing (e.g., cat qubits). Lower overhead than surface code for biased-noise platforms.',
+      feasibility: 'near_term',
+      tags: ['subsystem_code', 'biased_noise', 'cat_qubit'],
+      parameters: { noiseModel: 'biased', advantage: 'low_overhead_biased' },
+      confidence: 0.82,
+    });
+    this.addNode({
+      id: 'qec_measurement_results',
+      label: 'Threshold Theorem',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'States that if physical error rate is below a threshold p_th, logical error can be suppressed arbitrarily by increasing code distance. Foundation of fault-tolerant QC.',
+      feasibility: 'current',
+      tags: ['threshold_theorem', 'fault_tolerance', 'foundation'],
+      parameters: { status: 'proven', implications: 'arbitrary_suppression_below_threshold' },
+      confidence: 0.99,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // LINE 2 — NEW QUBIT MODALITIES (concepts, not hardware)
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'qubit_transmon',
+      label: 'Transmon Qubit',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Superconducting charge qubit with reduced charge dispersion via Josephson energy. Workhorse of IBM, Google, Rigetti. T1 ~100-500 µs; 2-qubit fidelity ~99.5-99.8%.',
+      feasibility: 'current',
+      tags: ['superconducting', 'charge_qubit', 'workhorse'],
+      parameters: { T1_us: 300, gate2qFidelity: 0.997, scalability: 'high', fabMaturity: 'high' },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'qubit_fluxonium',
+      label: 'Fluxonium Qubit',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Superconducting flux qubit with a large shunting inductor. T1 >1 ms demonstrated; anharmonic spectrum reduces leakage. Promising alternative to transmon.',
+      feasibility: 'near_term',
+      tags: ['superconducting', 'flux_qubit', 'long_coherence'],
+      parameters: { T1_us: 1000, gate2qFidelity: 0.999, anharmonicity: 'high' },
+      confidence: 0.78,
+    });
+    this.addNode({
+      id: 'qubit_cat',
+      label: 'Cat Qubit (Bosonic)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Qubit encoded in superposition of coherent states of a harmonic oscillator. Intrinsically bit-flip protected (exponential suppression). Alice&Bob, AWS demonstrated.',
+      feasibility: 'near_term',
+      tags: ['bosonic', 'cat_state', 'bit_flip_protected', 'AWS'],
+      parameters: { bitFlipSuppression: 'exponential', remainingError: 'phase_flip', platform: 'superconducting_cavity' },
+      confidence: 0.80,
+    });
+    this.addNode({
+      id: 'qubit_trapped_ion',
+      label: 'Trapped-Ion Qubit (Yb+/Ba+)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Hyperfine or optical qubits in individual trapped ions. All-to-all connectivity, T2 >1s, gate fidelity >99.9%. Slower gates (~100µs) limit clock speed.',
+      feasibility: 'current',
+      tags: ['trapped_ion', 'all_to_all', 'long_coherence'],
+      parameters: { T2_s: 1, gate2qFidelity: 0.999, gateTime_us: 100, connectivity: 'all_to_all' },
+      confidence: 0.93,
+    });
+    this.addNode({
+      id: 'qubit_neutral_atom',
+      label: 'Neutral-Atom Qubit (Rydberg)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Individual atoms trapped in optical tweezers; qubit in hyperfine or nuclear-spin states. Rydberg blockade enables gates. Highly scalable (1,000+ atoms), reconfigurable geometry.',
+      feasibility: 'current',
+      tags: ['neutral_atom', 'rydberg_blockade', 'scalable', 'reconfigurable'],
+      parameters: { qubitCount: 1180, gate2qFidelity: 0.995, T1_s: 40, reconfigurable: true },
+      confidence: 0.90,
+    });
+    this.addNode({
+      id: 'qubit_photonic',
+      label: 'Photonic Qubit (Fock / CV)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Qubit encoded in photon number, path, or time-bin. Room-temperature operation; fusion-based measurement enables MBQC. Challenge: deterministic photon sources and low-loss networks.',
+      feasibility: 'mid_term',
+      tags: ['photonic', 'room_temperature', 'fusion_based', 'MBQC'],
+      parameters: { operatingTemp: '300K', challenge: 'deterministic_sources', approach: 'fusion_measurement' },
+      confidence: 0.60,
+    });
+    this.addNode({
+      id: 'qubit_topological',
+      label: 'Topological Qubit (Majorana)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Qubit encoded non-locally in Majorana zero modes. Intrinsically protected from local noise. Microsoft\'s bet. Challenge: unambiguous demonstration and braiding.',
+      feasibility: 'long_term',
+      tags: ['topological', 'majorana', 'intrinsic_protection'],
+      parameters: { intrinsicProtection: true, status: 'prototype', challenge: 'demonstration' },
+      confidence: 0.45,
+    });
+    this.addNode({
+      id: 'qubit_spin_qubit',
+      label: 'Silicon Spin Qubit (Donor / Quantum Dot)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Electron or nuclear spin qubit in silicon. Leverages CMOS fabrication. Intel, imec, UNSW pursuing. T2 >10ms in isotopically purified 28-Si; 2-qubit fidelity ~99%.',
+      feasibility: 'near_term',
+      tags: ['spin', 'silicon', 'CMOS', 'Intel'],
+      parameters: { T2_ms: 10, gate2qFidelity: 0.99, fabCompatibility: 'CMOS' },
+      confidence: 0.75,
+    });
+    this.addNode({
+      id: 'qubit_nv_center',
+      label: 'NV-Center Qubit (Diamond)',
+      kind: 'concept',
+      researchLine: 'new_qubit_modalities',
+      description: 'Nitrogen-vacancy center in diamond; electron spin qubit with optical readout. Room-temperature operation; excellent for sensing. Limited scalability for computation.',
+      feasibility: 'mid_term',
+      tags: ['NV_center', 'diamond', 'sensing', 'room_temperature'],
+      parameters: { T2_ms: 1, operatingTemp: '300K', scalability: 'limited' },
+      confidence: 0.65,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // LINE 3 — QUANTUM ALGORITHMS
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'algo_shor',
+      label: 'Shor\'s Algorithm (Integer Factoring)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Polynomial-time quantum algorithm for integer factoring. Breaks RSA. Requires ~20M noisy physical qubits (or ~4K logical) for 2048-bit RSA. Far beyond current hardware.',
+      feasibility: 'long_term',
+      tags: ['factoring', 'RSA_breaking', 'exponential_speedup'],
+      parameters: { physicalQubitsForRSA2048: 20000000, logicalQubits: 4000, circuitDepth: 1e9, speedup: 'exponential' },
+      confidence: 0.99,
+    });
+    this.addNode({
+      id: 'algo_grover',
+      label: 'Grover\'s Algorithm (Unstructured Search)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Quadratic speedup for unstructured database search. Requires ~sqrt(N) oracle queries. Broad applicability but modest speedup limits near-term impact.',
+      feasibility: 'mid_term',
+      tags: ['search', 'quadratic_speedup', 'oracle'],
+      parameters: { speedup: 'quadratic', circuitDepth: 'sqrt_N', applicability: 'broad' },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'algo_vqe',
+      label: 'Variational Quantum Eigensolver (VQE)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Hybrid quantum-classical algorithm for ground-state energy estimation. NISQ-era workhorse. Suffers from barren plateaus and shot noise. Applied to chemistry and materials.',
+      feasibility: 'current',
+      tags: ['variational', 'hybrid', 'NISQ', 'chemistry'],
+      parameters: { era: 'NISQ', challenge: 'barren_plateaus', application: 'ground_state_energy' },
+      confidence: 0.90,
+    });
+    this.addNode({
+      id: 'algo_qaoa',
+      label: 'QAOA (Quantum Approximate Optimization)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Variational algorithm for combinatorial optimization. p-depth controls approximation. No proven practical advantage yet; active research area.',
+      feasibility: 'current',
+      tags: ['variational', 'optimization', 'combinatorial'],
+      parameters: { era: 'NISQ', challenge: 'no_proven_advantage', application: 'MaxCut_TSP' },
+      confidence: 0.82,
+    });
+    this.addNode({
+      id: 'algo_qft',
+      label: 'Quantum Fourier Transform (QFT)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Quantum analogue of the DFT. Core subroutine of Shor, phase estimation, and HHL. O(n^2) gates vs O(n*2^n) classical FFT for quantum states.',
+      feasibility: 'current',
+      tags: ['subroutine', 'Fourier', 'Shor_component'],
+      parameters: { gateComplexity: 'O(n^2)', subroutine_of: ['Shor', 'PEA', 'HHL'] },
+      confidence: 0.97,
+    });
+    this.addNode({
+      id: 'algo_hhl',
+      label: 'HHL Algorithm (Linear Systems)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Solves Ax=b with exponential speedup under conditions (sparse, well-conditioned, output as quantum state). Practical advantage debated; large qubit requirements.',
+      feasibility: 'long_term',
+      tags: ['linear_system', 'exponential_speedup', 'conditional'],
+      parameters: { speedup: 'exponential_conditional', conditions: ['sparse', 'well_conditioned'], qubitRequirement: 'high' },
+      confidence: 0.85,
+    });
+    this.addNode({
+      id: 'algo_qpe',
+      label: 'Quantum Phase Estimation (QPE)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Estimates eigenvalue phases of a unitary. Core for quantum chemistry (energy spectra) and Shor. Requires fault-tolerant qubits; deep circuits (~10^6 T-gates).',
+      feasibility: 'mid_term',
+      tags: ['phase_estimation', 'chemistry', 'fault_tolerant'],
+      parameters: { era: 'fault_tolerant', TgateCount: 1e6, application: 'energy_spectra' },
+      confidence: 0.93,
+    });
+    this.addNode({
+      id: 'algo_qml',
+      label: 'Quantum Machine Learning (QML)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Quantum algorithms for ML tasks: quantum kernels, variational classifiers, quantum GANs. Theoretical speedups exist for specific problems; practical advantage unproven.',
+      feasibility: 'mid_term',
+      tags: ['machine_learning', 'kernel_methods', 'variational'],
+      parameters: { era: 'NISQ_to_FT', advantage: 'unproven', approaches: ['quantum_kernel', 'variational', 'QGAN'] },
+      confidence: 0.70,
+    });
+    this.addNode({
+      id: 'algo_qsvt',
+      label: 'Quantum Singular Value Transformation (QSVT)',
+      kind: 'concept',
+      researchLine: 'quantum_algorithms',
+      description: 'Unifying framework (Gilyen et al. 2019) for quantum algorithms via block-encoding polynomial transforms. Subsumes QPE, HHL, Grover as special cases. Optimal query complexity.',
+      feasibility: 'mid_term',
+      tags: ['unifying_framework', 'block_encoding', 'optimal'],
+      parameters: { era: 'fault_tolerant', unifies: ['Grover', 'HHL', 'QPE'], optimality: 'query_complexity' },
+      confidence: 0.90,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // LINE 4 — MOLECULAR SIMULATION
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'sim_fermionic_hamiltonian',
+      label: 'Fermionic Hamiltonian Simulation',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Simulating the electronic structure Hamiltonian H = Σ h_pq a†_p a_q + ½ Σ h_pqrs a†_p a†_q a_r a_s. The core problem of quantum chemistry. Mapping via Jordan-Wigner, Bravyi-Kitaev, or parity.',
+      feasibility: 'current',
+      tags: ['electronic_structure', 'fermion_to_qubit', 'chemistry_core'],
+      parameters: { mappings: ['Jordan_Wigner', 'Bravyi_Kitaev', 'parity'], qubitsPerOrbital: 1 },
+      confidence: 0.96,
+    });
+    this.addNode({
+      id: 'sim_jordan_wigner',
+      label: 'Jordan-Wigner Transformation',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Maps fermionic operators to Pauli strings. Non-local strings (O(N) length) make 2D-lattice implementation costly, but simple. Bravyi-Kitaev reduces overhead.',
+      feasibility: 'current',
+      tags: ['fermion_mapping', 'Pauli_string', 'non_local'],
+      parameters: { stringLength: 'O(N)', overhead: 'high_for_2D_lattice' },
+      confidence: 0.97,
+    });
+    this.addNode({
+      id: 'sim_trotterization',
+      label: 'Trotter-Suzuki Decomposition',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Approximates e^(-iHt) as product of local terms e^(-iH_1 t) e^(-iH_2 t) ... Error decreases with Trotter steps. Standard for chemistry simulation.',
+      feasibility: 'current',
+      tags: ['time_evolution', 'product_formula', 'chemistry'],
+      parameters: { errorScaling: 'O(t^2/k)', approach: 'product_formula' },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'sim_qubitization',
+      label: 'Qubitization (Quantum Walk)',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Technique to implement block-encoded Hamiltonian evolution with optimal query complexity. Lower gate count than Trotter for chemistry. Core of modern fault-tolerant simulation.',
+      feasibility: 'mid_term',
+      tags: ['block_encoding', 'optimal_query', 'fault_tolerant'],
+      parameters: { queryComplexity: 'optimal', era: 'fault_tolerant', advantage: 'lower_gates_than_trotter' },
+      confidence: 0.88,
+    });
+    this.addNode({
+      id: 'sim_fe_mnn',
+      label: 'FeMoco (Nitrogenase Active Site)',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Iron-molybdenum cofactor of nitrogenase; the canonical "killer app" target for quantum chemistry. Classical methods struggle with strong correlation. Requires ~2,000-4,000 logical qubits.',
+      feasibility: 'long_term',
+      tags: ['FeMoco', 'nitrogenase', 'strong_correlation', 'killer_app'],
+      parameters: { logicalQubits: 3000, TgateCount: 1e11, motivation: 'fertilizer_production' },
+      confidence: 0.85,
+    });
+    this.addNode({
+      id: 'sim_transition_metal',
+      label: 'Transition-Metal Catalysis',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Catalytic cycles involving Fe, Cu, Ni (e.g., C-H activation, cross-coupling). Strongly correlated d-electrons. Near-term targets for VQE on 100-1000 qubits.',
+      feasibility: 'near_term',
+      tags: ['catalysis', 'transition_metal', 'VQE_target'],
+      parameters: { qubitsRange: '100-1000', era: 'NISQ_to_early_FT', application: 'pharma_chem' },
+      confidence: 0.80,
+    });
+    this.addNode({
+      id: 'sim_drug_discovery',
+      label: 'Quantum-Enhanced Drug Discovery',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Using quantum simulation for binding-affinity prediction, protein-ligand dynamics, and ADMET. Hybrid quantum-classical pipelines. Roche, Boehringer exploring.',
+      feasibility: 'mid_term',
+      tags: ['drug_discovery', 'binding_affinity', 'hybrid', 'pharma'],
+      parameters: { era: 'NISQ_to_FT', pipeline: 'hybrid', partners: ['Roche', 'Boehringer'] },
+      confidence: 0.72,
+    });
+    this.addNode({
+      id: 'sim_materials',
+      label: 'Materials Simulation (High-Tc, Battery)',
+      kind: 'concept',
+      researchLine: 'molecular_simulation',
+      description: 'Simulating strongly correlated materials: high-Tc superconductors, battery cathodes, catalysts. Quantum advantage expected for Hubbard model, transition-metal oxides.',
+      feasibility: 'mid_term',
+      tags: ['materials', 'Hubbard_model', 'high_Tc', 'battery'],
+      parameters: { era: 'early_FT', targets: ['cuprates', 'Li_ion_cathode', 'OER_catalyst'] },
+      confidence: 0.78,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // CROSS-CUTTING CONCEPTS
+    // ═══════════════════════════════════════════════════════════════════════
+    this.addNode({
+      id: 'concept_quantum_advantage',
+      label: 'Quantum Advantage / Supremacy',
+      kind: 'concept',
+      researchLine: null,
+      description: 'Demonstration that a quantum device solves a defined problem faster than the best classical algorithm. Achieved by Google (2019, RCS), USTC (2020, GBS), Xanadu (2022, GBS). Practical advantage remains elusive.',
+      feasibility: 'current',
+      tags: ['advantage', 'supremacy', 'milestone'],
+      parameters: { demonstrations: ['Google_2019', 'USTC_2020', 'Xanadu_2022'], practical: false },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'concept_logical_qubit',
+      label: 'Logical Qubit',
+      kind: 'concept',
+      researchLine: 'quantum_error_correction',
+      description: 'An error-corrected qubit composed of many physical qubits via a QEC code. The unit of fault-tolerant computation. Current best: ~1 logical qubit at distance-7 (Google Willow).',
+      feasibility: 'current',
+      tags: ['logical_qubit', 'error_corrected', 'fault_tolerance'],
+      parameters: { demonstrated: 1, targetForUseful: 100, targetForRSA: 4000 },
+      confidence: 0.95,
+    });
+    this.addNode({
+      id: 'concept_ftqc_roadmap',
+      label: 'Fault-Tolerant QC Roadmap',
+      kind: 'concept',
+      researchLine: null,
+      description: 'Industry consensus: 1 logical qubit (2024-2025) → 100 logical (2028-2030) → 4,000 logical for RSA-2048 (2035+). IBM, Google, Quantinuum, Atom Computing all targeting 100K+ physical qubits by 2033.',
+      feasibility: 'mid_term',
+      tags: ['roadmap', 'fault_tolerance', 'industry_consensus'],
+      parameters: { timeline_100logical: '2028-2030', timeline_RSA: '2035+', physicalQubitTarget: 100000 },
+      confidence: 0.80,
+    });
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // RELATIONSHIPS — this is what ensures nothing stays isolated
+    // ═══════════════════════════════════════════════════════════════════════
+    // QEC ↔ Qubits
+    this.addEdge({ from: 'qec_surface_code', to: 'qubit_transmon', type: 'implements', weight: 0.9 });
+    this.addEdge({ from: 'qec_surface_code', to: 'qubit_neutral_atom', type: 'implements', weight: 0.8 });
+    this.addEdge({ from: 'hw_google_willow', to: 'qec_surface_code', type: 'implements', weight: 0.95,
+      evidence: ['Willow demonstrated distance-7 surface code below threshold, Dec 2024'] });
+    this.addEdge({ from: 'qec_bacon_shor', to: 'qubit_cat', type: 'corrects', weight: 0.85 });
+    this.addEdge({ from: 'qubit_cat', to: 'qec_bacon_shor', type: 'qubit_modality_for', weight: 0.85 });
+    this.addEdge({ from: 'qec_qldpc', to: 'qubit_transmon', type: 'cross_links', weight: 0.6,
+      evidence: ['qLDPC requires long-range connectivity; transmon heavy-hex may need modification'] });
+    this.addEdge({ from: 'qec_qldpc', to: 'qubit_neutral_atom', type: 'cross_links', weight: 0.7,
+      evidence: ['Neutral atoms with reconfigurable geometry are natural for qLDPC long-range checks'] });
+    this.addEdge({ from: 'qec_magic_state_distillation', to: 'qec_surface_code', type: 'depends_on', weight: 0.9 });
+    this.addEdge({ from: 'qec_surface_code', to: 'qec_measurement_results', type: 'measured_by', weight: 1.0 });
+    this.addEdge({ from: 'qec_color_code', to: 'qec_magic_state_distillation', type: 'improves', weight: 0.7,
+      evidence: ['Color codes have transversal Clifford, reducing MSD overhead'] });
+    this.addEdge({ from: 'qubit_topological', to: 'hw_microsoft_majorana1', type: 'implements', weight: 0.6 });
+    this.addEdge({ from: 'qubit_topological', to: 'qec_surface_code', type: 'contradicts', weight: 0.3,
+      evidence: ['Topological qubits aim for intrinsic protection, reducing QEC overhead'] });
+
+    // Qubits ↔ Hardware
+    this.addEdge({ from: 'hw_ibm_condor', to: 'qubit_transmon', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_ibm_heron', to: 'qubit_transmon', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_rigetti_ankaa', to: 'qubit_transmon', type: 'qubit_modality_for', weight: 0.9 });
+    this.addEdge({ from: 'hw_ionq_forte', to: 'qubit_trapped_ion', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_quantinuum_h2', to: 'qubit_trapped_ion', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_quera_aquila', to: 'qubit_neutral_atom', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_atom_computing', to: 'qubit_neutral_atom', type: 'qubit_modality_for', weight: 0.95 });
+    this.addEdge({ from: 'hw_psiquantum', to: 'qubit_photonic', type: 'qubit_modality_for', weight: 0.9 });
+    this.addEdge({ from: 'hw_xanadu_borealis', to: 'qubit_photonic', type: 'qubit_modality_for', weight: 0.85 });
+    this.addEdge({ from: 'qubit_fluxonium', to: 'qubit_transmon', type: 'improves', weight: 0.7,
+      evidence: ['Fluxonium offers 3-10x longer T1 than transmon'] });
+    this.addEdge({ from: 'qubit_spin_qubit', to: 'qubit_transmon', type: 'cross_links', weight: 0.5,
+      evidence: ['Both leverage semiconductor fab; spin qubits use CMOS, transmons use Nb/Al'] });
+
+    // Algorithms ↔ QEC (algorithms need fault tolerance)
+    this.addEdge({ from: 'algo_shor', to: 'qec_surface_code', type: 'depends_on', weight: 0.95,
+      evidence: ['Shor for RSA-2048 requires ~4,000 logical qubits = millions of physical'] });
+    this.addEdge({ from: 'algo_qpe', to: 'qec_magic_state_distillation', type: 'depends_on', weight: 0.9 });
+    this.addEdge({ from: 'algo_hhl', to: 'algo_qsvt', type: 'cross_links', weight: 0.8,
+      evidence: ['HHL is a special case of QSVT'] });
+    this.addEdge({ from: 'algo_qsvt', to: 'algo_qpe', type: 'cross_links', weight: 0.8 });
+    this.addEdge({ from: 'algo_grover', to: 'algo_qsvt', type: 'cross_links', weight: 0.7 });
+    this.addEdge({ from: 'algo_qft', to: 'algo_shor', type: 'implements', weight: 1.0 });
+    this.addEdge({ from: 'algo_qft', to: 'algo_qpe', type: 'implements', weight: 1.0 });
+    this.addEdge({ from: 'algo_vqe', to: 'concept_ftqc_roadmap', type: 'cross_links', weight: 0.5,
+      evidence: ['VQE is a NISQ bridge to FTQC algorithms'] });
+    this.addEdge({ from: 'algo_qaoa', to: 'algo_vqe', type: 'cross_links', weight: 0.7 });
+
+    // Molecular Simulation ↔ Algorithms ↔ QEC
+    this.addEdge({ from: 'sim_fermionic_hamiltonian', to: 'sim_jordan_wigner', type: 'implements', weight: 0.95 });
+    this.addEdge({ from: 'sim_fermionic_hamiltonian', to: 'algo_qpe', type: 'depends_on', weight: 0.85,
+      evidence: ['QPE is the algorithm of choice for FTQC chemistry'] });
+    this.addEdge({ from: 'sim_fermionic_hamiltonian', to: 'algo_vqe', type: 'cross_links', weight: 0.8,
+      evidence: ['VQE is the NISQ-era precursor to QPE chemistry'] });
+    this.addEdge({ from: 'sim_trotterization', to: 'sim_fermionic_hamiltonian', type: 'implements', weight: 0.85 });
+    this.addEdge({ from: 'sim_qubitization', to: 'sim_fermionic_hamiltonian', type: 'implements', weight: 0.9 });
+    this.addEdge({ from: 'sim_qubitization', to: 'algo_qsvt', type: 'depends_on', weight: 0.85,
+      evidence: ['Qubitization is an application of QSVT'] });
+    this.addEdge({ from: 'sim_fe_mnn', to: 'sim_fermionic_hamiltonian', type: 'depends_on', weight: 1.0 });
+    this.addEdge({ from: 'sim_fe_mnn', to: 'qec_surface_code', type: 'depends_on', weight: 0.9,
+      evidence: ['FeMoco requires ~3,000 logical qubits = ~1M physical with surface code'] });
+    this.addEdge({ from: 'sim_transition_metal', to: 'sim_fermionic_hamiltonian', type: 'depends_on', weight: 0.9 });
+    this.addEdge({ from: 'sim_transition_metal', to: 'algo_vqe', type: 'implements', weight: 0.8 });
+    this.addEdge({ from: 'sim_drug_discovery', to: 'sim_transition_metal', type: 'cross_links', weight: 0.7 });
+    this.addEdge({ from: 'sim_drug_discovery', to: 'sim_fermionic_hamiltonian', type: 'depends_on', weight: 0.8 });
+    this.addEdge({ from: 'sim_materials', to: 'sim_fermionic_hamiltonian', type: 'depends_on', weight: 0.85 });
+    this.addEdge({ from: 'sim_materials', to: 'algo_qpe', type: 'cross_links', weight: 0.7 });
+
+    // Cross-cutting
+    this.addEdge({ from: 'concept_logical_qubit', to: 'qec_surface_code', type: 'depends_on', weight: 1.0 });
+    this.addEdge({ from: 'concept_ftqc_roadmap', to: 'concept_logical_qubit', type: 'measured_by', weight: 0.9 });
+    this.addEdge({ from: 'concept_ftqc_roadmap', to: 'hw_ibm_condor', type: 'cross_links', weight: 0.6 });
+    this.addEdge({ from: 'concept_ftqc_roadmap', to: 'hw_atom_computing', type: 'cross_links', weight: 0.6 });
+    this.addEdge({ from: 'concept_quantum_advantage', to: 'hw_xanadu_borealis', type: 'measured_by', weight: 0.8 });
+    this.addEdge({ from: 'concept_quantum_advantage', to: 'hw_google_willow', type: 'cross_links', weight: 0.7 });
+
+    this.emit('seeded', this.stats());
+  }
+}
+
+export { RELATION_TYPES, FEASIBILITY_TIERS };