dense-evolution 8.3.1__tar.gz → 8.3.2__tar.gz

{dense_evolution-8.3.1 → dense_evolution-8.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dense-evolution
-Version: 8.3.1
+Version: 8.3.2
 Summary: High-performance quantum simulation toolkit -- Statevector/MPS engines with JIT compilation, noise modeling, VQE, QEC, quantum chemistry, and agent-native tooling
 Author-email: Salvatore Pennacchio <jtatopenn@libero.it>
 License: Business Source License 1.1
@@ -46,6 +46,8 @@ Requires-Dist: qiskit>=1.0.0; extra == "qiskit"
 Provides-Extra: pennylane
 Requires-Dist: pennylane>=0.35.0; extra == "pennylane"
 Requires-Dist: basis_set_exchange>=0.9; extra == "pennylane"
+Provides-Extra: hf
+Requires-Dist: basis_set_exchange>=0.9; extra == "hf"
 Provides-Extra: stim
 Requires-Dist: stim>=1.13.0; extra == "stim"
 Provides-Extra: pymatching
@@ -99,7 +101,7 @@ Requires-Dist: rdkit>=2023.9.1; extra == "docs"
 Dynamic: license-file
 
 <p align="center">
-  <img src="docs/assets/banner.svg" alt="Dense Evolution — NISQ quantum simulation toolkit, JAX-native" width="900">
+  <img src="docs/assets/banner.png" alt="Dense Evolution — NISQ quantum simulation toolkit, JAX-native" width="900">
 </p>
 
 
@@ -111,8 +113,8 @@ Statevector/MPS engines with compilation, noise, VQE, QEC, chemistry, and agent-
 <p align="center">
   <img src="docs/assets/favicon.svg" width="32" alt=""><br>
   <b>Download the Dense Evolution Dashboard (Streamlit)</b><br>
-  <a href="https://github.com/tatopenn-cell/Dense-Evolution/raw/main/tools/installer/install-dashboard.bat">Windows (.bat)</a> &middot;
-  <a href="https://github.com/tatopenn-cell/Dense-Evolution/raw/main/tools/installer/install-dashboard.sh">macOS / Linux (.sh)</a>
+  <a href="https://tatopenn-cell.github.io/Dense-Evolution/assets/installer/install-dashboard.bat">Windows (.bat)</a> &middot;
+  <a href="https://tatopenn-cell.github.io/Dense-Evolution/assets/installer/install-dashboard.sh">macOS / Linux (.sh)</a>
 </p>
 
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
@@ -165,6 +167,9 @@ pip install dense-evolution[full]
 pip install dense-evolution[qiskit]
 pip install dense-evolution[pennylane]
 
+# native Hartree-Fock (basis-set data)
+pip install dense-evolution[hf]
+
 # Composer's local kernel (see "Composer" below)
 pip install dense-evolution[composer]
 
@@ -302,8 +307,8 @@ sim.run_chunk(circuit.to_tuples(), chunk_size_gates=500)
 - **Anti-OOM `Chunk` engine.** Circuits too large for one array, split dynamically and sized off the real compute device's own free memory — with disk-backed overflow past even that ceiling. [Chunk guide](https://tatopenn-cell.github.io/Dense-Evolution/api/chunk/).
 - **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation, with the shot budget split optimally across noise factors and a single-qubit Bloch-vector variant that always returns a valid state, to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
 - **Differentiable VQE, from scratch.** `circuit_to_energy_fn` is the same JAX-differentiable engine real molecular VQE runs on — real Hartree-Fock Hamiltonians, UCCSD/hardware-efficient ansätze, Adam optimization. [Autodiff](https://tatopenn-cell.github.io/Dense-Evolution/api/autodiff/).
-- **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
-- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations and checked against the Vedral, Cuccaro, Draper and Beauregard circuits. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
+- **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. Open-shell molecules with UHF and ROHF (`run_uhf`, `run_cuhf`). [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
+- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations, and as OPENQASM 2.0 gate circuits (Cuccaro, Draper and Beauregard adders, controlled modular multiplication), up to Shor order finding with one control qubit. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
 - **Postselection.** Keep the branch where a qubit is found in `|0>`, `|1>`, `|±>` or `|±i>`, with its probability. [Postselection](https://tatopenn-cell.github.io/Dense-Evolution/api/postselect/).
 - **OpenQASM 2.0/3.0, both directions.** A real parser, plus Qiskit/PennyLane interop bridges. [QASM Parser](https://tatopenn-cell.github.io/Dense-Evolution/api/parser/) · [Interop](https://tatopenn-cell.github.io/Dense-Evolution/api/interop/).
 - **Code-agnostic QEC decoding**, Majorana/Jordan-Wigner fermion mapping, from-scratch Hartree-Fock for elements outside PennyLane's own basis set, a traversable-wormhole-inspired teleportation protocol, and real QM/MM region partitioning (ring-safe BFS, Diffuse2Seg-derived relevance propagation) — see the [full API reference](https://tatopenn-cell.github.io/Dense-Evolution/api/) for all of it.

{dense_evolution-8.3.1 → dense_evolution-8.3.2}/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/assets/banner.svg" alt="Dense Evolution — NISQ quantum simulation toolkit, JAX-native" width="900">
+  <img src="docs/assets/banner.png" alt="Dense Evolution — NISQ quantum simulation toolkit, JAX-native" width="900">
 </p>
 
 
@@ -11,8 +11,8 @@ Statevector/MPS engines with compilation, noise, VQE, QEC, chemistry, and agent-
 <p align="center">
   <img src="docs/assets/favicon.svg" width="32" alt=""><br>
   <b>Download the Dense Evolution Dashboard (Streamlit)</b><br>
-  <a href="https://github.com/tatopenn-cell/Dense-Evolution/raw/main/tools/installer/install-dashboard.bat">Windows (.bat)</a> &middot;
-  <a href="https://github.com/tatopenn-cell/Dense-Evolution/raw/main/tools/installer/install-dashboard.sh">macOS / Linux (.sh)</a>
+  <a href="https://tatopenn-cell.github.io/Dense-Evolution/assets/installer/install-dashboard.bat">Windows (.bat)</a> &middot;
+  <a href="https://tatopenn-cell.github.io/Dense-Evolution/assets/installer/install-dashboard.sh">macOS / Linux (.sh)</a>
 </p>
 
 [![CI](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml/badge.svg)](https://github.com/tatopenn-cell/Dense-Evolution/actions/workflows/ci.yml)
@@ -65,6 +65,9 @@ pip install dense-evolution[full]
 pip install dense-evolution[qiskit]
 pip install dense-evolution[pennylane]
 
+# native Hartree-Fock (basis-set data)
+pip install dense-evolution[hf]
+
 # Composer's local kernel (see "Composer" below)
 pip install dense-evolution[composer]
 
@@ -202,8 +205,8 @@ sim.run_chunk(circuit.to_tuples(), chunk_size_gates=500)
 - **Anti-OOM `Chunk` engine.** Circuits too large for one array, split dynamically and sized off the real compute device's own free memory — with disk-backed overflow past even that ceiling. [Chunk guide](https://tatopenn-cell.github.io/Dense-Evolution/api/chunk/).
 - **Real noise, real mitigation.** Stochastic Kraus channels, real-device noise imported from Qiskit backends, and Zero-Noise Extrapolation, with the shot budget split optimally across noise factors and a single-qubit Bloch-vector variant that always returns a valid state, to correct for it. [Noise](https://tatopenn-cell.github.io/Dense-Evolution/api/noise/) · [Mitigation](https://tatopenn-cell.github.io/Dense-Evolution/api/mitigation/) · [what noise/mitigation/healing each mean](https://tatopenn-cell.github.io/Dense-Evolution/concepts/).
 - **Differentiable VQE, from scratch.** `circuit_to_energy_fn` is the same JAX-differentiable engine real molecular VQE runs on — real Hartree-Fock Hamiltonians, UCCSD/hardware-efficient ansätze, Adam optimization. [Autodiff](https://tatopenn-cell.github.io/Dense-Evolution/api/autodiff/).
-- **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
-- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations and checked against the Vedral, Cuccaro, Draper and Beauregard circuits. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
+- **libcint integrals on Windows, macOS and Linux.** `pip install dense-evolution` ships libcint compiled for each system: the full two-electron tensor of ethanol in 6-31G* in 0.32 s. Open-shell molecules with UHF and ROHF (`run_uhf`, `run_cuhf`). [native_hf](https://tatopenn-cell.github.io/Dense-Evolution/api/native_hf/).
+- **Reversible arithmetic.** Register adders, subtraction, comparisons and modular arithmetic up to modular exponentiation, applied as exact basis permutations, and as OPENQASM 2.0 gate circuits (Cuccaro, Draper and Beauregard adders, controlled modular multiplication), up to Shor order finding with one control qubit. [Arithmetic](https://tatopenn-cell.github.io/Dense-Evolution/api/arithmetic/).
 - **Postselection.** Keep the branch where a qubit is found in `|0>`, `|1>`, `|±>` or `|±i>`, with its probability. [Postselection](https://tatopenn-cell.github.io/Dense-Evolution/api/postselect/).
 - **OpenQASM 2.0/3.0, both directions.** A real parser, plus Qiskit/PennyLane interop bridges. [QASM Parser](https://tatopenn-cell.github.io/Dense-Evolution/api/parser/) · [Interop](https://tatopenn-cell.github.io/Dense-Evolution/api/interop/).
 - **Code-agnostic QEC decoding**, Majorana/Jordan-Wigner fermion mapping, from-scratch Hartree-Fock for elements outside PennyLane's own basis set, a traversable-wormhole-inspired teleportation protocol, and real QM/MM region partitioning (ring-safe BFS, Diffuse2Seg-derived relevance propagation) — see the [full API reference](https://tatopenn-cell.github.io/Dense-Evolution/api/) for all of it.

{dense_evolution-8.3.1 → dense_evolution-8.3.2}/dense_evolution/__init__.py

@@ -50,6 +50,11 @@ from .circuits.arithmetic import (
     compare_registers, compare_constant,
     add_registers_mod, add_constant_mod, multiply_add_mod, multiply_mod, power_mod,
 )
+from .circuits.arithmetic_qasm import (
+    cuccaro_adder_qasm, draper_adder_qasm, constant_adder_qasm, modular_constant_adder_qasm,
+    cmult_mod_qasm, controlled_ua_qasm,
+)
+from .circuits.shor import shor_order_finding
 from .circuits.postselect import postselect
 from .circuits.random_circuit import random_circuit
 from .utils.drawing import draw_circuit
@@ -68,7 +73,7 @@ from .physics.qec import (pauli_commutes, compute_syndrome, erasure_aware_decode
                    peeling_decode, union_find_decode, matching_erasure_decode,
                            estimate_edge_probabilities_from_detection_events)
 
-__version__ = "8.3.1"
+__version__ = "8.3.2"
 
 __all__ = [
     "__version__",
@@ -84,6 +89,8 @@ __all__ = [
     "add_registers", "subtract_registers", "add_constant",
     "compare_registers", "compare_constant",
     "add_registers_mod", "add_constant_mod", "multiply_add_mod", "multiply_mod", "power_mod",
+    "cuccaro_adder_qasm", "draper_adder_qasm", "constant_adder_qasm", "modular_constant_adder_qasm",
+    "cmult_mod_qasm", "controlled_ua_qasm", "shor_order_finding",
     "postselect",
     "pauli_rotation_ops", "trotter_evolve_ops", "continuous_pulse_evolve",
     "continuous_dissipative_evolve",

{dense_evolution-8.3.1 → dense_evolution-8.3.2}/dense_evolution/circuits/__init__.py

@@ -10,6 +10,11 @@ from .arithmetic import (
     compare_registers, compare_constant,
     add_registers_mod, add_constant_mod, multiply_add_mod, multiply_mod, power_mod,
 )
+from .arithmetic_qasm import (
+    cuccaro_adder_qasm, draper_adder_qasm, constant_adder_qasm, modular_constant_adder_qasm,
+    cmult_mod_qasm, controlled_ua_qasm,
+)
+from .shor import shor_order_finding
 from .postselect import postselect
 from .random_circuit import random_circuit
 from .trotter import pauli_rotation_ops, trotter_evolve_ops
@@ -24,6 +29,8 @@ __all__ = [
     "add_registers", "subtract_registers", "add_constant",
     "compare_registers", "compare_constant",
     "add_registers_mod", "add_constant_mod", "multiply_add_mod", "multiply_mod", "power_mod",
+    "cuccaro_adder_qasm", "draper_adder_qasm", "constant_adder_qasm", "modular_constant_adder_qasm",
+    "cmult_mod_qasm", "controlled_ua_qasm", "shor_order_finding",
     "postselect",
     "random_circuit",
     "pauli_rotation_ops", "trotter_evolve_ops",

dense_evolution-8.3.2/dense_evolution/circuits/arithmetic_qasm.py

@@ -0,0 +1,227 @@
+"""
+Reversible arithmetic as gate circuits, written as OPENQASM 2.0.
+
+`arithmetic.py` applies each operation as a basis permutation
+|x> -> |f(x)>: exact, but not a circuit. The functions here return the
+gate-level circuits of the original papers as OPENQASM 2.0 text, to be read
+with `QASMParser` and run, noised, counted or exported like any other
+circuit. Each one is checked exhaustively against the matching permutation
+in `arithmetic.py`.
+
+Registers are separate `qreg` declarations, least significant bit first
+(`b[0]` is the lowest bit), so the parser's flattened qubit list matches the
+register lists `arithmetic.py` takes.
+
+References
+----------
+Cuccaro, Draper, Kutin, Moulton, quant-ph/0410184 (ripple-carry adder).
+Draper, quant-ph/0008033 (addition on a quantum computer, QFT adder).
+Beauregard, quant-ph/0205095 (circuit for Shor's algorithm using 2n+3 qubits).
+"""
+import math
+import re
+
+__all__ = [
+    "cuccaro_adder_qasm", "draper_adder_qasm",
+    "constant_adder_qasm", "modular_constant_adder_qasm",
+    "cmult_mod_qasm", "controlled_ua_qasm",
+]
+
+_HEADER = 'OPENQASM 2.0;\ninclude "qelib1.inc";\n'
+
+_MAJ = "gate maj c, b, a { cx a, b; cx a, c; ccx c, b, a; }\n"
+_UMA = "gate uma c, b, a { ccx c, b, a; cx a, c; cx c, b; }\n"
+
+
+def _check_n(n):
+    if int(n) != n or n < 1:
+        raise ValueError(f"n must be a positive integer, got {n!r}.")
+
+
+def _qft(reg, m):
+    lines = []
+    for k in range(m - 1, -1, -1):
+        lines.append(f"h {reg}[{k}];")
+        for j in range(k - 1, -1, -1):
+            lines.append(f"cp({math.pi / 2 ** (k - j)!r}) {reg}[{j}], {reg}[{k}];")
+    return lines
+
+
+def _iqft(reg, m):
+    lines = []
+    for k in range(m):
+        for j in range(k):
+            lines.append(f"cp({-math.pi / 2 ** (k - j)!r}) {reg}[{j}], {reg}[{k}];")
+        lines.append(f"h {reg}[{k}];")
+    return lines
+
+
+def _ccp(theta, c1, c2, target):
+    return [f"cp({theta / 2!r}) {c2}, {target};", f"cx {c1}, {c2};",
+            f"cp({-theta / 2!r}) {c2}, {target};", f"cx {c1}, {c2};",
+            f"cp({theta / 2!r}) {c1}, {target};"]
+
+
+def _phi_add(reg, m, c, controls=()):
+    lines = []
+    for k in range(m):
+        theta = 2 * math.pi * (c % 2 ** (k + 1)) / 2 ** (k + 1)
+        if theta == 0.0:
+            continue
+        target = f"{reg}[{k}]"
+        if not controls:
+            lines.append(f"p({theta!r}) {target};")
+        elif len(controls) == 1:
+            lines.append(f"cp({theta!r}) {controls[0]}, {target};")
+        else:
+            lines += _ccp(theta, controls[0], controls[1], target)
+    return lines
+
+
+def _phi_add_mod(reg, m, c, N, t, controls=()):
+    msb = f"{reg}[{m - 1}]"
+    lines = _phi_add(reg, m, c, controls) + _phi_add(reg, m, -N)
+    lines += _iqft(reg, m) + [f"cx {msb}, {t};"] + _qft(reg, m)
+    lines += _phi_add(reg, m, N, (t,)) + _phi_add(reg, m, -c, controls)
+    lines += _iqft(reg, m) + [f"x {msb};", f"cx {msb}, {t};", f"x {msb};"] + _qft(reg, m)
+    return lines + _phi_add(reg, m, c, controls)
+
+
+def _cmult(a, N, n, control):
+    lines = _qft("b", n + 1)
+    for i in range(n):
+        lines += _phi_add_mod("b", n + 1, (2 ** i * a) % N, N, "t[0]", (control, f"x[{i}]"))
+    return lines + _iqft("b", n + 1)
+
+
+_ANGLE = re.compile(r"^(c?p)\((.+?)\) ")
+
+
+def _inverse(lines):
+    return [_ANGLE.sub(lambda mt: f"{mt.group(1)}({-float(mt.group(2))!r}) ", line) for line in reversed(lines)]
+
+
+def _check_modular(n, N):
+    _check_n(n)
+    if not 0 < N < 2 ** n:
+        raise ValueError(f"need 0 < N < 2^n = {2 ** n}, got N={N}.")
+
+
+def cuccaro_adder_qasm(n):
+    """
+    Ripple-carry adder |a, b, 0> -> |a, a + b, 0> of Cuccaro et al.
+    (quant-ph/0410184, Fig. 1-4): MAJ gates carry the sum up, UMA gates
+    undo them and write each sum bit.
+
+    Registers: `a[n]`, `b[n+1]` (b[n] receives the carry out, so the sum
+    never overflows) and one ancilla `x[1]`, initially 0 and returned to 0.
+    2n Toffoli gates and 4n + 1 CNOTs. Matches
+    `arithmetic.add_registers(sv, 2n + 2, a, b)`.
+    """
+    _check_n(n)
+    lines = [f"qreg a[{n}];", f"qreg b[{n + 1}];", "qreg x[1];",
+             "maj x[0], b[0], a[0];"]
+    lines += [f"maj a[{i - 1}], b[{i}], a[{i}];" for i in range(1, n)]
+    lines.append(f"cx a[{n - 1}], b[{n}];")
+    lines += [f"uma a[{i - 1}], b[{i}], a[{i}];" for i in range(n - 1, 0, -1)]
+    lines.append("uma x[0], b[0], a[0];")
+    return _HEADER + _MAJ + _UMA + "\n".join(lines) + "\n"
+
+
+def draper_adder_qasm(n):
+    """
+    QFT adder |a, b> -> |a, a + b> of Draper (quant-ph/0008033): b is
+    taken to Fourier space, each bit of a adds its phase with controlled
+    rotations, and the inverse QFT brings the sum back. No ancilla, no
+    carry gates.
+
+    Registers: `a[n]`, `b[n+1]` (b[n] holds the carry, so the sum never
+    overflows). Matches `arithmetic.add_registers(sv, 2n + 1, a, b)`.
+    """
+    _check_n(n)
+    m = n + 1
+    lines = [f"qreg a[{n}];", f"qreg b[{m}];"] + _qft("b", m)
+    for i in range(n):
+        lines += _phi_add("b", m, 2 ** i, (f"a[{i}]",))
+    lines += _iqft("b", m)
+    return _HEADER + "\n".join(lines) + "\n"
+
+
+def constant_adder_qasm(c, n):
+    """
+    Adds a classical integer, |b> -> |(b + c) mod 2^n>: Beauregard's
+    phiADD(c) (quant-ph/0205095, Fig. 3), one phase gate per qubit of b in
+    Fourier space, between a QFT and an inverse QFT.
+
+    Register: `b[n]`. Matches `arithmetic.add_constant(sv, n, b, c)`.
+    """
+    _check_n(n)
+    lines = [f"qreg b[{n}];"] + _qft("b", n) + _phi_add("b", n, int(c)) + _iqft("b", n)
+    return _HEADER + "\n".join(lines) + "\n"
+
+
+def modular_constant_adder_qasm(c, N, n):
+    """
+    Modular addition of a classical integer, |b, 0> -> |(b + c) mod N, 0>
+    for 0 <= b < N and 0 <= c < N: Beauregard's phiADD(c)MOD(N)
+    (quant-ph/0205095, Fig. 5, here without the two controls), between a
+    QFT and an inverse QFT.
+
+    Registers: `b[n+1]` (one bit more than N needs, used as the sign of
+    b + c - N) and one ancilla `t[1]`, initially 0 and returned to 0.
+    Requires N < 2^n. On inputs with b < N it matches
+    `arithmetic.add_constant_mod(sv, n + 2, b[:n], c, N)`; inputs with
+    b >= N are outside the circuit's contract.
+    """
+    c, N = int(c), int(N)
+    _check_modular(n, N)
+    if not 0 <= c < N:
+        raise ValueError(f"need 0 <= c < N, got c={c}, N={N}.")
+    m = n + 1
+    lines = [f"qreg b[{m}];", "qreg t[1];"] + _qft("b", m)
+    lines += _phi_add_mod("b", m, c, N, "t[0]") + _iqft("b", m)
+    return _HEADER + "\n".join(lines) + "\n"
+
+
+def cmult_mod_qasm(a, N, n):
+    """
+    Controlled modular multiply-add, |c, x, b, 0> -> |c, x, (b + a*x) mod N, 0>
+    when c = 1 and unchanged when c = 0, for 0 <= b < N: Beauregard's
+    CMULT(a)MOD(N) (quant-ph/0205095, Fig. 6), n doubly controlled
+    phiADD(2^i a mod N)MOD(N) gates (Fig. 5) controlled by c and x[i],
+    between a QFT and an inverse QFT on b.
+
+    Registers: `c[1]`, `x[n]`, `b[n+1]` (b[n] is the sign bit, 0 on input
+    and output) and one ancilla `t[1]`, initially 0 and returned to 0.
+    Requires N < 2^n. On inputs with b < N it matches
+    `arithmetic.multiply_add_mod(sv, 2n + 3, x, b[:n], a, N, controls=(c,))`.
+    """
+    a, N = int(a), int(N)
+    _check_modular(n, N)
+    lines = ["qreg c[1];", f"qreg x[{n}];", f"qreg b[{n + 1}];", "qreg t[1];"]
+    return _HEADER + "\n".join(lines + _cmult(a % N, N, n, "c[0]")) + "\n"
+
+
+def controlled_ua_qasm(a, N, n):
+    """
+    Controlled modular multiplication in place, |c, x, 0, 0> ->
+    |c, (a*x) mod N, 0, 0> when c = 1, unchanged when c = 0, for 0 <= x < N
+    and gcd(a, N) = 1: Beauregard's controlled-U_a (quant-ph/0205095, Fig. 7).
+    CMULT(a)MOD(N) writes a*x into b, a controlled swap exchanges x and b,
+    and the inverse of CMULT(a^-1 mod N)MOD(N) clears b back to 0.
+
+    Registers as in `cmult_mod_qasm`: `c[1]`, `x[n]`, `b[n+1]`, `t[1]`, with
+    b and t starting and ending at 0: 2n + 3 qubits, the count of the paper.
+    Matches `arithmetic.multiply_mod(sv, 2n + 3, x, a, N, controls=(c,))` on
+    inputs with x < N and b = t = 0.
+    """
+    a, N = int(a), int(N)
+    _check_modular(n, N)
+    if math.gcd(a, N) != 1:
+        raise ValueError(f"a={a} has no inverse modulo N={N}.")
+    swap = []
+    for i in range(n):
+        swap += [f"cx b[{i}], x[{i}];", f"ccx c[0], x[{i}], b[{i}];", f"cx b[{i}], x[{i}];"]
+    lines = ["qreg c[1];", f"qreg x[{n}];", f"qreg b[{n + 1}];", "qreg t[1];"]
+    lines += _cmult(a % N, N, n, "c[0]") + swap + _inverse(_cmult(pow(a, -1, N), N, n, "c[0]"))
+    return _HEADER + "\n".join(lines) + "\n"

dense_evolution-8.3.2/dense_evolution/circuits/shor.py

@@ -0,0 +1,70 @@
+"""
+Order finding for Shor's algorithm with one control qubit (Beauregard,
+quant-ph/0205095, Sect. 2.5, Fig. 8): 2n + 3 qubits in total.
+
+The 2n control qubits of the textbook circuit are replaced by a single one,
+measured and reset after each controlled multiplication; the inverse QFT is
+done semiclassically, a phase gate on that qubit set by the outcomes already
+measured, then a Hadamard and the measurement. Each controlled-U_{a^(2^k)}
+is the gate circuit of `controlled_ua_qasm`.
+"""
+import numpy as np
+
+from .arithmetic_qasm import controlled_ua_qasm
+from .parser import QASMParser
+
+__all__ = ["shor_order_finding"]
+
+
+def _hadamard_on_first(sv):
+    return np.stack([sv[0] + sv[1], sv[0] - sv[1]]) / np.sqrt(2.0)
+
+
+def shor_order_finding(a, N, rng=None, noise_model=None, p=0.0):
+    """
+    One run of quantum order finding for a modulo N, returns
+    (y, m): a measured integer 0 <= y < 2^m with m = 2n, n = N.bit_length().
+    y / 2^m is close to s / r for the order r of a and a random s, so the
+    continued-fraction expansion of y / 2^m recovers r with good probability
+    (`fractions.Fraction(y, 2**m).limit_denominator(N)`).
+
+    Iteration k = m-1, ..., 0 prepares the control in |+>, applies
+    controlled-U_{a^(2^k) mod N} to the work register (initially |1>),
+    applies the phase -2 pi sum_l r_l / 2^(l-k+1) over the bits r_l already
+    measured, a Hadamard, then measures and resets the control.
+
+    With `noise_model` (any model of `NoiseModel.apply_to_sv`, e.g.
+    "depolarizing") and probability `p`, one stochastic trajectory of that
+    channel acts on every qubit after each controlled multiplication, before
+    the control is measured.
+    """
+    from ..backends.statevector import DenseSVSimulator
+    from ..noise import NoiseModel
+
+    a, N = int(a), int(N)
+    n = N.bit_length()
+    m, nq = 2 * n, 2 * n + 3
+    rng = np.random.default_rng(rng)
+    sv = np.zeros((2, 2 ** (nq - 1)), dtype=np.complex128)
+    sv[0, 1 << (nq - 2)] = 1.0
+    bits = {}
+    for k in range(m - 1, -1, -1):
+        sv = _hadamard_on_first(sv)
+        ak = pow(a, 2 ** k, N)
+        if ak != 1:
+            circ = QASMParser().parse(controlled_ua_qasm(ak, N, n))
+            sim = DenseSVSimulator(nq)
+            sim.set_initial_state(sv.reshape(-1))
+            sim.run_circuit_jit(circ.to_tuples())
+            sv = np.asarray(sim.get_statevector()).reshape(2, -1)
+        if noise_model is not None and p > 0:
+            sv = np.asarray(NoiseModel.apply_to_sv(sv.reshape(-1).copy(), nq, noise_model, p, rng=rng)).reshape(2, -1)
+        phase = -2 * np.pi * sum(bits[l] / 2 ** (l - k + 1) for l in bits)
+        sv[1] *= np.exp(1j * phase)
+        sv = _hadamard_on_first(sv)
+        p1 = float(np.sum(np.abs(sv[1]) ** 2))
+        bits[k] = int(rng.random() < p1)
+        kept = sv[bits[k]] / np.sqrt(p1 if bits[k] else 1.0 - p1)
+        sv = np.stack([kept, np.zeros_like(kept)])
+    y = sum(r << (m - 1 - k) for k, r in bits.items())
+    return y, m

{dense_evolution-8.3.1 → dense_evolution-8.3.2}/dense_evolution/native_hf/basis.py

@@ -17,7 +17,6 @@ itself: N = 1/sqrt(<primitive|primitive>).
 
 import dataclasses
 
-import basis_set_exchange as bse
 import jax
 import jax.numpy as jnp
 import numpy as np
@@ -77,7 +76,19 @@ def _contracted_shell_from_bse(shell: dict, center: jax.Array, atom_index: int)
     return shells
 
 
+def _bse():
+    try:
+        import basis_set_exchange
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError(
+            "dense_evolution.native_hf needs basis_set_exchange for basis-set data: "
+            "pip install dense-evolution[hf]"
+        ) from exc
+    return basis_set_exchange
+
+
 def load_element_shells(basis_name: str, atomic_number: int, center: jax.Array, atom_index: int) -> list[ContractedShell]:
+    bse = _bse()
     data = bse.get_basis(basis_name, elements=[atomic_number])
     electron_shells = data["elements"][str(atomic_number)]["electron_shells"]