quantum-spherifier 1.0.0

package/src/modules/ResearchLineRouter.js

@@ -0,0 +1,187 @@
+/**
+ * ResearchLineRouter.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Routes each research cycle to one of the four primary research lines:
+ *
+ *   1. quantum_error_correction  — QEC codes, thresholds, magic states
+ *   2. new_qubit_modalities      — transmon, ion, neutral atom, photonic, ...
+ *   3. quantum_algorithms        — Shor, Grover, VQE, QAOA, QSVT, ...
+ *   4. molecular_simulation      — chemistry, materials, drug discovery
+ *
+ * Routing policy:
+ *   - If the owner directive names a specific line, route there.
+ *   - Otherwise, balance across lines using a round-robin + under-explored
+ *     boost: the line with the fewest recent cycles and the most
+ *     under-explored KG nodes gets priority.
+ *   - Every 5th cycle is a "cross-link" cycle that deliberately bridges
+ *     two lines (e.g. "qLDPC on neutral atoms" bridges QEC + qubits).
+ *
+ * This ensures robust, cross-linked progress: nothing stays isolated.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import { RESEARCH_LINES } from './QuantumKnowledgeGraph.js';
+
+const LINE_DESCRIPTIONS = {
+  quantum_error_correction: {
+    label: 'Quantum Error Correction',
+    shortLabel: 'QEC',
+    goal: 'Build fault-tolerant logical qubits by suppressing physical errors below threshold and reducing overhead.',
+    keyMetrics: ['logical_error_rate', 'code_distance', 'physical_to_logical_overhead', 'threshold'],
+    seedTopics: ['qec_surface_code', 'qec_qldpc', 'qec_color_code', 'qec_magic_state_distillation'],
+  },
+  new_qubit_modalities: {
+    label: 'New Qubit Modalities',
+    shortLabel: 'Qubits',
+    goal: 'Develop qubit platforms with longer coherence, higher gate fidelity, lower cost, and better scalability.',
+    keyMetrics: ['T1', 'T2', 'gate2qFidelity', 'qubitCount', 'costPerQubit'],
+    seedTopics: ['qubit_fluxonium', 'qubit_cat', 'qubit_neutral_atom', 'qubit_silicon_spin', 'qubit_topological'],
+  },
+  quantum_algorithms: {
+    label: 'Quantum Algorithms',
+    shortLabel: 'Algorithms',
+    goal: 'Discover and optimize algorithms with provable or practical quantum advantage on near-term and fault-tolerant hardware.',
+    keyMetrics: ['circuit_depth', 'tgate_count', 'speedup', 'qubit_requirement'],
+    seedTopics: ['algo_qsvt', 'algo_qpe', 'algo_vqe', 'algo_qml', 'algo_hhl'],
+  },
+  molecular_simulation: {
+    label: 'Molecular Simulation',
+    shortLabel: 'Simulation',
+    goal: 'Simulate fermionic systems (catalysts, drugs, materials) beyond classical capability.',
+    keyMetrics: ['logical_qubits', 'tgate_count', 'chemical_accuracy', 'molecule_size'],
+    seedTopics: ['sim_femoco', 'sim_transition_metal', 'sim_drug_discovery', 'sim_materials', 'sim_qubitization'],
+  },
+};
+
+export class ResearchLineRouter extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.kg = opts.kg ?? null;
+    this.cycleCounts = Object.fromEntries(RESEARCH_LINES.map(l => [l, 0]));
+    this.crossLinkCycleEvery = opts.crossLinkCycleEvery ?? 5;
+    this.totalCycles = 0;
+    this.lastLine = null;
+  }
+
+  /**
+   * Decide which research line to execute next.
+   * @param {string|null} ownerDirective
+   * @returns {{ line: string, crossLink: boolean, pairedLine?: string, seedTopic: string|null }}
+   */
+  route(ownerDirective = null) {
+    this.totalCycles++;
+
+    // Cross-link cycle every Nth cycle
+    const isCrossLinkCycle = this.totalCycles % this.crossLinkCycleEvery === 0;
+
+    // Try to detect line from directive
+    let line = this._detectLineFromDirective(ownerDirective);
+
+    if (!line) {
+      if (isCrossLinkCycle) {
+        // Pick two under-explored lines to bridge
+        const pair = this._pickCrossLinkPair();
+        line = pair[0];
+        const result = {
+          line,
+          crossLink: true,
+          pairedLine: pair[1],
+          seedTopic: this._pickSeedTopic(line),
+        };
+        this.cycleCounts[line]++;
+        this.lastLine = line;
+        this.emit('routed', result);
+        return result;
+      }
+      // Autonomous: pick the least-cycled line with most under-explored nodes
+      line = this._pickBalancedLine();
+    }
+
+    const result = {
+      line,
+      crossLink: false,
+      seedTopic: this._pickSeedTopic(line),
+    };
+    this.cycleCounts[line]++;
+    this.lastLine = line;
+    this.emit('routed', result);
+    return result;
+  }
+
+  _detectLineFromDirective(directive) {
+    if (!directive || typeof directive !== 'string') return null;
+    const lower = directive.toLowerCase();
+    const keywords = {
+      quantum_error_correction: ['error correction', 'qec', 'surface code', 'qldpc', 'color code', 'magic state', 'fault tolerant', 'threshold', 'logical qubit', 'code distance'],
+      new_qubit_modalities: ['qubit', 'transmon', 'fluxonium', 'cat qubit', 'trapped ion', 'neutral atom', 'rydberg', 'photonic', 'topological', 'majorana', 'spin qubit', 'silicon spin', 'nv center', 'coherence', 'gate fidelity'],
+      quantum_algorithms: ['algorithm', 'shor', 'grover', 'vqe', 'qaoa', 'qft', 'hhl', 'phase estimation', 'qsvt', 'quantum machine learning', 'qml', 'optimization'],
+      molecular_simulation: ['molecular', 'simulation', 'chemistry', 'femoco', 'catalyst', 'drug', 'fermionic', 'hamiltonian', 'trotter', 'qubitization', 'jordan-wigner', 'materials', 'battery', 'protein'],
+    };
+    for (const [line, kws] of Object.entries(keywords)) {
+      if (kws.some(k => lower.includes(k))) return line;
+    }
+    return null;
+  }
+
+  _pickBalancedLine() {
+    // Score each line: lower cycle count + more under-explored nodes = higher priority
+    const scores = [];
+    for (const line of RESEARCH_LINES) {
+      const cycleCount = this.cycleCounts[line];
+      const underExplored = this.kg ? this.kg.findUnderExplored(50, line).length : 10;
+      const lastCyclePenalty = this.lastLine === line ? 2 : 0;
+      const score = underExplored - cycleCount * 0.5 - lastCyclePenalty;
+      scores.push({ line, score });
+    }
+    scores.sort((a, b) => b.score - a.score);
+    return scores[0].line;
+  }
+
+  _pickCrossLinkPair() {
+    // Pick two lines that have the fewest cross-links between them in the KG
+    const pairs = [
+      ['quantum_error_correction', 'new_qubit_modalities'],
+      ['quantum_error_correction', 'quantum_algorithms'],
+      ['quantum_error_correction', 'molecular_simulation'],
+      ['new_qubit_modalities', 'quantum_algorithms'],
+      ['new_qubit_modalities', 'molecular_simulation'],
+      ['quantum_algorithms', 'molecular_simulation'],
+    ];
+    // Simple rotation for determinism
+    const idx = Math.floor(this.totalCycles / this.crossLinkCycleEvery) % pairs.length;
+    return pairs[idx];
+  }
+
+  _pickSeedTopic(line) {
+    const desc = LINE_DESCRIPTIONS[line];
+    if (!desc) return null;
+    // Prefer under-explored seed topics
+    if (this.kg) {
+      for (const topic of desc.seedTopics) {
+        const underExplored = this.kg.findUnderExplored(20, line);
+        const found = underExplored.find(u => u.node?.id === topic);
+        if (found) return topic;
+      }
+    }
+    return desc.seedTopics[Math.floor(Math.random() * desc.seedTopics.length)];
+  }
+
+  describe(line) {
+    return LINE_DESCRIPTIONS[line] ?? null;
+  }
+
+  allLines() {
+    return RESEARCH_LINES.map(l => ({ id: l, ...LINE_DESCRIPTIONS[l], cycles: this.cycleCounts[l] }));
+  }
+
+  stats() {
+    return {
+      totalCycles: this.totalCycles,
+      byLine: { ...this.cycleCounts },
+      lastLine: this.lastLine,
+    };
+  }
+}
+
+export { LINE_DESCRIPTIONS, RESEARCH_LINES };

