Orbital-optimized coupled-cluster circuits

• Choose a parameterised trial state

  Fix the gate structure of a circuit family and leave its rotation angles open. What comes back is not a circuit but the set of states the later optimisation is allowed to search — which is why this is a slot of its own and not a paragraph in one method's write-up.

Mizukami et al. state what is varied and what follows from it. OO-UCC "variationally determines the coupled cluster amplitudes and also molecular orbital coefficients", and "owing to its fully variational nature, first-order properties are readily available" — which they cash out immediately: "this feature allows the optimization of molecular structures in VQE without solving any additional equations". The resource claim is comparative and unquantified in the abstract: "the method requires smaller active space and shallower quantum circuit than UCC to achieve the same accuracy", with no number attached, so none is quoted here. Evidence is simulation, and it is worth naming what was simulated because it is a property calculation rather than a single energy: "numerical examples of OO-UCC using quantum simulators, which include the geometry optimization of the water and ammonia molecules using analytical first derivatives of the VQE".

Every step this method names moves its route along, so there is nothing it needs alongside them.

Mizukami et al. report a quantum-circuit simulation: the geometry optimisation of water and ammonia in the STO-3G basis, run without an active-space approximation so all orbitals were mapped onto qubits, using OO-UCCD truncated at the first Trotter step alongside UCCD and UCCSD for comparison. Qulacs simulated the circuits, PySCF handled the orbital optimisation and the Hamiltonian integrals, and OpenFermion mapped the Hamiltonian to qubits via the Jordan-Wigner transformation. In this ansatz the singles are identical to an orbital-rotation unitary and are optimised on a classical computer from the one- and two-electron reduced density matrices the VQE already measures, while the doubles are optimised by the VQE itself, the two repeated until convergence; because every parameter is variationally determined this way the energy is fully variational, so analytical first derivatives of it were available directly and drove the geometry search. Table I reports the outcome as the RMSD of the optimised Cartesian geometry against FCI, in angstrom, with the energy deviation at that geometry in parentheses: $3.3\times10^{-4}$ ($1.8\times10^{-4}$) for ammonia and $6.7\times10^{-5}$ ($1.0\times10^{-4}$) for water, against $5.1\times10^{-4}$ for plain UCCD on both molecules; OO-UCCD and UCCSD, the paper says, provided “virtually the same geometries and energies for these two systems,” which it glosses elsewhere as reaching FCI to about $3\times10^{-4}$ angstrom in structure and 0.2 millihartree in energy. For ammonia, OO-UCCD and plain UCCD in fact share one circuit — 120 parameters, depth 2720 — against 135 and 2780 for UCCSD; the paper calls that reduction slight, so the real return on the orbital loop is that the smaller circuit reaches UCCSD-level accuracy at all, not that the circuit shrinks further. Neither molecule is ever given a qubit count, and the only description given anywhere for the amplitude-loop optimiser is a generic “non-linear optimizer”; the orbital-VQE alternation runs only “until convergence” with no count of cycles reported, so how many VQE evaluations these numbers actually cost cannot be read off the paper.

Classical simulation · Section III (“Without the active space approximation”), Table I; Section II (“Orbital optimized unitary coupled cluster doubles” and “Analytical first derivatives of energy” subsections); Section I (Introduction) of arXiv:1910.11526

given  molecular Hamiltonian H built from 1- and 2-electron integrals h_pq, h_pqrs
       in a chosen orbital basis;  reference determinant |0>  (conventionally Hartree-Fock)
       UCCSD ansatz  |Psi> = e^(A1+A2) |0>,   A_n = T_n - T_n^dagger        (Eq. 3, Eq. 9)
       a VQE circuit that already measures the 1- and 2-particle RDMs needed below
           # RDMs are "readily available in VQE, because it measures [them] to
           #   compute electronic energy in a given quantum circuit" -- no extra
           #   measurement is added for the orbital step

requires  no formal bound is stated on the outer loop below;
    # optimizing the singles/orbital part classically from the measured RDMs, rather
    #   than varying it on the circuit, is presented as a design choice (Sec. II),
    #   not as something the paper proves necessary

