zeropoint-node 1.0.10 → 1.0.12

package/src/quantum/advantage.ts

@@ -0,0 +1,271 @@
+/**
+ * Quantum advantage, counted rather than claimed.
+ *
+ * "Quantum advantage" is one of the most overstated phrases in computing, and
+ * this module exists to say exactly how much of it this repository can
+ * demonstrate. It does not argue. It wraps the oracle in a counter, runs the
+ * simulator's own algorithms, and reports how many times each one asked.
+ *
+ * THE ONE THING THAT IS PROVEN. In the QUERY MODEL — where cost is the number
+ * of oracle calls and nothing else — there are separations that are theorems,
+ * not conjectures:
+ *
+ *   Grover          Θ(√N) quantum against Θ(N) classical. The lower bound is
+ *                   Bennett–Bernstein–Brassard–Vazirani: no quantum algorithm
+ *                   beats √N for unstructured search, so the gap is exactly
+ *                   quadratic and cannot be improved.
+ *   Deutsch–Jozsa   1 quantum query against 2^(n-1)+1 classical WORST CASE —
+ *                   but only against DETERMINISTIC EXACT classical algorithms.
+ *                   A randomised classical algorithm decides it in a constant
+ *                   number of queries with bounded error, so this famous
+ *                   "exponential separation" collapses the moment the classical
+ *                   side is allowed to be wrong occasionally. That caveat is
+ *                   usually dropped, and dropping it is the overstatement.
+ *
+ * WHAT IS NOT PROVEN. Shor's algorithm factors in polynomial time, and the
+ * repository implements it. That is NOT a proven advantage: no one has shown
+ * factoring is hard classically. The separation is conditional on an unproven
+ * assumption, and calling it proven — or calling factoring NP-complete, which
+ * it is not known to be — is the error this module is written against.
+ *
+ * AND THE MEASUREMENT REFUTED MY OWN PREMISE. This module was written to count
+ * the simulator's oracle calls and show the advantage. It shows the opposite,
+ * and that is the finding:
+ *
+ *   Grover n=10          25 600 simulated oracle calls vs 1 024 classical
+ *   Deutsch-Jozsa n=10    1 024 simulated oracle calls vs   513 classical
+ *
+ * A simulator applies the oracle to EVERY basis state of the amplitude vector,
+ * so one "quantum query" costs 2^n classical evaluations. Simulated query
+ * counts are therefore strictly WORSE than classical, always, by construction.
+ * Quantum advantage is a property of hardware that holds the superposition; it
+ * is not something a classical simulation can exhibit, and any repository
+ * claiming to demonstrate it by simulation is measuring the wrong thing.
+ *
+ * So this module reports two different quantities and never conflates them:
+ * the ALGORITHM's query count, which is where the theorem lives, and the
+ * SIMULATION's oracle calls, which is what running it here actually costs.
+ */
+
+import { groverSearch, deutschJozsa, groverIterations } from './algorithms.ts'
+
+// ============================================================================
+// COUNTING
+// ============================================================================
+
+/** An oracle wrapped so every call is counted. */
+function counted<T extends (x: number) => unknown>(f: T): { fn: T; calls: () => number } {
+  let n = 0
+  const fn = ((x: number) => {
+    n += 1
+    return f(x)
+  }) as T
+  return { fn, calls: () => n }
+}
+
+export interface QueryComparison {
+  /** Number of qubits, so the search space is 2^n. */
+  readonly qubits: number
+  /** Size of the space searched. */
+  readonly space: number
+  /**
+   * Queries the ALGORITHM makes — what the theorem counts. On hardware this is
+   * the cost; here it is derived from the algorithm, not observed.
+   */
+  readonly algorithmQueries: number
+  /**
+   * Oracle calls the SIMULATION actually made. Larger than the algorithm's
+   * count by a factor of the state-vector size, because simulating one query
+   * means evaluating the oracle on every basis state.
+   */
+  readonly simulatedOracleCalls: number
+  /** Oracle calls a classical algorithm needs in the worst case. */
+  readonly classicalWorstCase: number
+  /** Whether the algorithm returned the right answer. */
+  readonly correct: boolean
+}
+
+// ============================================================================
+// GROVER — a proven quadratic separation
+// ============================================================================
+
+/**
+ * Run Grover for one marked item and count the oracle calls.
+ *
+ * Classical worst case for unstructured search over N items is N: an adversary
+ * puts the marked item last. Grover's is the iteration count, which the
+ * simulator derives from N rather than taking on faith.
+ */
+export function groverQueries(qubits: number, target: number): QueryComparison {
+  const space = 1 << qubits
+  const oracle = counted((x: number) => x === target)
+  const result = groverSearch(qubits, oracle.fn as (x: number) => boolean, 1)
+
+  // The most likely basis state after the run.
+  let best = 0
+  let bestWeight = -1
+  if (result !== null) {
+    for (let i = 0; i < result.amps.length; i++) {
+      const a = result.amps[i]!
+      const weight = a.re * a.re + a.im * a.im
+      if (weight > bestWeight) { bestWeight = weight; best = i }
+    }
+  }
+
+  return {
+    qubits,
+    space,
+    algorithmQueries: groverIterations(space),
+    simulatedOracleCalls: oracle.calls(),
+    classicalWorstCase: space,
+    correct: result !== null && best === target,
+  }
+}
+
+// ============================================================================
+// DEUTSCH–JOZSA — exponential, but only against exact classical algorithms
+// ============================================================================
+
+/**
+ * Run Deutsch–Jozsa and count the oracle calls.
+ *
+ * Classical worst case for a DETERMINISTIC EXACT answer is 2^(n-1)+1: having
+ * seen half the inputs agree, one more disagreement still decides it. A
+ * randomised classical algorithm needs only a constant number, so the
+ * separation reported here is against exact classical algorithms alone.
+ */
+export function deutschJozsaQueries(qubits: number, balanced: boolean): QueryComparison {
+  const space = 1 << qubits
+  // Constant: always 0. Balanced: the parity of the input, which is 0 on
+  // exactly half the domain.
+  const f = balanced
+    ? (x: number): 0 | 1 => {
+        let bits = 0
+        for (let b = 0; b < qubits; b++) bits ^= (x >> b) & 1
+        return (bits & 1) as 0 | 1
+      }
+    : (): 0 | 1 => 0
+
+  const oracle = counted(f as (x: number) => unknown)
+  const verdict = deutschJozsa(qubits, oracle.fn as (x: number) => 0 | 1)
+
+  return {
+    qubits,
+    space,
+    algorithmQueries: 1,
+    simulatedOracleCalls: oracle.calls(),
+    classicalWorstCase: space / 2 + 1,
+    correct: verdict === (balanced ? 'balanced' : 'constant'),
+  }
+}
+
+// ============================================================================
+// WHAT EACH SEPARATION RESTS ON
+// ============================================================================
+
+export type Standing =
+  /** A theorem in the query model. Both bounds are proved. */
+  | 'proven'
+  /** Proved only against a restricted classical adversary. */
+  | 'proven-against-exact-classical'
+  /** Fast quantumly; no classical lower bound is known. */
+  | 'conditional'
+
+export interface Separation {
+  readonly algorithm: string
+  readonly standing: Standing
+  readonly note: string
+}
+
+/** The honest status of each separation this repository implements. */
+export const SEPARATIONS: readonly Separation[] = [
+  {
+    algorithm: 'Grover',
+    standing: 'proven',
+    note:
+      'Θ(√N) against Θ(N). The BBBV lower bound shows no quantum algorithm does better than √N, ' +
+      'so the quadratic gap is exact and final rather than a current best effort.',
+  },
+  {
+    algorithm: 'Deutsch-Jozsa',
+    standing: 'proven-against-exact-classical',
+    note:
+      '1 query against 2^(n-1)+1, but only if the classical algorithm must be exact and ' +
+      'deterministic. Allowed bounded error, a classical algorithm needs O(1). Quoting the ' +
+      'exponential without that condition is the usual overstatement.',
+  },
+  {
+    algorithm: 'Shor',
+    standing: 'conditional',
+    note:
+      'Polynomial-time factoring quantumly, with NO proof that factoring is classically hard. ' +
+      'Factoring is not known to be NP-complete, so Shor does not place NP in P and does not ' +
+      'imply a general speedup for NP problems.',
+  },
+]
+
+// ============================================================================
+// SELF-CHECK
+// ============================================================================
+
+/** Facts this module must satisfy. Returns failures. */
+export function selfTest(): string[] {
+  const fail: string[] = []
+
+  for (const qubits of [3, 4, 5, 6]) {
+    const target = (1 << qubits) - 1 // adversarial: the last item
+    const r = groverQueries(qubits, target)
+    if (!r.correct) fail.push(`grover n=${qubits} did not find the target`)
+
+    // The ALGORITHM beats classical. This is where the theorem lives.
+    if (!(r.algorithmQueries < r.classicalWorstCase)) {
+      fail.push(`grover n=${qubits}: ${r.algorithmQueries} algorithm queries, not below ${r.classicalWorstCase}`)
+    }
+
+    // The SIMULATION does not, and must be recorded as not doing so. If this
+    // ever flips, the simulator has stopped evaluating the oracle over the
+    // whole state vector and something is wrong with it, not right.
+    if (!(r.simulatedOracleCalls > r.classicalWorstCase)) {
+      fail.push(
+        `grover n=${qubits}: simulation made ${r.simulatedOracleCalls} calls, which is not above ` +
+          `${r.classicalWorstCase} — a simulator cannot beat classical query cost`,
+      )
+    }
+
+    // One simulated query costs the state-vector size.
+    if (r.simulatedOracleCalls !== r.algorithmQueries * r.space) {
+      fail.push(
+        `grover n=${qubits}: ${r.simulatedOracleCalls} calls is not ${r.algorithmQueries} x ${r.space}`,
+      )
+    }
+  }
+
+  // The ALGORITHM's advantage must widen with n — a constant factor is not a
+  // speedup. Measured on the algorithm count, not the simulation count.
+  const small = groverQueries(3, 7)
+  const large = groverQueries(6, 63)
+  if (!(large.classicalWorstCase - large.algorithmQueries > small.classicalWorstCase - small.algorithmQueries)) {
+    fail.push('grover algorithmic advantage does not widen with n')
+  }
+
+  for (const balanced of [true, false]) {
+    const r = deutschJozsaQueries(4, balanced)
+    if (!r.correct) fail.push(`deutsch-jozsa balanced=${balanced} gave the wrong verdict`)
+    if (r.algorithmQueries !== 1) fail.push('deutsch-jozsa algorithm query count is not 1')
+    // Again: the simulation pays the full space, so it cannot be the cheaper side.
+    if (!(r.simulatedOracleCalls >= r.space)) {
+      fail.push(`deutsch-jozsa: simulation made ${r.simulatedOracleCalls} calls, expected at least ${r.space}`)
+    }
+  }
+
+  const shor = SEPARATIONS.find((s) => s.algorithm === 'Shor')
+  if (!shor || shor.standing !== 'conditional') fail.push('Shor is not recorded as conditional')
+  const dj = SEPARATIONS.find((s) => s.algorithm === 'Deutsch-Jozsa')
+  if (!dj || dj.standing !== 'proven-against-exact-classical') {
+    fail.push('Deutsch-Jozsa is not recorded with its classical-exactness condition')
+  }
+  const grover = SEPARATIONS.find((s) => s.algorithm === 'Grover')
+  if (!grover || grover.standing !== 'proven') fail.push('Grover is not recorded as proven')
+
+  return fail
+}