package/src/modules/ResourceFeasibilityChecker.js

@@ -0,0 +1,494 @@
+/**
+ * ResourceFeasibilityChecker.js — quantum-spherifier (v1.0)
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Anchors every proposed solution to the ACTUAL resources of human
+ * civilisation (quantum hardware, cryogenics, fab capacity, supply chains)
+ * as of 2026. Produces a structured feasibility verdict:
+ *
+ *   tier:    current | near_term | mid_term | long_term | speculative
+ *   anchors: list of existing facilities / technologies that support the claim
+ *   gaps:    list of missing capabilities that must be developed
+ *   cost:    rough order-of-magnitude estimate (USD)
+ *   timeline: years-to-useful-quantum-advantage estimate
+ *   resource: { physicalQubits, logicalQubits, codeDistance, TgateCount, cryo }
+ *
+ * KEY PRINCIPLE: Every proposed solution must be enlaced with the actual
+ * level of resources that civilisation possesses, or will possess if the
+ * apparatuses/infrastructures proposed in the solution are built. Nothing
+ * stays isolated from reality.
+ *
+ * Used as a HARD GATE before any document is marked patent-eligible.
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { EventEmitter } from 'eventemitter3';
+
+// Resource anchors: the ACTUAL quantum-computing capacity of human
+// civilisation as of 2026. Every claim must trace back to at least one
+// anchor or be flagged as speculative.
+export const RESOURCE_ANCHORS = Object.freeze({
+  // ── Superconducting platforms ─────────────────────────────────────────────
+  IBM_Condor: {
+    label: 'IBM Condor — 1,121 superconducting qubits (Yorktown, USA)',
+    status: 'operating',
+    qubitCount: 1121,
+    modality: 'superconducting_transmon',
+    year: 2023,
+    note: 'Kilo-qubit cryogenic control demonstrated; no quantum advantage',
+  },
+  IBM_Heron: {
+    label: 'IBM Heron R2 — 156 qubits, tunable couplers (IBM Quantum System Two)',
+    status: 'operating',
+    qubitCount: 156,
+    modality: 'superconducting_transmon',
+    gate2qFidelity: 0.997,
+    year: 2024,
+  },
+  Google_Willow: {
+    label: 'Google Willow — 105 qubits, below-threshold QEC (Santa Barbara, USA)',
+    status: 'operating',
+    qubitCount: 105,
+    modality: 'superconducting_transmon',
+    gate2qFidelity: 0.998,
+    achievement: 'exponential_error_suppression_distance_7',
+    year: 2024,
+  },
+  Rigetti_Ankaa3: {
+    label: 'Rigetti Ankaa-3 — 84 superconducting qubits',
+    status: 'operating',
+    qubitCount: 84,
+    modality: 'superconducting_transmon',
+    gate2qFidelity: 0.995,
+    year: 2024,
+  },
+
+  // ── Trapped-ion platforms ─────────────────────────────────────────────────
+  IonQ_Forte: {
+    label: 'IonQ Forte Enterprise — 36 algorithmic qubits (Bothell, USA)',
+    status: 'operating',
+    algorithmicQubits: 36,
+    modality: 'trapped_ion_ytterbium',
+    gate2qFidelity: 0.996,
+    connectivity: 'all_to_all',
+    year: 2024,
+  },
+  Quantinuum_H2: {
+    label: 'Quantinuum H2 — 56 trapped-ion qubits, 99.87% 2Q fidelity',
+    status: 'operating',
+    qubitCount: 56,
+    modality: 'trapped_ion_barium',
+    gate2qFidelity: 0.9987,
+    connectivity: 'all_to_all',
+    achievement: 'non_Abelian_topological_states_2024',
+    year: 2024,
+  },
+
+  // ── Neutral-atom platforms ────────────────────────────────────────────────
+  QuEra_Aquila: {
+    label: 'QuEra Aquila — 256 neutral-atom qubits (Boston, USA, AWS Braket)',
+    status: 'operating',
+    qubitCount: 256,
+    modality: 'neutral_atom_rubidium',
+    gate2qFidelity: 0.98,
+    year: 2023,
+  },
+  Atom_Computing_1180: {
+    label: 'Atom Computing — 1,180 neutral-atom qubits, strontium (Boulder, USA)',
+    status: 'operating',
+    qubitCount: 1180,
+    modality: 'neutral_atom_strontium',
+    gate2qFidelity: 0.995,
+    T1_s: 40,
+    achievement: 'first_1000_plus_qubit_neutral_atom',
+    year: 2024,
+  },
+
+  // ── Photonic platforms ────────────────────────────────────────────────────
+  Xanadu_Borealis: {
+    label: 'Xanadu Borealis — 216 photonic squeezed modes (Toronto, CA)',
+    status: 'operating',
+    modes: 216,
+    modality: 'photonic_continuous_variable',
+    achievement: 'GBS_quantum_advantage_2022',
+    year: 2022,
+  },
+  PsiQuantum_Omega: {
+    label: 'PsiQuantum Omega — photonic FTQC chip in development (Palo Alto, USA + Brisbane, AU)',
+    status: 'under_construction',
+    targetQubitCount: 1000000,
+    modality: 'photonic_fusion_based',
+    fabPartner: 'GlobalFoundries',
+    year: '2027_target',
+  },
+
+  // ── Topological ───────────────────────────────────────────────────────────
+  Microsoft_Majorana1: {
+    label: 'Microsoft Majorana 1 — topological qubit prototype',
+    status: 'prototype',
+    qubitCount: 1,
+    modality: 'topological_majorana',
+    materials: 'InAs/Al nanowire',
+    year: 2024,
+    note: 'First topological qubit; not yet scalable',
+  },
+
+  // ── Silicon spin ──────────────────────────────────────────────────────────
+  Intel_Spin_TunnelFalls: {
+    label: 'Intel Tunnel Falls — 12-qubit silicon spin chip',
+    status: 'operating',
+    qubitCount: 12,
+    modality: 'silicon_spin_qubit',
+    fabNode: 'Intel 3 (CMOS compatible)',
+    year: 2023,
+  },
+
+  // ── Cryogenics & infrastructure ───────────────────────────────────────────
+  Dilution_Refrigerators: {
+    label: 'Bluefors / Oxford Instruments dilution refrigerators (10-20 mK)',
+    status: 'available',
+    baseTemp_mK: 10,
+    coolingPower_uW_at_20mK: 30,
+    annualUnits: 500,
+    costUSD: 500000,
+  },
+  Cryogenic_CMOS_Control: {
+    label: 'Cryo-CMOS control chips (Intel, Google, SeeQC)',
+    status: 'emerging',
+    note: '4K-stage CMOS for scalable control; reduces wiring burden',
+    year: 2024,
+  },
+
+  // ── Classical HPC for simulation ──────────────────────────────────────────
+  GPU_Clusters: {
+    label: 'NVIDIA H100 / H200 GPU clusters for tensor-network simulation',
+    status: 'available',
+    note: 'cuQuantum library; simulates up to ~40 qubits state-vector, 100+ with tensor networks',
+    year: 2024,
+  },
+  Supercomputers: {
+    label: 'Frontier / Aurora / Fugaku supercomputers (exascale)',
+    status: 'available',
+    performance: '1-2 exaflops',
+    note: 'Used for classical simulation of quantum circuits and benchmarking',
+  },
+
+  // ── Materials & supply chain ──────────────────────────────────────────────
+  Helium3_supply: {
+    label: 'Helium-3 supply (dilution refrigerators)',
+    status: 'constrained',
+    annualLiters: 10000,
+    note: 'Critical for sub-100mK; limited global supply',
+  },
+  REBCO_tape: {
+    label: 'REBCO HTS tape (for high-field magnets in ion traps)',
+    status: 'available',
+    annualKm: 1000,
+  },
+  Ultra_pure_Si28: {
+    label: 'Isotopically purified 28-Silicon (for spin qubits)',
+    status: 'available',
+    enrichmentLevel: 0.9999,
+    costPerGramUSD: 50000,
+  },
+  Fiber_optics: {
+    label: 'Low-loss optical fiber (<0.2 dB/km) for photonic QC',
+    status: 'available',
+    loss_dB_per_km: 0.17,
+  },
+});
+
+// Feasibility rules — each tests a specific quantum parameter and returns
+// a tier verdict. The most pessimistic tier wins.
+const FEASIBILITY_RULES = [
+  // ── Physical qubit count ──────────────────────────────────────────────────
+  {
+    id: 'rule_physical_qubits',
+    test: (claim) => {
+      const n = claim.parameters?.physicalQubits;
+      if (typeof n !== 'number') return null;
+      if (n > 1_000_000) return { tier: 'speculative', reason: `${n} physical qubits exceeds any announced roadmap (PsiQuantum targets 1M by ~2028)` };
+      if (n > 100_000)   return { tier: 'long_term', reason: `${n} physical qubits requires 2030+ fab scale-up` };
+      if (n > 10_000)    return { tier: 'mid_term', reason: `${n} physical qubits is 5-8 years from current 1K-scale` };
+      if (n > 1_000)     return { tier: 'near_term', reason: `${n} physical qubits within IBM/Atom Computing 2025-2027 roadmap` };
+      if (n > 100)       return { tier: 'current', reason: `${n} physical qubits demonstrated (IBM Condor 1121, Atom 1180)` };
+      return { tier: 'current', reason: `${n} physical qubits well within current capability` };
+    },
+  },
+  // ── Logical qubit count ───────────────────────────────────────────────────
+  {
+    id: 'rule_logical_qubits',
+    test: (claim) => {
+      const n = claim.parameters?.logicalQubits;
+      if (typeof n !== 'number') return null;
+      if (n > 10_000) return { tier: 'speculative', reason: `${n} logical qubits far beyond any roadmap (RSA-2048 needs ~4K)` };
+      if (n > 1_000)  return { tier: 'long_term', reason: `${n} logical qubits requires 2035+ fault-tolerant scale` };
+      if (n > 100)    return { tier: 'mid_term', reason: `${n} logical qubits in 2029-2033 FTQC roadmap window` };
+      if (n > 10)     return { tier: 'near_term', reason: `${n} logical qubits targeted by 2026-2028 (Google, Quantinuum)` };
+      if (n >= 1)     return { tier: 'current', reason: `${n} logical qubit(s) demonstrated (Google Willow distance-7, 2024)` };
+      return null;
+    },
+  },
+  // ── 2-qubit gate fidelity ─────────────────────────────────────────────────
+  {
+    id: 'rule_gate_fidelity',
+    test: (claim) => {
+      const f = claim.parameters?.gate2qFidelity;
+      if (typeof f !== 'number') return null;
+      if (f < 0.90)  return { tier: 'speculative', reason: `2Q fidelity ${(f*100).toFixed(2)}% far below surface-code threshold (99%)` };
+      if (f < 0.99)  return { tier: 'long_term', reason: `2Q fidelity ${(f*100).toFixed(2)}% below surface-code threshold; QEC infeasible` };
+      if (f < 0.995) return { tier: 'mid_term', reason: `2Q fidelity ${(f*100).toFixed(2)}% marginal for surface code; high overhead` };
+      if (f < 0.999) return { tier: 'near_term', reason: `2Q fidelity ${(f*100).toFixed(2)}% above threshold; practical QEC (IBM Heron, IonQ)` };
+      return { tier: 'current', reason: `2Q fidelity ${(f*100).toFixed(2)}% excellent (Quantinuum H2: 99.87%)` };
+    },
+  },
+  // ── Surface code distance ─────────────────────────────────────────────────
+  {
+    id: 'rule_code_distance',
+    test: (claim) => {
+      const d = claim.parameters?.codeDistance;
+      if (typeof d !== 'number') return null;
+      if (d > 30)   return { tier: 'long_term', reason: `Code distance ${d} requires ~${d*d*2} physical qubits per logical (2030+)` };
+      if (d > 15)   return { tier: 'mid_term', reason: `Code distance ${d} requires ~${d*d*2} physical qubits per logical (2027-2029)` };
+      if (d > 7)    return { tier: 'near_term', reason: `Code distance ${d} within reach of current 100+ qubit processors` };
+      if (d >= 3)   return { tier: 'current', reason: `Code distance ${d} demonstrated (Google Willow d=7, 2024)` };
+      return null;
+    },
+  },
+  // ── T-gate count (circuit depth proxy) ────────────────────────────────────
+  {
+    id: 'rule_tgate_count',
+    test: (claim) => {
+      const t = claim.parameters?.tgateCount;
+      if (typeof t !== 'number') return null;
+      if (t > 1e12)  return { tier: 'speculative', reason: `${t.toExponential()} T-gates exceeds feasible runtime even at FTQC` };
+      if (t > 1e9)   return { tier: 'long_term', reason: `${t.toExponential()} T-gates requires large-scale FTQC (Shor RSA-2048 scale)` };
+      if (t > 1e6)   return { tier: 'mid_term', reason: `${t.toExponential()} T-gates requires early FTQC (FeMoco-scale)` };
+      if (t > 1e4)   return { tier: 'near_term', reason: `${t.toExponential()} T-gates requires small FTQC` };
+      return { tier: 'current', reason: `${t} T-gates within NISQ+ range` };
+    },
+  },
+  // ── Coherence time ────────────────────────────────────────────────────────
+  {
+    id: 'rule_coherence',
+    test: (claim) => {
+      const T1 = claim.parameters?.T1_s;
+      if (typeof T1 !== 'number') return null;
+      if (T1 > 1000)  return { tier: 'speculative', reason: `T1=${T1}s exceeds any demonstrated qubit` };
+      if (T1 > 100)   return { tier: 'long_term', reason: `T1=${T1}s exceeds current best trapped ions (~100s)` };
+      if (T1 > 1)     return { tier: 'near_term', reason: `T1=${T1}s achievable with trapped ions / nuclear-spin neutral atoms` };
+      if (T1 > 0.001) return { tier: 'current', reason: `T1=${(T1*1000).toFixed(1)}ms within superconducting / neutral atom range` };
+      return { tier: 'current', reason: `T1=${(T1*1e6).toFixed(0)}µs typical transmon` };
+    },
+  },
+  // ── Error rate (physical) ─────────────────────────────────────────────────
+  {
+    id: 'rule_error_rate',
+    test: (claim) => {
+      const e = claim.parameters?.physicalErrorRate;
+      if (typeof e !== 'number') return null;
+      if (e < 1e-6) return { tier: 'speculative', reason: `Physical error ${e.toExponential()} below any demonstrated qubit` };
+      if (e < 1e-4) return { tier: 'long_term', reason: `Physical error ${e.toExponential()} requires topological or major advances` };
+      if (e < 1e-3) return { tier: 'near_term', reason: `Physical error ${e.toExponential()} within reach of improved transmons/ions` };
+      if (e < 1e-2) return { tier: 'current', reason: `Physical error ${e.toExponential()} typical of current superconducting qubits` };
+      return { tier: 'speculative', reason: `Physical error ${e.toExponential()} above QEC threshold (1%)` };
+    },
+  },
+  // ── Qubit modality maturity ───────────────────────────────────────────────
+  {
+    id: 'rule_modality',
+    test: (claim) => {
+      const m = claim.parameters?.modality;
+      if (!m) return null;
+      const maturity = {
+        'superconducting_transmon': 'current',
+        'trapped_ion': 'current',
+        'neutral_atom': 'current',
+        'photonic': 'mid_term',
+        'silicon_spin': 'near_term',
+        'topological': 'long_term',
+        'NV_center': 'mid_term',
+      };
+      const tier = maturity[m];
+      if (!tier) return null;
+      const reasons = {
+        current: `${m}: demonstrated at scale (IBM, Google, IonQ, Atom)`,
+        near_term: `${m}: promising; requires 1-3 years maturation (silicon spin)`,
+        mid_term: `${m}: 3-8 years from scalable computation (photonic, NV)`,
+        long_term: `${m}: 8-20 years; fundamental R&D ongoing (topological)`,
+      };
+      return { tier, reason: reasons[tier] };
+    },
+  },
+  // ── Quantum advantage claim ───────────────────────────────────────────────
+  {
+    id: 'rule_advantage_claim',
+    test: (claim) => {
+      if (!claim.parameters?.claimsAdvantage) return null;
+      const problem = claim.parameters?.advantageProblem ?? 'unknown';
+      const demonstrated = ['RCS', 'GBS', 'random_circuit_sampling'];
+      if (demonstrated.includes(problem)) {
+        return { tier: 'current', reason: `Quantum advantage for ${problem} already demonstrated (Google 2019, USTC 2020, Xanadu 2022)` };
+      }
+      const practical = ['chemistry', 'optimization', 'ML', 'factoring'];
+      if (practical.includes(problem)) {
+        return { tier: 'long_term', reason: `Practical quantum advantage for ${problem} requires 4K+ logical qubits (2035+)` };
+      }
+      return { tier: 'mid_term', reason: `Quantum advantage for ${problem}: unproven; requires further research` };
+    },
+  },
+];
+
+export class ResourceFeasibilityChecker extends EventEmitter {
+  constructor(opts = {}) {
+    super();
+    this.kg = opts.kg ?? null;
+  }
+
+  /**
+   * Assess a hypothesis or design proposal.
+   * @param {object} claim  – { statement, parameters, supportingConcepts, ... }
+   * @returns {object} verdict
+   */
+  async assess(claim) {
+    const anchors = this._findAnchors(claim);
+    const ruleResults = FEASIBILITY_RULES
+      .map(rule => rule.test(claim))
+      .filter(r => r !== null);
+
+    // Pick the most pessimistic tier
+    const tierOrder = ['current', 'near_term', 'mid_term', 'long_term', 'speculative'];
+    let worstTier = 'current';
+    for (const r of ruleResults) {
+      if (tierOrder.indexOf(r.tier) > tierOrder.indexOf(worstTier)) worstTier = r.tier;
+    }
+    // If no anchors found and no rules fired, default to speculative
+    if (anchors.length === 0 && ruleResults.length === 0) worstTier = 'speculative';
+    else if (anchors.length === 0) worstTier = tierOrder[Math.max(tierOrder.indexOf(worstTier), 2)];
+
+    const costEstimate = this._estimateCost(claim, worstTier);
+    const timelineEstimate = this._estimateTimeline(worstTier);
+    const resourceProfile = this._resourceProfile(claim, worstTier);
+    const crossLinks = this._verifyCrossLinks(claim);
+
+    const verdict = {
+      tier: worstTier,
+      confidence: this._confidence(anchors.length, ruleResults.length, crossLinks),
+      anchors,
+      ruleResults,
+      gaps: this._findGaps(claim, anchors),
+      costEstimate,
+      timelineEstimate,
+      resourceProfile,
+      crossLinks,
+      patentEligible: worstTier !== 'speculative'
+        && anchors.length >= 1
+        && crossLinks.linkedConcepts >= 1,
+    };
+
+    this.emit('assessed', { claim, verdict });
+    return verdict;
+  }
+
+  _findAnchors(claim) {
+    const found = [];
+    const text = `${claim.statement ?? ''} ${JSON.stringify(claim.parameters ?? {})} ${(claim.supportingConcepts ?? []).join(' ')}`.toLowerCase();
+    for (const [id, anchor] of Object.entries(RESOURCE_ANCHORS)) {
+      const label = (anchor.label ?? id).toLowerCase();
+      const keywords = [id.toLowerCase().replace(/_/g, ' '), label.split('(')[0].trim()];
+      // Also match on modality
+      if (anchor.modality) keywords.push(anchor.modality.toLowerCase().replace(/_/g, ' '));
+      if (keywords.some(k => text.includes(k))) found.push({ id, ...anchor });
+    }
+    return found;
+  }
+
+  _findGaps(claim, anchors) {
+    const gaps = [];
+    const p = claim.parameters ?? {};
+    if (p.physicalQubits > 10000 && !anchors.find(a => a.id === 'IBM_Condor' || a.id === 'Atom_Computing_1180' || a.id === 'PsiQuantum_Omega')) {
+      gaps.push('Kilo-to-mega-qubit scale-up: requires new cryogenic wiring (cryo-CMOS) and calibration automation');
+    }
+    if (p.modality === 'superconducting_transmon' && p.physicalQubits > 1000 && !anchors.find(a => a.id === 'Dilution_Refrigerators')) {
+      gaps.push('Dilution refrigerator capacity: current systems cool ~1000 qubits; >10K needs modular cryogenics');
+    }
+    if (p.modality === 'topological' && !anchors.find(a => a.id === 'Microsoft_Majorana1')) {
+      gaps.push('Topological qubit validation: Majorana zero modes need unambiguous braiding demonstration');
+    }
+    if (p.logicalQubits > 10 && (p.codeDistance ?? 0) < 5) {
+      gaps.push('Code distance must increase to ≥5 for multiple logical qubits with useful error rates');
+    }
+    if (p.tgateCount > 1e6 && !anchors.find(a => a.id === 'Google_Willow' || a.id === 'Quantinuum_H2')) {
+      gaps.push('Fault-tolerant gate infrastructure: T-gate factories (magic state distillation) at scale');
+    }
+    if (p.modality === 'silicon_spin' && !anchors.find(a => a.id === 'Intel_Spin_TunnelFalls')) {
+      gaps.push('Silicon spin qubit 2-qubit gate fidelity improvement (currently ~99%, need 99.9%+)');
+    }
+    return gaps;
+  }
+
+  _estimateCost(claim, tier) {
+    const base = {
+      current: 5e6,          // $5M (single chip experiment)
+      near_term: 5e7,        // $50M (small processor + team)
+      mid_term: 5e8,         // $500M (100-qubit FTQC prototype)
+      long_term: 5e9,        // $5B (1K logical qubits)
+      speculative: 5e10,     // $50B+ (RSA-scale)
+    };
+    return {
+      low: base[tier] ?? 1e7,
+      high: (base[tier] ?? 1e7) * 10,
+      currency: 'USD',
+      note: 'Order-of-magnitude estimate; refine with bottom-up EPC + cryogenics + control electronics analysis.',
+    };
+  }
+
+  _estimateTimeline(tier) {
+    return {
+      current: '0-2 years',
+      near_term: '2-5 years',
+      mid_term: '5-10 years',
+      long_term: '10-20 years',
+      speculative: '>20 years or unknown',
+    }[tier] ?? 'unknown';
+  }
+
+  _resourceProfile(claim) {
+    const p = claim.parameters ?? {};
+    return {
+      physicalQubits: p.physicalQubits ?? null,
+      logicalQubits: p.logicalQubits ?? null,
+      codeDistance: p.codeDistance ?? null,
+      tgateCount: p.tgateCount ?? null,
+      modality: p.modality ?? 'unknown',
+      cryoRequired: ['superconducting_transmon', 'topological', 'silicon_spin'].includes(p.modality),
+      operatingTemp: p.modality === 'photonic' ? '300K'
+                   : p.modality === 'trapped_ion' ? '4K (vacuum)'
+                   : p.modality === 'neutral_atom' ? 'µK (magneto-optical trap)'
+                   : '10-20mK (dilution refrigerator)',
+    };
+  }
+
+  _verifyCrossLinks(claim) {
+    // quantum-spherifier principle: nothing stays isolated
+    const concepts = claim.supportingConcepts ?? [];
+    const kgHits = this.kg
+      ? concepts.filter(c => this.kg.nodes.has(c)).length
+      : 0;
+    return {
+      linkedConcepts: kgHits,
+      totalConcepts: concepts.length,
+      sufficient: kgHits >= 1,
+      note: kgHits >= 1
+        ? 'Solution is cross-linked to the quantum knowledge graph.'
+        : 'WARNING: solution is isolated — no KG concepts referenced. Enforce cross-linking.',
+    };
+  }
+
+  _confidence(anchorCount, ruleCount, crossLinks) {
+    const base = Math.min(1.0, 0.25 + 0.12 * anchorCount + 0.08 * ruleCount);
+    const linkBonus = crossLinks.linkedConcepts >= 1 ? 0.10 : -0.15;
+    return Math.round(Math.max(0, Math.min(1, base + linkBonus)) * 100) / 100;
+  }
+}
+
+export { FEASIBILITY_RULES };