# --- decompose UCCSD into a classical orbital rotation and a Trotterized doubles part ---
model  |Psi'> = e^(A2) e^(A1) |0>                                          (Eq. 10)
    # a distinct wave-function model, not an exact rewrite of e^(A1+A2)|0>:
    #   A1 and A2 do not commute, so separating them "is different from the
    #   original ansatz" (Sec. II)

identify  e^(A1)  with the orbital-rotation operator  e^(kappa)             (Sec. II)
    kappa = sum_pq  kappa_pq (Epq - Eqp),        Epq^- := Epq - Eqp
    # "the singles part e^(A1) ... is identical to the orbital rotation unitary
    #   operator e^kappa" -- so it can be optimized on a classical computer via
    #   standard orbital-optimization technique instead of varied on the circuit

collapse to  |Psi_OOUCCD> = e^(A2~) |0~>,    |0~> = e^(A1) |0>             (Eq. 11)

# --- outer loop: alternate VQE with a classical Newton-Raphson orbital step ---
repeat
    run VQE, optimizing doubles amplitudes A2~ on the circuit  ->  E(A2~, kappa)
    from the 1RDM, 2RDM VQE just measured, form
        g_pq       = <Psi|[H, Epq^-]|Psi>                                  (Eq. 8)
        Hess_pq,rs = (1/2) ( <Psi|[[H,Epq^-],Ers^-]|Psi> + <Psi|[[H,Ers^-],Epq^-]|Psi> )   (Eq. 7)
    solve  Hess kappa_step = -g   for the orbital-rotation step             (Eq. 6, Newton-Raphson)
    kappa <- kappa + kappa_step
until self-consistent
    # "we repeatedly perform the VQE and the orbital optimization until
    #   convergence" -- no cycle-count bound is given (Sec. II);
    #   "UCCSD-level ... results ... at the cost of repeated VQE optimizations" (Sec. III)
    # at self-consistency the singles operator A1~ itself vanishes (the Brueckner
    #   condition) together with dE/dkappa = 0, simultaneously and by construction
    #   of the separation above -- "variational orbitals are Brueckner orbitals
    #   in this ansatz" (Sec. II, 'Trotterization and Brueckner orbitals')
    # the paper's own printed condition is the exponential  e^(A1~) = 0 -- which
    #   cannot literally hold for a unitary exponential of an anti-Hermitian
    #   operator;  read here, per that same sentence's prose ("the singles'
    #   contribution ... vanishes"), as the operator condition  A1~ = 0

# --- map the converged doubles generator onto the circuit ---
Trotterize  e^(A2~)  ~=  prod_mu e^(A2~_mu),   truncated at the first Trotter step   (Eq. 14)
    # this defines OO-UCCD1; a single Trotter step is a large truncation of the
    #   BCH-infinite UCC generator, and this paper proves no bound on the
    #   truncation error -- it cites Barkoutsos et al.'s empirical finding that a
    #   single step "reproduces ground-state energy accurately", and reports its own
    #   numerics (LiH, H2O, NH3) showing OO-UCCD1 tracks UCCSD1 closely (Table I, Fig. 1)

return  the OO-UCCD1 circuit family together with converged (theta, kappa)
        as the trial state for the eigenvalue problem
# because theta and kappa are BOTH variationally converged, the full chain rule
#   dE/dx = dE/dx|_x + (dE/dtheta)(dtheta/dx) + (dE/dkappa)(dkappa/dx)      (Eq. 12)
#   collapses to just the Hellmann-Feynman term:
    dE/dx = <Psi| dH/dx |Psi>                                    # consequence of Eq. 12
    # the d(E)/d(theta) . d(theta)/dx term vanishes because VQE has converged theta;
    #   the d(E)/d(kappa) . d(kappa)/dx term vanishes because the orbitals are optimized
# a non-orbital-optimized VQE keeps that second term and must instead solve a
#   coupled-perturbed Hartree-Fock (CPHF) equation for the orbital response (Eq. 13)