package/src/quantum/index.ts

@@ -57,3 +57,13 @@ export {
   executeInSuperposition,
   describeQuantumExecution,
 } from './superposition-execution.ts'
+
+// Named rather than star-exported: `selfTest` exists in several modules here,
+// and an ambiguous star export silently drops every one of them.
+export type { QueryComparison, Separation, Standing } from './advantage.ts'
+export {
+  groverQueries,
+  deutschJozsaQueries,
+  SEPARATIONS,
+  selfTest as advantageSelfTest,
+} from './advantage.ts'

package/src/quantum/millennium-bridge.ts

@@ -46,14 +46,29 @@ export function layer1_riemannSimulator(): RiemannLayer {
 /**
  * P vs NP: Can every problem verifiable in polynomial time be solved in polynomial time?
  *
- * Maps to: Quantum Algorithms
- * Why: Shor (NP → P for factoring), Grover (speedup for search)
- * Gap: Algorithm definitions exist but not end-to-end tested
- * Solution: P vs NP gap IS the algorithm completeness gap
+ * Maps to: Quantum Algorithms — as a NAMING, not a result. Three corrections,
+ * because the previous version of this comment stated two things that are false
+ * and one that is misleading:
  *
- * Shor proves factoring is in BQP (Quantum Polynomial)
- * If NP ⊆ BQP, then Shor solves the NP-completeness problem
- * Grover gives quadratic speedup for any search (generic NP solver)
+ *   "Shor (NP → P for factoring)" is wrong twice over. Factoring is not known
+ *   to be NP-complete — it sits in NP ∩ co-NP, which is strong evidence it is
+ *   NOT NP-complete — so solving it settles nothing about NP. And Shor puts
+ *   factoring in BQP, not in P; those are different classes.
+ *
+ *   "Grover ... (generic NP solver)" is wrong. Grover is a QUADRATIC speedup on
+ *   brute force: 2^n becomes 2^(n/2), which is still exponential. That is not
+ *   polynomial time and does not solve NP-complete problems efficiently. The
+ *   BBBV lower bound proves no quantum algorithm does better on unstructured
+ *   search, so this is a ceiling rather than a starting point.
+ *
+ *   "If NP ⊆ BQP, then Shor solves the NP-completeness problem" is a
+ *   conditional whose antecedent is an open question widely believed false.
+ *   Stating it beside two claimed results reads as though it followed from
+ *   them. It does not.
+ *
+ * What IS true: Shor places factoring in BQP, and no classical lower bound for
+ * factoring is known, so the speedup is conditional. See src/quantum/advantage.ts,
+ * which counts the queries and records which separations are theorems.
  */
 
 export interface PvsNPLayer {

package/src/quantum/orchestrator.ts

@@ -251,11 +251,22 @@ export function feedbackAndImprove(
   const boost = 0.05 // 5% improvement per iteration
   const decay = 0.98 // Strong layers maintain, don't overfit
 
-  let updated = { ...state }
+  // `{ ...state }` copies the TOP LEVEL only, so the copy's `layer_states` was
+  // the same object as the caller's. Both loops then assigned into it, and this
+  // function — which takes a state and returns a new one — mutated the state it
+  // was given. Measured: after one call, the input's layer_states had changed.
+  // The readonly types were reporting exactly that, and the fix is a second
+  // copy rather than a cast.
+  //
+  // Note on the names: `suppress` is the WEAK set (quality < 0.7) and gets the
+  // boost, `amplify` is the STRONG set (> 0.8) and gets the decay. That reads
+  // backwards but is correct — the fields classify the interference, they do
+  // not name the action taken here, which is what the comments above describe.
+  const layer_states = { ...state.layer_states }
 
   for (const layer_name of interference.suppress) {
     const key = layer_name as keyof typeof state.layer_states
-    updated.layer_states[key] = {
+    layer_states[key] = {
       working: true,
       quality: min(1, state.layer_states[key].quality + boost),
     }
@@ -263,14 +274,13 @@ export function feedbackAndImprove(
 
   for (const layer_name of interference.amplify) {
     const key = layer_name as keyof typeof state.layer_states
-    updated.layer_states[key] = {
+    layer_states[key] = {
       working: true,
       quality: state.layer_states[key].quality * decay,
     }
   }
 
-  // Iterate
-  updated = { ...updated, iteration: state.iteration + 1 }
+  const updated = { ...state, layer_states, iteration: state.iteration + 1 }
 
   // Re-entangle with new state
   return entangleLayerOutputs(updated)

package/src/vbm-math.ts

@@ -7,6 +7,7 @@
 
 import { pathToFileURL } from 'node:url'
 import { abs, pow } from './0/algebra.ts'
+import { VORTEX_ORBIT, VORTEX_AXIS } from './0/index.ts'
 import { legacyDigitalRoot } from './0/3/6/9/1/2/4/8/7/5/1/a432.roots.ts'
 
 export class VortexMath {
@@ -41,10 +42,14 @@ export class VortexMath {
     }
 
     /**
-     * Get the core Mobius Circuit pattern [1,2,4,8,7,5]
+     * The core Mobius circuit — the kernel's VORTEX_ORBIT, not a second copy.
+     *
+     * This returned a literal, so it was one of 91 places in the tree holding
+     * its own copy of a constant the kernel already exports. Bound rather than
+     * retyped, it cannot drift from the definition.
      */
     static getMobiusCircuit(): number[] {
-        return [1, 2, 4, 8, 7, 5];
+        return [...VORTEX_ORBIT];
     }
 
     /**
@@ -52,7 +57,7 @@ export class VortexMath {
      * These numbers form the higher dimensional control axis in VBM
      */
     static getSpiritNumbers(): number[] {
-        return [3, 6, 9];
+        return [...VORTEX_AXIS];
     }
 
     /**

package/src/verification/lean-bridge.ts

@@ -32,6 +32,11 @@
 import { createHash } from 'node:crypto'
 import { digitalRoot, throughVoid, bearingForDigit, VORTEX_SEQUENCE, VORTEX_ORBIT, VORTEX_AXIS } from '../0/index.ts'
 import { angleForDigit } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import { A432Sequence } from '../0/3/6/9/1/2/4/8/7/5/1/a432.utils.ts'
+import { getTrinityAxis } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import { a432RodinCoil } from '../0/3/6/9/1/2/4/8/7/5/1/a432.coil.ts'
+import { a432Shears } from '../0/3/6/9/1/2/4/8/7/5/1/a432.shear.ts'
+import { a432ElectronShear } from '../0/3/6/9/1/2/4/8/7/5/1/a432.shear.electron.ts'
 import { foldToLean, leanIsFixed } from '../kernel/import-graph.ts'
 import {
   GIBBS_FORMATION,
@@ -69,6 +74,10 @@ import {
   STEANE_CODE,
   symplecticProduct,
   estimateSurfaceCodeThreshold,
+  groverQueries,
+  deutschJozsaQueries,
+  SEPARATIONS,
+  advantageSelfTest,
   executeInSuperposition,
   computeInterferencePattern,
   describeQuantumExecution,
@@ -471,6 +480,63 @@ export const SEALS: Record<string, Seal> = {
       return TRIAD.every((t) => reflected.includes(t))
     },
   },
+  a432_vortex_is_the_doubling_orbit: {
+    basis: "A432Sequence.generateVortex returned digitalRoot(i + 1) — the counting sequence 1..9 — under the name 'vortex'. Two things gave it away: it was byte-identical to generateConsciousness(9), and it contained 3, 6 and 9, which doubling_avoids_the_triad proves the doubling circuit can never reach. Nothing caught it because no test in the repository names it and the a432 surface has no tests at all. This binds the a432 layer's vortex to the kernel's VORTEX_ORBIT so the two cannot drift apart again.",
+    decide: () => {
+      // One period. Must BE the kernel's orbit — not merely orbit-shaped.
+      const period = A432Sequence.generateVortex(VORTEX_ORBIT.length)
+      if (period.join() !== VORTEX_ORBIT.join()) return false
+
+      // The bug's own signature: the triad must be absent. This is the
+      // conjunct that the counting sequence fails, so it is what makes the
+      // seal falsifiable rather than decorative. VORTEX_AXIS is narrowed to
+      // 3 | 6 | 9, so it is widened to compare against arbitrary digits.
+      const TRIAD: readonly number[] = VORTEX_AXIS
+      if (period.some((d) => TRIAD.includes(d))) return false
+
+      // Every term a unit mod 9, which is why the triad is unreachable.
+      if (period.some((d) => d % 3 === 0)) return false
+
+      // It is the doubling map, step by step, not a list that happens to match.
+      for (let i = 0; i < period.length; i++) {
+        if (digitalRoot(period[i]! * 2) !== period[(i + 1) % period.length]!) return false
+      }
+
+      // Period 6: asking for more repeats the circuit rather than continuing to
+      // count. The old implementation ran 1..9 and then wrapped, so length 12
+      // is where the two disagree most visibly.
+      const twice = A432Sequence.generateVortex(VORTEX_ORBIT.length * 2)
+      if (twice.slice(0, VORTEX_ORBIT.length).join() !== twice.slice(VORTEX_ORBIT.length).join()) return false
+
+      // And it must no longer be the counting sequence wearing the name.
+      return A432Sequence.generateVortex(9).join() !== A432Sequence.generateConsciousness(9).join()
+    },
+  },
+  a432_constants_do_not_drift_from_the_kernel: {
+    basis: "An isolated collision trial over all 198 a432 modules found the kernel's constants RETYPED as literals in module after module: [1,2,4,8,7,5] in a432.coil, [3,6,9] in a432.trinity, [1,4,7] in both a432.shear and a432.shear.electron. Each retyped copy is a place that can drift with nothing noticing, which is exactly how generateVortex became the counting sequence. Some modules already bind to the kernel — a432.string.theory returns VORTEX_ORBIT itself and cannot drift — so this seal holds the literal copies to the same standard by recomputing the agreement instead of trusting it.",
+    decide: () => {
+      // The doubling circuit, retyped as a literal in a432.coil.
+      if (a432RodinCoil().join() !== VORTEX_ORBIT.join()) return false
+
+      // The triad. a432.math derives it by slicing A432_SEQUENCE, so this also
+      // pins that sequence's ordering, not just the three digits.
+      if (getTrinityAxis().join() !== VORTEX_AXIS.join()) return false
+
+      // [1,4,7] is not a kernel constant, so it is derived rather than
+      // compared to another literal: it is exactly the set that reflection
+      // through the void carries ONTO the triad. Computing the preimage is
+      // what keeps this from being one hardcoded array checked against another.
+      const preimage = VORTEX_AXIS.map((t) => throughVoid(t)).sort((a, b) => a - b)
+      if (a432Shears().slice().sort((a, b) => a - b).join() !== preimage.join()) return false
+      if (a432ElectronShear().join() !== a432Shears().join()) return false
+
+      // And the preimage must actually reflect back onto the triad, so the
+      // relation is verified in both directions rather than assumed from the
+      // fact that throughVoid produced it.
+      const TRIAD: readonly number[] = VORTEX_AXIS
+      return preimage.every((n) => TRIAD.includes(throughVoid(n)))
+    },
+  },
   superposition_reports_its_own_state: {
     basis: "the superposition model's prose must follow its measurement, not assert simultaneity regardless. Collapse is decided by one comparison — interference against the threshold — and the description must claim 'all at once' exactly when that comparison says so. While anything is still open the sequence has not computed all at once, and the text must say that.",
     decide: () => {
@@ -774,6 +840,43 @@ export const SEALS: Record<string, Seal> = {
       return leanIsFixed(full, ['r'])
     },
   },
+  simulation_shows_no_query_advantage: {
+    basis: "the algorithm's query count beats classical and the SIMULATION's does not, and both are checked. Grover asks about sqrt(N) times as an algorithm, against N classically — a proven separation with a matching BBBV lower bound. Simulating one such query costs 2^n oracle evaluations, so the simulation makes MORE calls than classical, always, by construction. A repository that claimed to demonstrate quantum advantage by simulation would be measuring the wrong quantity, so this seal requires the simulation to lose.",
+    decide: () => {
+      if (advantageSelfTest().length > 0) return false
+
+      for (const qubits of [4, 6, 8]) {
+        const r = groverQueries(qubits, (1 << qubits) - 1)
+        if (!r.correct) return false
+        // The algorithm wins.
+        if (!(r.algorithmQueries < r.classicalWorstCase)) return false
+        // The simulation loses, and must — one query costs the state vector.
+        if (!(r.simulatedOracleCalls > r.classicalWorstCase)) return false
+        if (r.simulatedOracleCalls !== r.algorithmQueries * r.space) return false
+      }
+
+      // The algorithmic gap widens; a constant factor would not be a speedup.
+      const a = groverQueries(4, 15)
+      const b = groverQueries(8, 255)
+      if (!(b.classicalWorstCase - b.algorithmQueries > a.classicalWorstCase - a.algorithmQueries)) return false
+
+      // Deutsch-Jozsa: one algorithmic query, and the simulation pays the space.
+      const dj = deutschJozsaQueries(4, true)
+      if (dj.algorithmQueries !== 1 || !dj.correct) return false
+      if (!(dj.simulatedOracleCalls >= dj.space)) return false
+
+      // Shor must be recorded as CONDITIONAL, and Deutsch-Jozsa's exponential
+      // must carry its exact-classical condition. Dropping either is the
+      // overstatement this seal exists to prevent.
+      const shor = SEPARATIONS.find((x) => x.algorithm === 'Shor')
+      const dozsa = SEPARATIONS.find((x) => x.algorithm === 'Deutsch-Jozsa')
+      const grover = SEPARATIONS.find((x) => x.algorithm === 'Grover')
+      if (shor?.standing !== 'conditional') return false
+      if (dozsa?.standing !== 'proven-against-exact-classical') return false
+      return grover?.standing === 'proven'
+    },
+  },
+
 }
 
 // ============================================================================