@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-ZDSYWBIE.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+// src/math/vec3.ts
+function vec3NormalizeInPlace(v) {
+  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len > 1e-8) {
+    v[0] /= len;
+    v[1] /= len;
+    v[2] /= len;
+  }
+  return len;
+}
+function vec3Normalize(v) {
+  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len === 0) return [0, 0, 0];
+  return [v[0] / len, v[1] / len, v[2] / len];
+}
+function vec3Length(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+}
+function vec3Cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function vec3CrossArray(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function vec3Sub(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function vec3SubArray(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function vec3Add(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+function vec3Scale(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
+function vec3ScaleArray(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
+function vec3Distance(a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const dz = b[2] - a[2];
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function vec3Dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+exports.vec3Add = vec3Add;
+exports.vec3Cross = vec3Cross;
+exports.vec3CrossArray = vec3CrossArray;
+exports.vec3Distance = vec3Distance;
+exports.vec3Dot = vec3Dot;
+exports.vec3Length = vec3Length;
+exports.vec3Normalize = vec3Normalize;
+exports.vec3NormalizeInPlace = vec3NormalizeInPlace;
+exports.vec3Scale = vec3Scale;
+exports.vec3ScaleArray = vec3ScaleArray;
+exports.vec3Sub = vec3Sub;
+exports.vec3SubArray = vec3SubArray;
+//# sourceMappingURL=chunk-ZDSYWBIE.cjs.map
+//# sourceMappingURL=chunk-ZDSYWBIE.cjs.map

package/dist/chunk-ZU7NIRT6.js

@@ -0,0 +1,325 @@
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+
+// src/compiler/QuantumCircuitCompiler.ts
+init_CompilerBase();
+function qubitsForMolecule(atoms) {
+  const orbitalCount = atoms.reduce((sum, a) => {
+    if (a.symbol === "H") return sum + 1;
+    if (["C", "N", "O", "F"].includes(a.symbol)) return sum + 5;
+    return sum + 9;
+  }, 0);
+  return orbitalCount * 2;
+}
+function extractNumber(config, key) {
+  const entry = config[key];
+  if (!entry) return void 0;
+  const v = entry.value;
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = parseFloat(v);
+    return isNaN(n) ? void 0 : n;
+  }
+  return void 0;
+}
+function extractAtoms(config) {
+  const entry = config["molecule"] ?? config["atoms"];
+  if (!entry) return void 0;
+  let raw = entry.value;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(raw)) return void 0;
+  return raw.filter(
+    (a) => typeof a === "object" && a !== null && typeof a["symbol"] === "string"
+  );
+}
+function extractWeightMatrix(config) {
+  const entry = config["weightMatrix"] ?? config["weight_matrix"] ?? config["adjacency"];
+  if (!entry) return void 0;
+  let raw = entry.value;
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(raw)) return void 0;
+  if (!raw.every((row) => Array.isArray(row))) return void 0;
+  return raw;
+}
+function generateVQECircuit(atoms, moleculeName, ansatzLayers, initialParams) {
+  const warnings = [];
+  let numQubits = qubitsForMolecule(atoms);
+  if (numQubits > 50) {
+    warnings.push(
+      `Molecule requires ${numQubits} qubits which exceeds the 50-qubit cap. Clamping to 50. Use classical QM for larger systems.`
+    );
+    numQubits = 50;
+  }
+  if (numQubits > 20) {
+    warnings.push(
+      `Circuit uses ${numQubits} qubits  -  near-term hardware is limited to ~20 qubits without error correction. Consider a smaller basis set.`
+    );
+  }
+  const n = numQubits;
+  const totalParams = ansatzLayers * n;
+  const paramNames = [];
+  for (let i = 0; i < totalParams; i++) {
+    paramNames.push(`theta_${i}`);
+  }
+  const lines = [];
+  lines.push("OPENQASM 3.0;");
+  lines.push('include "stdgates.inc";');
+  lines.push(`// Hardware-efficient ansatz for ${moleculeName} (${n} qubits, sto-3g)`);
+  lines.push("// Generated by HoloScript QuantumCircuitCompiler");
+  lines.push(`qubit[${n}] q;`);
+  lines.push(`bit[${n}] c;`);
+  lines.push(`// Parameters: bindable by optimizer (initial values are defaults)`);
+  for (let i = 0; i < totalParams; i++) {
+    const defaultVal = initialParams?.[i] ?? 0.1;
+    lines.push(`input float theta_${i}; // default=${defaultVal}`);
+  }
+  let paramIdx = 0;
+  for (let layer = 0; layer < ansatzLayers; layer++) {
+    lines.push(`// Layer ${layer}: Ry rotations ( - [${paramIdx}..${paramIdx + n - 1}] optimised by VQE)`);
+    for (let i = 0; i < n; i++) {
+      lines.push(`ry(theta_${paramIdx}) q[${i}];`);
+      paramIdx++;
+    }
+    if (layer < ansatzLayers - 1 || n > 1) {
+      lines.push(`// Entanglement: linear CNOT chain`);
+      for (let i = 0; i < n - 1; i++) {
+        lines.push(`cx q[${i}], q[${i + 1}];`);
+      }
+    }
+  }
+  lines.push("// Measurement");
+  lines.push("c = measure q;");
+  const estimatedDepth = ansatzLayers * 2 + 1;
+  return { qasm: lines.join("\n"), numQubits: n, estimatedDepth, warnings, paramNames };
+}
+function generateQAOACircuit(weightMatrix, p, initialGamma, initialBeta) {
+  const warnings = [];
+  let n = weightMatrix.length;
+  if (n > 100) {
+    warnings.push(
+      `Graph has ${n} nodes which exceeds the 100-qubit cap. Clamping to 100. Use classical solvers for larger instances.`
+    );
+    n = 100;
+    weightMatrix = weightMatrix.slice(0, 100).map((row) => row.slice(0, 100));
+  }
+  if (n > 50) {
+    warnings.push(
+      `Circuit uses ${n} qubits  -  near-term hardware handles ~50 qubits without error correction.`
+    );
+  }
+  const defaultGamma = initialGamma ?? 0.5;
+  const defaultBeta = initialBeta ?? 0.5;
+  const paramNames = [];
+  for (let round = 0; round < p; round++) {
+    paramNames.push(`gamma_${round}`);
+    paramNames.push(`beta_${round}`);
+  }
+  const lines = [];
+  lines.push("OPENQASM 3.0;");
+  lines.push('include "stdgates.inc";');
+  lines.push(`// QAOA Max-Cut circuit for ${n}-node graph (p=${p})`);
+  lines.push("// Generated by HoloScript QuantumCircuitCompiler");
+  lines.push(`qubit[${n}] q;`);
+  lines.push(`bit[${n}] c;`);
+  lines.push("// Parameters: bindable by optimizer (initial values are defaults)");
+  for (let round = 0; round < p; round++) {
+    lines.push(`input float gamma_${round}; // default=${defaultGamma}`);
+    lines.push(`input float beta_${round}; // default=${defaultBeta}`);
+  }
+  lines.push("// Initial superposition");
+  for (let i = 0; i < n; i++) {
+    lines.push(`h q[${i}];`);
+  }
+  for (let round = 0; round < p; round++) {
+    lines.push(`// Problem unitary  -  round ${round + 1} (gamma=gamma_${round})`);
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const w = weightMatrix[i]?.[j] ?? 0;
+        if (w !== 0) {
+          lines.push(`// Edge (${i},${j}) weight=${w}: rzz(2.0*gamma_${round}*${w.toFixed(4)})`);
+          lines.push(`cx q[${i}], q[${j}];`);
+          lines.push(`rz(2.0 * gamma_${round} * ${w.toFixed(4)}) q[${j}];`);
+          lines.push(`cx q[${i}], q[${j}];`);
+        }
+      }
+    }
+    lines.push(`// Mixer unitary  -  round ${round + 1} (beta=beta_${round})`);
+    for (let i = 0; i < n; i++) {
+      lines.push(`rx(2.0 * beta_${round}) q[${i}];`);
+    }
+  }
+  lines.push("// Measurement");
+  lines.push("c = measure q;");
+  const edgeCount = weightMatrix.flat().filter((w) => w !== 0).length / 2;
+  const estimatedDepth = 1 + p * (Math.ceil(edgeCount * 3) + 1) + 1;
+  return { qasm: lines.join("\n"), numQubits: n, estimatedDepth, warnings, paramNames };
+}
+function generateStubCircuit() {
+  const qasm = [
+    "OPENQASM 3.0;",
+    'include "stdgates.inc";',
+    "// Stub circuit: no @quantumCircuit trait found in composition",
+    "// Generated by HoloScript QuantumCircuitCompiler",
+    "qubit[1] q;",
+    "bit[1] c;",
+    "h q[0];",
+    "c = measure q;"
+  ].join("\n");
+  return {
+    qasm,
+    warnings: [
+      "No @quantumCircuit (or @quantum_circuit) trait found in the composition. A stub 1-qubit circuit has been emitted. Add a @quantumCircuit trait with `molecule` or `weightMatrix` params to generate a real circuit."
+    ]
+  };
+}
+var QuantumCircuitCompiler = class extends CompilerBase {
+  constructor() {
+    super(...arguments);
+    this.compilerName = "QuantumCircuitCompiler";
+  }
+  /**
+   * Compile a HoloScript composition to an OpenQASM 3.0 circuit.
+   *
+   * The method scans `composition.objects` for the first object that carries a
+   * `@quantumCircuit` or `@quantum_circuit` trait. Trait params drive the type:
+   *   - `molecule` (or `atoms`)  -  VQE hardware-efficient ansatz
+   *   - `weightMatrix` / `weight_matrix` / `adjacency` / `numNodes`  -  QAOA Max-Cut
+   *   - none of the above  -  stub 1-qubit circuit with a warning
+   *
+   * @param composition - Parsed HoloScript AST
+   * @param agentToken  - JWT RBAC token or UCAN CapabilityTokenCredential (optional)
+   * @param outputPath  - Optional path for output-scope RBAC check
+   * @param _sceneGraph - Unused (reserved for future scene-graph hints)
+   * @returns {@link QASMOutput}
+   */
+  compile(composition, agentToken, outputPath, _sceneGraph) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const quantum = this.findQuantumTrait(composition.objects ?? []);
+    if (!quantum) {
+      const { qasm: qasm2, warnings: warnings2 } = generateStubCircuit();
+      return {
+        qasm: qasm2,
+        numQubits: 1,
+        numClbits: 1,
+        estimatedDepth: 2,
+        circuitType: "custom",
+        recommendedBackend: "aer",
+        warnings: warnings2
+      };
+    }
+    const { trait } = quantum;
+    const cfg = trait.config;
+    const atoms = extractAtoms(cfg);
+    const weightMatrix = extractWeightMatrix(cfg);
+    const numNodes = extractNumber(cfg, "numNodes") ?? extractNumber(cfg, "num_nodes");
+    if (atoms && atoms.length > 0) {
+      return this.buildVQEOutput(atoms, cfg);
+    }
+    if (weightMatrix) {
+      return this.buildQAOAOutput(weightMatrix, cfg);
+    }
+    if (numNodes !== void 0 && numNodes > 0) {
+      const n = Math.min(Math.round(numNodes), 100);
+      const matrix = Array.from(
+        { length: n },
+        (_, i) => Array.from({ length: n }, (_2, j) => i !== j ? 1 : 0)
+      );
+      return this.buildQAOAOutput(matrix, cfg);
+    }
+    const { qasm, warnings } = generateStubCircuit();
+    warnings.unshift(
+      "@quantumCircuit trait found but neither `molecule`/`atoms` nor `weightMatrix`/`numNodes` params are present. Add params to generate a circuit."
+    );
+    return {
+      qasm,
+      numQubits: 1,
+      numClbits: 1,
+      estimatedDepth: 2,
+      circuitType: "custom",
+      recommendedBackend: "aer",
+      warnings
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Walk `objects` (and their children) recursively, returning the first object
+   * that has a `@quantumCircuit` or `@quantum_circuit` trait, plus the trait.
+   */
+  findQuantumTrait(objects) {
+    for (const obj of objects) {
+      for (const trait of obj.traits ?? []) {
+        if (trait.name === "quantumCircuit" || trait.name === "quantum_circuit") {
+          return { obj, trait };
+        }
+      }
+      if (obj.children && obj.children.length > 0) {
+        const found = this.findQuantumTrait(obj.children);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
+  /** Build a {@link QASMOutput} for a VQE circuit. */
+  buildVQEOutput(atoms, cfg) {
+    const moleculeName = (extractNumber(cfg, "moleculeName") !== void 0 ? void 0 : cfg["moleculeName"]?.value) ?? atoms.map((a) => a.symbol).join("") ?? "molecule";
+    const ansatzLayers = Math.max(1, Math.round(extractNumber(cfg, "ansatzLayers") ?? extractNumber(cfg, "ansatz_layers") ?? 2));
+    const initialParams = cfg["initialParams"]?.value ?? cfg["initial_params"]?.value ?? void 0;
+    const { qasm, numQubits, estimatedDepth, warnings, paramNames } = generateVQECircuit(
+      atoms,
+      moleculeName,
+      ansatzLayers,
+      initialParams
+    );
+    return {
+      qasm,
+      numQubits,
+      numClbits: numQubits,
+      estimatedDepth,
+      circuitType: "vqe",
+      molecule: { atoms },
+      recommendedBackend: numQubits <= 20 ? "aer" : "ibm-quantum",
+      warnings,
+      paramNames
+    };
+  }
+  /** Build a {@link QASMOutput} for a QAOA circuit. */
+  buildQAOAOutput(weightMatrix, cfg) {
+    const p = Math.max(1, Math.round(extractNumber(cfg, "p") ?? 1));
+    const initialGamma = extractNumber(cfg, "gamma") ?? extractNumber(cfg, "initial_gamma");
+    const initialBeta = extractNumber(cfg, "beta") ?? extractNumber(cfg, "initial_beta");
+    const { qasm, numQubits, estimatedDepth, warnings, paramNames } = generateQAOACircuit(
+      weightMatrix,
+      p,
+      initialGamma,
+      initialBeta
+    );
+    return {
+      qasm,
+      numQubits,
+      numClbits: numQubits,
+      estimatedDepth,
+      circuitType: "qaoa",
+      weightMatrix,
+      recommendedBackend: numQubits <= 50 ? "aer" : "ibm-quantum",
+      warnings,
+      paramNames
+    };
+  }
+};
+
+export { QuantumCircuitCompiler };
+//# sourceMappingURL=chunk-ZU7NIRT6.js.map
+//# sourceMappingURL=chunk-ZU7NIRT6.js.map