The paper's only resource figures are measured on one molecule, not derived. Mizukami, Mitarai, Nakagawa, Yamamoto, Yan and Ohnishi report, for ammonia in STO-3G with all electrons correlated and no active-space approximation, 120 VQE parameters $\theta$ and quantum-circuit depth 2720 for OO-UCCD truncated at the first Trotter step — the same pair they quote for plain UCCD at that truncation — against 135 and 2780 for UCCSD, likewise at one Trotter step. They call the reduction slight, and never define what the depth counts or in what gate set. It is paid for by an unbounded outer loop: singles are handled classically, so VQE and a classical Newton–Raphson orbital optimisation are repeated until convergence, UCCSD-level accuracy coming "at the cost of repeated VQE optimizations", with no bound and no measured count of cycles. Once both $\theta$ and $\kappa$ are converged, a first derivative costs only the expectation value of the derivative of the Hamiltonian; second and higher derivatives still need the circuit-parameter response. The abstract's other claim — smaller active space, hence fewer qubits — is nowhere quantified.

• Quket's `oo()` orbital-optimisation driver over a UCC ansatz

  Quket describes itself in its own README as "Quket: Quantum Unified Kernel for Emulator Toolbox", "Official Version 0.9.4", a suite that "simulates quantum computing for electronic Hamiltonian", copyrighted "2019-2022 Takashi Tsuchimochi, Yuto Mori, Yuma Shimomoto, Taisei Nishimaki, Yoohee Ryo, Masaki Taii, Takahiro Yoshikura, TsangSiuChung, Kazuki Sasasako, Kengo Yoshimura". Orbital optimisation is a first-class feature rather than an example: the README's API list carries an entry headed "(13). `oo()`" whose body reads "Orbital-optimization is performed. See sample inputs.", and `oo` is a registered input key. What ties this artefact to this method is what the code does and what the shipped sample runs, not a citation: a case-insensitive search for "mizukami" over the whole default-branch tree matches no file, and the modules under `quket/orbital/` carry no arXiv identifier, DOI or journal reference at all.

  The driver is `oo(Q, maxiter=None, gtol=None, ftol=None)` in `quket/orbital/oo.py`, whose docstring reads "Main driver of Orbital optimization. Update mo coeffcients C by a skew matrix k as C[k] = C0 @ exp[k]" — the same rotation the method uses, with `C0` the original (usually Hartree-Fock) coefficients and `k` held as one triangle of the skew matrix. Which triangle, the file says two ways: the `oo()` docstring calls `kappa_list` the "only lower-triangular part", while `transform_integrals` at the top of the same file calls the same array "the upper triangular part of the skew matrix"; the lower-triangular reading is the one the code uses, since that docstring writes the rotation generator as a sum over p greater than q and the loop that indexes the step vector runs q below p. Its loop is the method's outer loop, with the VQE at the end of each cycle rather than the start: one `Q.run()` before the loop converges the circuit parameters, and then each cycle takes `get_1RDM` and `get_2RDM` of the current state, forms the gradient with `get_orbital_gradient` from `quket/orbital/grad.py`, computes a step from those density matrices, applies it to the Hamiltonian with `orbital_rotation`, and re-runs `Q.run()`, up to `oo_maxiter` cycles. The orbital step is not the paper's plain Newton-Raphson solve: `method = 'AH'` is assigned unconditionally at line 289 of `oo.py` and never reassigned, so the augmented-Hessian branch is always taken — a `pyscf.lib.davidson` call against the matrix-vector product `AHx` from `quket/orbital/hess.py`, followed by `line_search` with a golden-section inner search — and the `elif method == 'NR'` branch at line 430 and the `elif method == 'SD'` branch at line 439 are unreachable from `oo()`. `transform_integrals` rebuilds the integrals as "h1_new = exp(-K) h1 exp(K)" and "h2_new = exp(-K) h2 exp(K)" at each new set of coefficients.

  Two orbital-optimisation inputs are checked in under `samples/OO/`, and one of them is literally this method. `samples/OO/h2o_oo-uccd.inp` sets `basis = 6-31g**`, `ansatz = uccd`, `oo = True`, `maxiter = 100`, `n_orbitals = 5`, `n_electrons = 6`, `taper_off = True`, over a Z-matrix water geometry with both O-H bonds at 0.9614 and the angle at 104.5136. `samples/OO/n2_oo-sauccgd.inp` is the same switches on N2 at 1.0975 in cc-pvtz with `ansatz = sauccgd` — the README's spin-adapted UCCGD, not a state-averaged run — and six orbitals and six electrons. Integrals and the reference determinant come from PySCF: the README's required-library list is "pyscf >= 1.7.5", "openfermion >= 0.10.0", "openfermionpyscf >= 0.4", "Qulacs >= 0.1.9", plus numpy, scipy, psutil and pyberny.

  https://github.com/quket/quket, Python, Apache-2.0, with `quket/_version.py` reading `__version__ = "0.9.4"`. The orbital machinery is the package `quket/orbital/`, whose eight files are `__init__.py`, `oo.py`, `grad.py`, `hess.py`, `hess_diag.py`, `hess_vec.py`, `hess_whole.py` and `misc.py`; `oo.py` defines eight top-level functions, among them `oo`, `transform_integrals`, `orbital_rotation`, `line_search` and `wrap_energy`, while `get_orbital_gradient` and `orbital_gradient` are in `grad.py`, `AHx` in `hess.py`, `get_orbital_hessian` in `hess_whole.py` and `Hess_diag` in `hess_diag.py`. The input keys are registered in `quket/fileio/read.py`, where `oo_maxiter`, `oo_ftol` and `oo_gtol` sit under a comment reading `#----- For OO -----` and the boolean `oo` itself is listed separately with the other switches. Files read from the repository's default branch `main` on 2026-09-02; GitHub reports the repository's last push as 2022-09-16, so this is the state in which it was left rather than a maintained line.

  The log of the OO-UCCD sample is checked in beside its input, so the numbers are the package's own, not a rerun. `samples/OO/h2o_oo-uccd.log` is stamped "Quantum Computing Simulator Ver 0.9.4" and 2022-09-16, and runs on 16 processes. Its header prints `E[FCI] = -76.028720259868` and `E[HF] = -76.022363773732`; the FCI line is a CASCI over the declared five-orbital, six-electron active space, since `quket/quket_data/chemical.py` passes `n_active_orbitals`, `n_active_electrons` and `run_casci=run_fci` into one PySCF call, and `quket/fileio/read.py` maps the input's `n_orbitals` onto `n_active_orbitals`. Four qubits are tapered off, and the first VQE — 12 parameters, fixed Hartree-Fock orbitals — converges to `Final: E[uccd] = -76.028435793130`. Seven orbital-optimisation cycles then run, each ending in its own VQE; an eighth cycle opens, forms its density matrices and gradient, and returns at the convergence test without a further VQE, so the banner printed under that eighth heading reads "Convergence of orbital optimizer with 7 cycles". The answer is `Final: E[oo-uccd] = -76.07359608655958`, about 45 millihartree below the fixed-orbital active-space CASCI — which is possible precisely because the orbitals defining that active space moved: `oo()` sizes its rotation vector over `Q.n_orbitals`, which `chemical.py` sets to the full atomic-orbital count, printed in this log as `NBasis = 24` against 5 active and 17 secondary orbitals. Everything is Qulacs simulation with no shot noise and no device. A dipole moment is printed afterwards from the relaxed 1RDM, `| mu | = 2.06001` Debye against `2.06005` from the unrelaxed one.

• `OrbitalOptimizationVQE` in Qiskit Aqua's chemistry module

  • Quantum Orbital-Optimized Unitary Coupled Cluster Methods in the Strongly Correlated Regime: Can Quantum Algorithms Outperform their Classical Equivalents?

  Mizukami et al. point at the paper behind this solver, in their introduction: "Note that after posting the initial manuscript of this work on the arXiv preprint server, an implementation of OO-UCCD by Sokolov et al. was appeared there", adding that "Their study carefully performed the cost and accuracy analysis of several variants of OO-UCCD methods". Their citation there is to the preprint, arXiv:1911.10864, posted 25 November 2019 — not to this class, which is later and separate. The class docstring names the published form of that paper — "For more details of this method refer to: https://aip.scitation.org/doi/10.1063/1.5141835" — and the solver shipped in Aqua under a release note filed at `releasenotes/notes/0.8/oovqe-e8ff4f50f30687c3.yaml`: "Introduces a new ``ground_state_solver`` based on the orbital optimization VQE. The new solver is called ``OrbitalOptimizationVQE`` and operates by optimizing orbitals (orbital rotations) and variational parameters throughout the VQE process." It did not survive the move to Qiskit Nature: the current qiskit-nature default branch has no orbital-optimisation solver, and its `puccd.py` still carries the line "TODO: when ooVQE gets refactored, it may turn out that this Ansatz can indeed by used for unrestricted spin systems."

  `OrbitalOptimizationVQE(GroundStateEigensolver)` rotates the AO-to-MO coefficient matrix, written on its `orbital_rotation` argument as "C = C0 * exp(-kappa)" and in the class docstring as "C=Ce^(-kappa) where kappa is an anti-hermitian matrix", the free parameters being "the off-diagonal elements of the anti-hermitian matrix kappa", built by the companion `OrbitalRotation` class. `_energy_evaluation_oo` is where the orbital objective lives, and what it varies turns on a switch: with `iterative_oo` off it slices the incoming vector into `parameters[:self.var_form_num_parameters]` for the circuit and `parameters[self.var_form_num_parameters:]` for the orbitals and drives both at once, while under the default `iterative_oo=True` it varies the orbital parameters alone against a fixed `self._fixed_wavefunction_params`, and `solve` alternates that with an amplitudes-only minimisation, `iterative_oo_iterations` times, default 2. Either way the same evaluation calls `orbital_rotation_matrix`, rebuilds a rotated copy of the molecule via `_rotate_orbitals_in_qmolecule` — which re-does `mo_coeff = np.matmul(qmolecule.mo_coeff, orbital_rotation.matrix_a)` and re-transforms the one- and two-electron and dipole integrals — and only then re-runs the fermion-to-qubit transformation and evaluates the energy, so the qubit Hamiltonian is rebuilt at every energy evaluation. The orbital parameters are driven by the same classical optimizer as the amplitudes, not by a density-matrix Newton-Raphson solve; the constructor's own words for the two schedules are "optimize first the variational form and then the orbitals, iteratively" and "the wavefunction ansatz and orbitals are optimized simultaneously". The ansatz is constrained: `_set_operator_and_vqe` raises "The OrbitalOptimizationVQE algorithm requires the use of the UCCSD varform." `OrbitalRotation._create_orbital_rotation_list` defaults to every pair `[i, j]` with `i < j` over half the qubit count, or `(num_qubits + 2) / 2` when two-qubit reduction is on.

  The tests read three HDF5 fixtures shipped in the repository through `HDF5Driver` — `test/chemistry/test_oovqe_h4.hdf5`, `test/chemistry/test_oovqe_lih.hdf5` and `test/chemistry/test_oovqe_h4_uhf.hdf5` — so H4 from a restricted reference, LiH with `freeze_core=True`, and H4 again from an unrestricted one. No molecule is built from a live PySCF driver in the test suite, and the fixtures carry no basis or geometry in their filenames.

  Python, Apache-2.0, in the now-archived https://github.com/qiskit-community/qiskit-aqua. The file is `qiskit/chemistry/algorithms/ground_state_solvers/orbital_optimization_vqe.py`, headed "(C) Copyright IBM 2020, 2021", defining `class OrbitalOptimizationVQE(GroundStateEigensolver)`, `class OrbitalRotation` and `class OOVQEResult(ElectronicStructureResult)` in 699 lines. The repository is marked archived, its `qiskit/aqua/VERSION.txt` reads 0.10.0, and GitHub reports its last push as 2021-11-26. Files read from the default branch `main` on 2026-09-02.

  `test/chemistry/test_oovqe.py` is the only reported evidence, and it is a statevector regression suite rather than a chemistry result. All seven tests use `BasicAer.get_backend('statevector_simulator')` with `shots=1`, `seed_simulator=50` and `seed_transpiler=50`, and a COBYLA optimizer capped at one to three iterations. Six of them build the ansatz through `VQEUCCSDFactory(..., excitation_type='d', same_spin_doubles=False, method_doubles='pucc')` — the paired doubles ansatz, not full UCCSD — one of those six by pulling the solver out of that factory with `get_solver` rather than handing over the factory; the seventh passes a plain `VQE` on `RealAmplitudes` precisely to trip the UCCSD guard, and asserts only that it raises. Only one test asserts an equality: `test_orbital_rotations` checks `computed_electronic_energy` equals -3.0104 to four places on the H4 fixture with `iterative_oo=False` and a fixed ten-element `initial_point`. The rest assert inequalities against numbers the file names as targets — at most -2.77 for H4, annotated in the source as the "energy of the VQE with pUCCD ansatz and LBFGSB optimizer", at most -7.70 for frozen-core LiH after adding back the energy shift and nuclear repulsion, and at most -2.50 for the unrestricted H4 fixture. Nothing here runs on hardware, and with the optimizer capped at three iterations none of it demonstrates convergence.

• Mizukami et al.'s own OO-UCCD simulator code

  • Orbital optimized unitary coupled cluster theory for quantum computer

  The method's own paper says what it built and where the pieces came from, in one paragraph opening Section III, and then says nothing further about its own implementation — the only other program package it names anywhere is ORCA, and that is for the classical reference geometries. Everything reported is simulator work — the abstract offers "numerical examples of OO-UCC using quantum simulators" — and the paper names no repository, no licence and no released package.

  Three public packages, each with a stated job: "Qulacs is used to simulate quantum circuits. PySCF is used for orbital optimizations and for evaluating molecular Hamiltonian integrals", and "OpenFermion is employed for mapping molecular Hamiltonian into a quantum circuit based on the Jordan-Wigner transformation". So the classical orbital-optimisation machinery comes from PySCF rather than from the circuit side, which is what the design the paper argues for requires: "OO-UCCD treats singles contributions not on quantum computers but on classical computers". The reference geometries it compares against come from a fourth package, outside this code: "The CCSD and CCSD(T) geometries were obtained by the ORCA program package using numerical gradients".

  Four calculations, all in small bases. LiH along a potential energy curve in STO-3G with no active space, "all the orbitals were mapped into qubits". Water and ammonia geometry optimisations in STO-3G, driven by analytical first derivatives, in that same subsection headed "Without the active space approximation" whose opening reads "In this subsection, we show the results without the active space approximation. It means that all the orbitals were mapped into qubits." — the paper's one sentence "All electrons were correlated in these calculations" follows the ORCA sentence instead, so on the text alone its antecedent is those classical reference geometries and not the UCC runs. N2 in STO-3G at the AS-OO-UCCD(6o, 6e) level, "by fixing the lowest four occupied orbitals and eight electrons". LiH again in 6-311G with an active space of four orbitals and two electrons, where "the orbital optimization was performed for all the orbitals and electrons" while only the active space was correlated in the VQE.

  Not released. The paper names no repository and carries no code- or data-availability statement; searching its full text for "github", "repository" and "available" turns up no hit on the first two and only prose uses of the third ("first-order properties are readily available", "the available qubits"). What can be pinned down is the stack it was assembled from and nothing more, so this record notes that an implementation exists rather than pointing at one that can be run.

  Table I is the geometry result, in RMSD of Cartesian coordinates against FCI in Å with the energy deviation at the optimised geometry in parentheses: OO-UCCD at one Trotter step gives 3.3E-04 (1.8E-04) for NH3 and 6.7E-05 (1.0E-04) for H2O, against UCCSD at one Trotter step at 3.3E-04 (1.8E-04) and 7.1E-05 (1.0E-04), and CCSD at 2.9E-04 (2.5E-04) and 1.7E-04 (1.5E-04). On the LiH curve the agreement with UCCSD is much tighter than the doubles-only comparison: the paper puts the energy deviation of OO-UCCD at one Trotter step from UCCSD at one Trotter step at $10^{-7}$ mhartree at 1.3 Å Li-H distance and 3 × $10^{-5}$ at 2.1 Å, that second unit printed in the paper as "mhatree", while "the deviation of UCCD1 is at least five orders of magnitude larger than OO-UCCD1". On N2 in the active space the three variants nearly coincide — "the differences among AS-UCCD, AS-OO-UCCD, and AS-UCCSD were small. They are at most 0.2 kcal/mol", with an RMSD of 0.02 kcal/mol over 1.0 to 2.1 Å — which the paper attributes to "the little orbital relaxation effect in the small basis sets", so it is not evidence that orbital optimisation is cheap to skip in general.

• `oo_VQE` in the qc2 package, on Qiskit and PennyLane

  qc2 calls itself "a modular software designed to seamlessly integrate traditional computational chemistry codes and quantum computing frameworks", "specifically crafted for hybrid quantum-classical workflows such as the variational quantum eigensolver (VQE) algorithm", and "a direct outcome of the QCforQC project, a collaboration between Netherlands eScience Center, Vrije Universiteit Amsterdam (VU) and SURF". Alone among the artefacts recorded here it cites this method by name: `docs/algorithms/oo_vqe_class.rst` says the orbital coefficients are optimised "by resorting to analytic first and second derivatives of the energy" and cites four sources for the details, one of them the key `Mizukami:2020`, which `docs/references.bib` resolves to "Orbital optimized unitary coupled cluster theory for quantum computer", Physical Review Research 2, 033421 (2020) — the published form of this method's paper. It is also the only one of the four artefacts here still maintained.

  The algorithm is `class oo_VQE(VQE)`, shipped twice — `qc2/algorithms/qiskit/oo_vqe.py` and `qc2/algorithms/pennylane/oo_vqe.py` — over one shared `OrbitalOptimization` class in `qc2/algorithms/utils/orbital_optimization.py`. Its docstring states the design: "Orbital optimization is performed alongside VQE parameter optimization using analytic first and second derivatives". `run()` is the outer loop and, unlike Quket's, it is not run to an orbital convergence test of its own: for up to `max_iterations`, default 50, it optimises the circuit parameters at fixed kappa, takes the one- and two-particle reduced density matrices of the resulting state with `_get_rdms(theta)`, hands them to `oo_problem.orbital_optimization(rdm1, rdm2, kappa)`, recomputes the energy from both sets of parameters, and stops when successive energies differ by less than `conv_tol`, default 1e-7; if the loop runs out it raises "Optimization did not converge within the maximum iterations." The orbital step is a Newton-Raphson solve and exactly one of them per outer cycle — `grad = gradient(kappa_init)`, `hess = hessian(kappa_init)`, `delta_kappa = -np.linalg.solve(hess, grad)` — with gradient and Hessian from `get_analytic_gradients` and `get_analytic_hessian` rather than from finite differences, and the rotation applied as `expm(-kappa_matrix)` to the molecular-orbital coefficients in `_get_rotation_matrix`. The Hessian is regularised before the solve: when its lowest eigenvalue is negative the code adds twice that eigenvalue's magnitude on the diagonal, under the comment "perform regularization to ensure all hessian eigenvalues are > 0". Only non-redundant rotations are parameterised — `n_kappa` is the length of `get_non_redundant_indices` over the occupied, active and virtual index sets — and `freeze_active` holds the active block fixed.

  Nothing is shipped as a fixture: each test builds its molecule with ASE, runs the reference Hartree-Fock through one of qc2's own ASE calculators, and writes a QCSchema HDF5 file that the algorithm then reads. `tests/integration_tests/test_oo_vqe_qiskit_h2o.py` uses `molecule('H2O')` with `Psi4(method='hf', basis='sto-3g')`; `tests/integration_tests/test_oo_vqe_pennylane_h2o.py` uses the same molecule with `PySCF()`, whose calculator defaults to `sto-3g`. Both declare `ActiveSpace(num_active_electrons=(1, 1), num_active_spatial_orbitals=2)`, one alpha and one beta electron in two spatial orbitals. The unit tests run `molecule('H2')` through the same path.

  https://github.com/qc2nl/qc2, Python, Apache-2.0, not archived, default branch `main`, last push 2025-11-11 per the GitHub API; files read on 2026-09-02. The orbital-optimisation code is `qc2/algorithms/utils/orbital_optimization.py`, 662 lines, `class OrbitalOptimization` with `orbital_optimization`, `get_analytic_hessian`, `get_analytic_gradients`, `get_fock_matrix`, `get_energy_from_kappa`, `get_transformed_qubit_hamiltonian` and `_kappa_vector_to_matrix` among its methods, plus the two `oo_vqe.py` files, the two `examples/oo_vqe_*_water.py` scripts and the documentation page `docs/algorithms/oo_vqe_class.rst`. Two version numbers disagree and neither is obviously the stale one: `qc2/__init__.py` and `.bumpversion.cfg` both read 0.1.0, while `CITATION.cff` gives version "v1.1.3" released 2024-11-19, with the concept DOI 10.5281/zenodo.14186370. No paper documents the package, so this entry cites none.

  Two integration tests are the reported evidence and they assert the same number: `test_oo_vqe_calculation`, in both the Qiskit and the PennyLane file, checks `results.optimal_energy` against `pytest.approx(-74.96565745741862, rel=1e-6)` under a docstring reading "Check that the oo-vqe energy corresponds to one at CASSCF/sto-3g" — so the target is a classical CASSCF value for water in that two-orbital, two-electron active space, not FCI and not an experiment. The Qiskit unit test `test_theta_kappa_optimization` asserts -1.1373015 for H2 in the same active space, and separately that every optimised orbital parameter is non-zero. All of it is simulation: the Qiskit path runs on `qiskit.primitives.Estimator` with `SLSQP`, the PennyLane path defaults to the `default.qubit` device, and no hardware backend appears anywhere in the tests. The evidence is conditional on optional dependencies — each integration file opens with a `try`/`except ImportError` calling `pytest.skip(..., allow_module_level=True)`, so a missing Psi4 or PennyLane removes the whole file from a run rather than failing it.

Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.

Different approaches

• Unitary coupled-cluster singles and doubles

  Build the trial state from single and double excitations out of a reference determinant, exponentiated as a unitary. The family is chosen for chemistry rather than for the machine: the state you want is in it by construction, and the circuit that reaches it is deep.

• Hardware-efficient ansatz

  Build the trial state out of the gates and couplings the machine already has, and accept whatever states that reaches. The circuit is shallow because nothing in it was chosen for the chemistry; there is correspondingly no argument that the state you want is inside the family.

• ADAPT-VQE adaptive ansatz

  Refuse to fix the structure in advance. Start from nothing and add one operator at a time, choosing each from a pool according to what the molecule itself indicates, until the energy stops improving. The circuit ends up short because nothing was included that the problem did not ask for.

• qubit-ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive ansatz

  The same grow-it-one-operator-at-a-time construction, with the pool rebuilt out of qubit operators rather than fermionic excitations so that the circuits it produces are shallow enough for near-term hardware.

• k-UpCCGSD ansatz

  Take k repetitions of paired double excitations together with generalized singles, instead of the full set of doubles. The point of the restriction is that the depth then grows linearly in the number of orbitals rather than polynomially, and k is the dial that buys accuracy back.

• Qubit coupled-cluster ansatz

  Skip the fermionic layer and build the ansatz directly in qubit space, ranking candidate entangling operators by how much each would move the energy and keeping the ones that earn their place.

• Particle-hole coupled-cluster circuits

  Rewrite the Hamiltonian around the reference determinant so that what the circuit has to describe is excitations out of it, then build the family from gates that move an electron without creating or destroying one. Staying inside the right particle-number sector is a property of the gates, not something the optimiser has to discover.

• Symmetry-preserving state-preparation circuits

  Build the circuit so that it cannot leave the symmetry sector the chemistry lives in. Particle number, total spin, spin projection and time reversal are respected by the gate structure itself, so the search never spends parameters on states the answer cannot be in.

• TETRIS-ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive ansatz

  Keep ADAPT's habit of growing the ansatz from measured gradients, and stop adding one operator per round. Several operators acting on disjoint qubits can go in together, filling the same layer instead of stacking — the same circuit, packed rather than piled.

• Iterative qubit coupled cluster a narrower version of Qubit coupled-cluster ansatz

  Stop growing the circuit and grow the Hamiltonian instead. Each round folds the entanglers found so far into the operator by a canonical transformation, so every round runs a circuit of the same size — the cost moves off the device and into the number of terms that have to be measured.

• Generalized singles and doubles ansatz

  Drop the rule that an excitation has to move an electron from an occupied orbital into an empty one. Every pair of orbitals may be coupled, so the circuit stops depending on which reference determinant it was built around — a wider variational manifold, paid for in parameters.

• Batched ADAPT-VQE ansatz a narrower version of ADAPT-VQE adaptive ansatz

  Keep ADAPT's habit of growing the ansatz from measured gradients, and stop adding exactly one operator per round. Every operator whose gradient is close to the largest goes in together, so the ansatz reaches the same size in far fewer rounds — and it is the rounds, not the operators, that cost measurements.

• Orbital-optimized VQE

  Orbital rotations are optimized alongside circuit parameters to improve compact active-space descriptions.

• Orbital optimized unitary coupled cluster theory for quantum computer↗Wataru Mizukami, Kosuke Mitarai, Yuya O. Nakagawa, Takahiro Yamamoto, Tennin Yan, Yu-ya Ohnishi · 2019theory yes · simulation yes · hardware no