qoro-divi 0.3.3__tar.gz → 0.3.4__tar.gz

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qoro-divi
-Version: 0.3.3
+Version: 0.3.4
 Summary: A Python library to automate generating, parallelizing, and executing quantum programs.
 Author: Ahmed Darwish
 Author-email: ahmed@qoroquantum.de

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/divi/__init__.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .qlogger import enable_logging
-from .qoro_service import QoroService
+from .reporting import enable_logging
 
 enable_logging()

qoro_divi-0.3.4/divi/backends/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._circuit_runner import CircuitRunner
+from ._parallel_simulator import ParallelSimulator
+from ._qoro_service import JobStatus, JobType, QoroService

qoro_divi-0.3.3/divi/parallel_simulator.py → qoro_divi-0.3.4/divi/backends/_parallel_simulator.py

@@ -18,7 +18,7 @@ from qiskit.providers import Backend
 from qiskit_aer import AerSimulator
 from qiskit_aer.noise import NoiseModel
 
-from divi.interfaces import CircuitRunner
+from divi.backends import CircuitRunner
 
 logger = logging.getLogger(__name__)
 
@@ -74,8 +74,9 @@ class ParallelSimulator(CircuitRunner):
             n_processes (int, optional): Number of parallel processes to use for simulation. Defaults to 2.
             shots (int, optional): Number of shots to perform. Defaults to 5000.
             simulation_seed (int, optional): Seed for the random number generator to ensure reproducibility. Defaults to None.
-            backend (Backend or "auto, optional): A Qiskit backend to initiate the simulator from. If "auto" is passed,
-             the best-fit most recent fake backend will be chosen for the given circuit. Defaults to None, resulting in noiseless simulation.
+            qiskit_backend (Backend | Literal["auto"] | None, optional): A Qiskit backend to initiate the simulator from.
+            If "auto" is passed, the best-fit most recent fake backend will be chosen for the given circuit.
+            Defaults to None, resulting in noiseless simulation.
             noise_model (NoiseModel, optional): Qiskit noise model to use in simulation. Defaults to None.
         """
         super().__init__(shots=shots)

qoro_divi-0.3.3/divi/qoro_service.py → qoro_divi-0.3.4/divi/backends/_qoro_service.py

@@ -15,9 +15,9 @@ import requests
 from dotenv import dotenv_values
 from requests.adapters import HTTPAdapter, Retry
 
-from divi.exp.cirq import validate_qasm_raise
-from divi.interfaces import CircuitRunner
-from divi.qpu_system import QPU, QPUSystem
+from divi.backends import CircuitRunner
+from divi.backends._qpu_system import QPU, QPUSystem
+from divi.extern.cirq import is_valid_qasm
 
 API_URL = "https://app.qoroquantum.net/api"
 MAX_PAYLOAD_SIZE_MB = 0.95
@@ -241,9 +241,8 @@ class QoroService(CircuitRunner):
             raise ValueError("Only one circuit allowed for circuit-cutting jobs.")
 
         for key, circuit in circuits.items():
-            validate_qasm_raise(circuit)
-            # if not is_valid_qasm(circuit):
-            #     raise ValueError(f"Circuit {key} is not a valid QASM string.")
+            if not (err := is_valid_qasm(circuit)):
+                raise ValueError(f"Circuit '{key}' is not a valid QASM: {err}")
 
         circuit_chunks = self._split_circuits(circuits)
 

qoro_divi-0.3.4/divi/circuits/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._core import Circuit, MetaCircuit

qoro_divi-0.3.3/divi/circuits.py → qoro_divi-0.3.4/divi/circuits/_core.py

@@ -10,10 +10,9 @@ from typing import Literal
 import dill
 import pennylane as qml
 from pennylane.transforms.core.transform_program import TransformProgram
-from qiskit.qasm2 import dumps
 
-from divi.qasm import to_openqasm
-from divi.qem import QEMProtocol
+from divi.circuits.qasm import to_openqasm
+from divi.circuits.qem import QEMProtocol
 
 TRANSFORM_PROGRAM = TransformProgram()
 TRANSFORM_PROGRAM.add_transform(qml.transforms.split_to_single_terms)
@@ -30,35 +29,22 @@ class Circuit:
         qasm_circuits: list[str] = None,
     ):
         self.main_circuit = main_circuit
-        self.circuit_type = main_circuit.__module__.split(".")[0]
         self.tags = tags
 
         self.qasm_circuits = qasm_circuits
 
         if self.qasm_circuits is None:
-            self.convert_to_qasm()
-
-        self.circuit_id = Circuit._id_counter
-        Circuit._id_counter += 1
-
-    def __str__(self):
-        return f"Circuit: {self.circuit_id}"
-
-    def convert_to_qasm(self):
-        if self.circuit_type == "pennylane":
             self.qasm_circuits = to_openqasm(
                 self.main_circuit,
                 measurement_groups=[self.main_circuit.measurements],
                 return_measurements_separately=False,
             )
 
-        elif self.circuit_type == "qiskit":
-            self.qasm_circuits = [dumps(self.main_circuit)]
+        self.circuit_id = Circuit._id_counter
+        Circuit._id_counter += 1
 
-        else:
-            raise ValueError(
-                f"Invalid circuit type. Circuit type {self.circuit_type} not currently supported."
-            )
+    def __str__(self):
+        return f"Circuit: {self.circuit_id}"
 
 
 class MetaCircuit:

{qoro_divi-0.3.3/divi → qoro_divi-0.3.4/divi/circuits}/qasm.py

@@ -14,8 +14,8 @@ from pennylane.tape import QuantumScript
 from pennylane.wires import Wires
 from sympy import Symbol
 
-from divi.exp.cirq import cirq_circuit_from_qasm
-from divi.qem import QEMProtocol
+from divi.circuits.qem import QEMProtocol
+from divi.extern.cirq import cirq_circuit_from_qasm
 
 OPENQASM_GATES = {
     "CNOT": "cx",

{qoro_divi-0.3.3/divi/exp → qoro_divi-0.3.4/divi/extern}/cirq/_validator.py

@@ -289,7 +289,12 @@ class Parser:
     # ---- gate definitions ----
     def gate_def(self):
         self.match("GATE")
-        gname = self.match("ID").value
+        gname_tok = self.match("ID")
+        gname = gname_tok.value
+        if gname in BUILTINS:
+            raise SyntaxError(
+                f"Cannot redefine built-in gate '{gname}' at {gname_tok.line}:{gname_tok.col}"
+            )
         if gname in self.user_gates:
             self._dupe(gname)
         params: tuple[str, ...] = ()
@@ -570,7 +575,6 @@ class Parser:
         if t.type == "PI":
             self.match("PI")
             return
-        # ---- NEW BLOCK TO HANDLE MATH FUNCTIONS ----
         if t.type in _MATH_FUNCS:
             self.match(t.type)  # Consume the function name (e.g., COS)
             self.match("LPAREN")
@@ -578,13 +582,11 @@ class Parser:
             # Note: QASM 2.0 math functions only take one argument
             self.match("RPAREN")
             return
-        # --------------------------------------------
         if t.type == "ID":
             # function call or plain ID
             id_tok = self.match("ID")
             ident = id_tok.value
             if self.accept("LPAREN"):
-                # This now correctly handles user-defined functions (if any)
                 if self.peek().type != "RPAREN":
                     self._expr(allow_id)
                     while self.accept("COMMA"):
@@ -637,9 +639,9 @@ def validate_qasm_raise(src: str) -> None:
     Parser(toks).parse()
 
 
-def is_valid_qasm(src: str) -> bool:
+def is_valid_qasm(src: str) -> bool | str:
     try:
         validate_qasm_raise(src)
         return True
-    except SyntaxError:
-        return False
+    except SyntaxError as e:
+        return str(e)

qoro_divi-0.3.4/divi/qprog/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# isort: skip_file
+from .quantum_program import QuantumProgram
+from .batch import ProgramBatch
+from .algorithms import (
+    QAOA,
+    GraphProblem,
+    VQE,
+    Ansatz,
+    UCCSDAnsatz,
+    QAOAAnsatz,
+    HardwareEfficientAnsatz,
+    HartreeFockAnsatz,
+    GenericLayerAnsatz,
+)
+from .workflows import (
+    GraphPartitioningQAOA,
+    PartitioningConfig,
+    QUBOPartitioningQAOA,
+    VQEHyperparameterSweep,
+    MoleculeTransformer,
+)
+from .optimizers import ScipyOptimizer, ScipyMethod, MonteCarloOptimizer

qoro_divi-0.3.4/divi/qprog/algorithms/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._ansatze import (
+    Ansatz,
+    GenericLayerAnsatz,
+    HardwareEfficientAnsatz,
+    HartreeFockAnsatz,
+    QAOAAnsatz,
+    UCCSDAnsatz,
+)
+from ._qaoa import QAOA, GraphProblem, GraphProblemTypes, QUBOProblemTypes
+from ._vqe import VQE

qoro_divi-0.3.4/divi/qprog/algorithms/_ansatze.py

@@ -0,0 +1,215 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from itertools import tee
+from typing import Literal, Sequence
+from warnings import warn
+
+import pennylane as qml
+
+
+class Ansatz(ABC):
+    """Abstract base class for all VQE ansaetze."""
+
+    @property
+    def name(self) -> str:
+        """Returns the human-readable name of the ansatz."""
+        return self.__class__.__name__
+
+    @staticmethod
+    @abstractmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        """Returns the number of parameters required by the ansatz for one layer."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        """
+        Builds the ansatz circuit.
+
+        Args:
+            params (array): The parameters (weights) for the ansatz.
+            n_qubits (int): The number of qubits.
+            n_layers (int): The number of layers.
+            **kwargs: Additional arguments like n_electrons for chemistry ansaetze.
+        """
+        raise NotImplementedError
+
+
+# --- Template Ansaetze ---
+
+
+class GenericLayerAnsatz(Ansatz):
+    """
+    A flexible ansatz alternating single-qubit gates with optional entanglers.
+    """
+
+    def __init__(
+        self,
+        gate_sequence: list[qml.operation.Operator],
+        entangler: qml.operation.Operator | None = None,
+        entangling_layout: (
+            Literal["linear", "brick", "circular", "all-to-all"]
+            | Sequence[tuple[int, int]]
+            | None
+        ) = None,
+    ):
+        """
+        Args:
+            gate_sequence (list[Callable]): List of one-qubit gate classes (e.g., qml.RY, qml.Rot).
+            entangler (Callable): Two-qubit entangling gate class (e.g., qml.CNOT, qml.CZ).
+                                  If None, no entanglement is applied.
+            entangling_layout (str): Layout for entangling layer ("linear", "all_to_all", etc.).
+        """
+        if not all(
+            issubclass(g, qml.operation.Operator) and g.num_wires == 1
+            for g in gate_sequence
+        ):
+            raise ValueError(
+                "All elements in gate_sequence must be PennyLane one-qubit gate classes."
+            )
+        self.gate_sequence = gate_sequence
+
+        if entangler not in (None, qml.CNOT, qml.CZ):
+            raise ValueError("Only qml.CNOT and qml.CZ are supported as entanglers.")
+        self.entangler = entangler
+
+        self.entangling_layout = entangling_layout
+        if entangler is None and self.entangling_layout is not None:
+            warn("`entangling_layout` provided but `entangler` is None.")
+        match self.entangling_layout:
+            case None | "linear":
+                self.entangling_layout = "linear"
+
+                self._layout_fn = lambda n_qubits: zip(
+                    range(n_qubits), range(1, n_qubits)
+                )
+            case "brick":
+                self._layout_fn = lambda n_qubits: [
+                    (i, i + 1) for r in range(2) for i in range(r, n_qubits - 1, 2)
+                ]
+            case "circular":
+                self._layout_fn = lambda n_qubits: zip(
+                    range(n_qubits), [(i + 1) % n_qubits for i in range(n_qubits)]
+                )
+            case "all_to_all":
+                self._layout_fn = lambda n_qubits: (
+                    (i, j) for i in range(n_qubits) for j in range(i + 1, n_qubits)
+                )
+            case _:
+                if not all(
+                    isinstance(ent, tuple)
+                    and len(ent) == 2
+                    and isinstance(ent[0], int)
+                    and isinstance(ent[1], int)
+                    for ent in entangling_layout
+                ):
+                    raise ValueError(
+                        "entangling_layout must be 'linear', 'circular', "
+                        "'all_to_all', or a Sequence of tuples of integers."
+                    )
+
+                self._layout_fn = lambda _: entangling_layout
+
+    def n_params_per_layer(self, n_qubits: int, **kwargs) -> int:
+        """Total parameters = sum of gate.num_params per qubit per layer."""
+        per_qubit = sum(getattr(g, "num_params", 1) for g in self.gate_sequence)
+        return per_qubit * n_qubits
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        # calculate how many params each gate needs per qubit
+        gate_param_counts = [getattr(g, "num_params", 1) for g in self.gate_sequence]
+        per_qubit = sum(gate_param_counts)
+
+        # reshape into [layers, qubits, per_qubit]
+        params = params.reshape(n_layers, n_qubits, per_qubit)
+        layout_gen = iter(tee(self._layout_fn(n_qubits), n_layers))
+
+        def _layer(layer_params, wires):
+            for w, qubit_params in zip(wires, layer_params):
+                idx = 0
+                for gate, n_p in zip(self.gate_sequence, gate_param_counts):
+                    theta = qubit_params[idx : idx + n_p]
+                    gate(*theta, wires=w)
+                    idx += n_p
+
+            if self.entangler is not None:
+                for wire_a, wire_b in next(layout_gen):
+                    self.entangler(wires=[wire_a, wire_b])
+
+        qml.layer(_layer, n_layers, params, wires=range(n_qubits))
+
+
+class QAOAAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        return qml.QAOAEmbedding.shape(n_layers=1, n_wires=n_qubits)[1]
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs):
+        qml.QAOAEmbedding(
+            features=[],
+            weights=params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+        )
+
+
+class HardwareEfficientAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, **kwargs) -> int:
+        raise NotImplementedError("HardwareEfficientAnsatz is not yet implemented.")
+
+    def build(self, params, n_qubits: int, n_layers: int, **kwargs) -> None:
+        raise NotImplementedError("HardwareEfficientAnsatz is not yet implemented.")
+
+
+# --- Chemistry Ansaetze ---
+
+
+class UCCSDAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, n_electrons: int, **kwargs) -> int:
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
+        return len(s_wires) + len(d_wires)
+
+    def build(self, params, n_qubits: int, n_layers: int, n_electrons: int, **kwargs):
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
+        hf_state = qml.qchem.hf_state(n_electrons, n_qubits)
+
+        qml.UCCSD(
+            params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+            s_wires=s_wires,
+            d_wires=d_wires,
+            init_state=hf_state,
+            n_repeats=n_layers,
+        )
+
+
+class HartreeFockAnsatz(Ansatz):
+    @staticmethod
+    def n_params_per_layer(n_qubits: int, n_electrons: int, **kwargs) -> int:
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        return len(singles) + len(doubles)
+
+    def build(self, params, n_qubits: int, n_layers: int, n_electrons: int, **kwargs):
+        singles, doubles = qml.qchem.excitations(n_electrons, n_qubits)
+        hf_state = qml.qchem.hf_state(n_electrons, n_qubits)
+
+        qml.layer(
+            qml.AllSinglesDoubles,
+            n_layers,
+            params.reshape(n_layers, -1),
+            wires=range(n_qubits),
+            hf_state=hf_state,
+            singles=singles,
+            doubles=doubles,
+        )
+
+        # Reset the BasisState operations after the first layer
+        # for behaviour similar to UCCSD ansatz
+        for op in qml.QueuingManager.active_context().queue[1:]:
+            op._hyperparameters["hf_state"] = 0

{qoro_divi-0.3.3/divi/qprog → qoro_divi-0.3.4/divi/qprog/algorithms}/_qaoa.py

@@ -224,7 +224,7 @@ class QAOA(QuantumProgram):
         self.n_layers = n_layers
         self.max_iterations = max_iterations
         self.current_iteration = 0
-        self.n_params = 2
+        self._n_params = 2
         self._is_compute_probabilites = False
         self.optimizer = optimizer if optimizer is not None else MonteCarloOptimizer()
 

{qoro_divi-0.3.3/divi/qprog → qoro_divi-0.3.4/divi/qprog/algorithms}/_vqe.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from enum import Enum
 from warnings import warn
 
 import pennylane as qml
@@ -10,38 +9,10 @@ import sympy as sp
 
 from divi.circuits import MetaCircuit
 from divi.qprog import QuantumProgram
+from divi.qprog.algorithms._ansatze import Ansatz, HartreeFockAnsatz
 from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 
-class VQEAnsatz(Enum):
-    UCCSD = "UCCSD"
-    RY = "RY"
-    RYRZ = "RYRZ"
-    HW_EFFICIENT = "HW_EFFICIENT"
-    QAOA = "QAOA"
-    HARTREE_FOCK = "HF"
-
-    def describe(self):
-        return self.name, self.value
-
-    def n_params(self, n_qubits, **kwargs):
-        if self in (VQEAnsatz.UCCSD, VQEAnsatz.HARTREE_FOCK):
-            singles, doubles = qml.qchem.excitations(
-                kwargs.pop("n_electrons"), n_qubits
-            )
-            s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
-
-            return len(s_wires) + len(d_wires)
-        elif self == VQEAnsatz.RY:
-            return n_qubits
-        elif self == VQEAnsatz.RYRZ:
-            return 2 * n_qubits
-        elif self == VQEAnsatz.HW_EFFICIENT:
-            raise NotImplementedError
-        elif self == VQEAnsatz.QAOA:
-            return qml.QAOAEmbedding.shape(n_layers=1, n_wires=n_qubits)[1]
-
-
 class VQE(QuantumProgram):
     def __init__(
         self,
@@ -49,7 +20,7 @@ class VQE(QuantumProgram):
         molecule: qml.qchem.Molecule | None = None,
         n_electrons: int | None = None,
         n_layers: int = 1,
-        ansatz=VQEAnsatz.HARTREE_FOCK,
+        ansatz: Ansatz | None = None,
         optimizer: Optimizer | None = None,
         max_iterations=10,
         **kwargs,
@@ -62,15 +33,15 @@ class VQE(QuantumProgram):
             molecule (pennylane.qchem.Molecule, optional): The molecule representing the problem.
             n_electrons (int, optional): Number of electrons associated with the Hamiltonian.
                 Only needs to be provided when a Hamiltonian is given.
-            ansatz (VQEAnsatz): The ansatz to use for the VQE problem
+            ansatz (Ansatz): The ansatz to use for the VQE problem
             optimizer (Optimizers): The optimizer to use.
             max_iterations (int): Maximum number of iteration optimizers.
         """
 
         # Local Variables
+        self.ansatz = HartreeFockAnsatz() if ansatz is None else ansatz
         self.n_layers = n_layers
         self.results = {}
-        self.ansatz = ansatz
         self.max_iterations = max_iterations
         self.current_iteration = 0
 
@@ -84,6 +55,13 @@ class VQE(QuantumProgram):
 
         self._meta_circuits = self._create_meta_circuits_dict()
 
+    @property
+    def n_params(self):
+        return (
+            self.ansatz.n_params_per_layer(self.n_qubits, n_electrons=self.n_electrons)
+            * self.n_layers
+        )
+
     def _process_problem_input(self, hamiltonian, molecule, n_electrons):
         if hamiltonian is None and molecule is None:
             raise ValueError(
@@ -91,13 +69,8 @@ class VQE(QuantumProgram):
             )
 
         if hamiltonian is not None:
-            if not isinstance(n_electrons, int) or n_electrons < 0:
-                raise ValueError(
-                    f"`n_electrons` is expected to be a non-negative integer. Got {n_electrons}."
-                )
-
-            self.n_electrons = n_electrons
             self.n_qubits = len(hamiltonian.wires)
+            self.n_electrons = n_electrons
 
         if molecule is not None:
             self.molecule = molecule
@@ -112,10 +85,6 @@ class VQE(QuantumProgram):
                     UserWarning,
                 )
 
-        self.n_params = self.ansatz.n_params(
-            self.n_qubits, n_electrons=self.n_electrons
-        )
-
         self.cost_hamiltonian = self._clean_hamiltonian(hamiltonian)
 
     def _clean_hamiltonian(
@@ -148,9 +117,17 @@ class VQE(QuantumProgram):
         return hamiltonian.simplify()
 
     def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
-        weights_syms = sp.symarray("w", (self.n_layers, self.n_params))
+        weights_syms = sp.symarray(
+            "w",
+            (
+                self.n_layers,
+                self.ansatz.n_params_per_layer(
+                    self.n_qubits, n_electrons=self.n_electrons
+                ),
+            ),
+        )
 
-        def _prepare_circuit(ansatz, hamiltonian, params):
+        def _prepare_circuit(hamiltonian, params):
             """
             Prepare the circuit for the VQE problem.
             Args:
@@ -158,7 +135,12 @@ class VQE(QuantumProgram):
                 hamiltonian (qml.Hamiltonian): The Hamiltonian to use
                 params (list): The parameters to use for the ansatz
             """
-            self._set_ansatz(ansatz, params)
+            self.ansatz.build(
+                params,
+                n_qubits=self.n_qubits,
+                n_layers=self.n_layers,
+                n_electrons=self.n_electrons,
+            )
 
             # Even though in principle we want to sample from a state,
             # we are applying an `expval` operation here to make it compatible
@@ -169,93 +151,12 @@ class VQE(QuantumProgram):
         return {
             "cost_circuit": self._meta_circuit_factory(
                 qml.tape.make_qscript(_prepare_circuit)(
-                    self.ansatz, self.cost_hamiltonian, weights_syms
+                    self.cost_hamiltonian, weights_syms
                 ),
                 symbols=weights_syms.flatten(),
             )
         }
 
-    def _set_ansatz(self, ansatz: VQEAnsatz, params):
-        """
-        Set the ansatz for the VQE problem.
-        Args:
-            ansatz (Ansatze): The ansatz to use
-            params (list): The parameters to use for the ansatz
-            n_layers (int): The number of layers to use for the ansatz
-        """
-
-        def _add_hw_efficient_ansatz(params):
-            raise NotImplementedError
-
-        def _add_qaoa_ansatz(params):
-            # This infers layers automatically from the parameters shape
-            qml.QAOAEmbedding(
-                features=[],
-                weights=params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-            )
-
-        def _add_ry_ansatz(params):
-            qml.layer(
-                qml.AngleEmbedding,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                rotation="Y",
-            )
-
-        def _add_ryrz_ansatz(params):
-            def _ryrz(params, wires):
-                ry_rots, rz_rots = params.reshape(2, -1)
-                qml.AngleEmbedding(ry_rots, wires=wires, rotation="Y")
-                qml.AngleEmbedding(rz_rots, wires=wires, rotation="Z")
-
-            qml.layer(
-                _ryrz,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-            )
-
-        def _add_uccsd_ansatz(params):
-            hf_state = qml.qchem.hf_state(self.n_electrons, self.n_qubits)
-
-            singles, doubles = qml.qchem.excitations(self.n_electrons, self.n_qubits)
-            s_wires, d_wires = qml.qchem.excitations_to_wires(singles, doubles)
-
-            qml.UCCSD(
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                s_wires=s_wires,
-                d_wires=d_wires,
-                init_state=hf_state,
-                n_repeats=self.n_layers,
-            )
-
-        def _add_hartree_fock_ansatz(params):
-            singles, doubles = qml.qchem.excitations(self.n_electrons, self.n_qubits)
-            hf_state = qml.qchem.hf_state(self.n_electrons, self.n_qubits)
-
-            qml.layer(
-                qml.AllSinglesDoubles,
-                self.n_layers,
-                params.reshape(self.n_layers, -1),
-                wires=range(self.n_qubits),
-                hf_state=hf_state,
-                singles=singles,
-                doubles=doubles,
-            )
-
-            # Reset the BasisState operations after the first layer
-            # for behaviour similar to UCCSD ansatz
-            for op in qml.QueuingManager.active_context().queue[1:]:
-                op._hyperparameters["hf_state"] = 0
-
-        if ansatz in VQEAnsatz:
-            locals()[f"_add_{ansatz.name.lower()}_ansatz"](params)
-        else:
-            raise ValueError(f"Invalid Ansatz Value. Got {ansatz}.")
-
     def _generate_circuits(self):
         """
         Generate the circuits for the VQE problem.

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/divi/qprog/batch.py

@@ -16,11 +16,9 @@ from warnings import warn
 from rich.console import Console
 from rich.progress import Progress, TaskID
 
-from divi._pbar import make_progress_bar
-from divi.interfaces import CircuitRunner
-from divi.parallel_simulator import ParallelSimulator
-from divi.qlogger import disable_logging
+from divi.backends import CircuitRunner, ParallelSimulator
 from divi.qprog.quantum_program import QuantumProgram
+from divi.reporting import disable_logging, make_progress_bar
 
 
 def queue_listener(

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/divi/qprog/optimizers.py

@@ -5,12 +5,11 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from enum import Enum
-from typing import Any
 
 import numpy as np
 from scipy.optimize import OptimizeResult, minimize
 
-from divi.exp.scipy._cobyla import _minimize_cobyla as cobyla_fn
+from divi.extern.scipy._cobyla import _minimize_cobyla as cobyla_fn
 
 
 class ScipyMethod(Enum):

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/divi/qprog/quantum_program.py

@@ -13,13 +13,11 @@ import numpy as np
 from pennylane.measurements import ExpectationMP
 from scipy.optimize import OptimizeResult
 
-from divi import QoroService
+from divi.backends import CircuitRunner, JobStatus, QoroService
 from divi.circuits import Circuit, MetaCircuit
-from divi.interfaces import CircuitRunner
-from divi.qem import _NoMitigation
-from divi.qoro_service import JobStatus
+from divi.circuits.qem import _NoMitigation
 from divi.qprog.optimizers import ScipyMethod, ScipyOptimizer
-from divi.reporter import LoggingProgressReporter, QueueProgressReporter
+from divi.reporting import LoggingProgressReporter, QueueProgressReporter
 
 logger = logging.getLogger(__name__)
 
@@ -145,6 +143,10 @@ class QuantumProgram(ABC):
     def meta_circuits(self):
         return self._meta_circuits
 
+    @property
+    def n_params(self):
+        return self._n_params
+
     @abstractmethod
     def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
         pass
@@ -282,13 +284,18 @@ class QuantumProgram(ABC):
             for shots_dicts, curr_measurement_group in zip(
                 shots_by_qem_idx, measurement_groups
             ):
+                if hasattr(self, "cost_hamiltonian"):
+                    wire_order = tuple(reversed(self.cost_hamiltonian.wires))
+                else:
+                    wire_order = tuple(
+                        reversed(range(len(next(iter(shots_dicts[0].keys())))))
+                    )
+
                 curr_marginal_results = []
                 for observable in curr_measurement_group:
+
                     intermediate_exp_values = [
-                        ExpectationMP(observable).process_counts(
-                            shots_dict,
-                            tuple(reversed(range(len(next(iter(shots_dict.keys())))))),
-                        )
+                        ExpectationMP(observable).process_counts(shots_dict, wire_order)
                         for shots_dict in shots_dicts
                     ]
 

qoro_divi-0.3.4/divi/qprog/workflows/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._graph_partitioning import (
+    GraphPartitioningQAOA,
+    PartitioningConfig,
+)
+from ._qubo_partitioning import QUBOPartitioningQAOA
+from ._vqe_sweep import MoleculeTransformer, VQEHyperparameterSweep

{qoro_divi-0.3.3/divi/qprog → qoro_divi-0.3.4/divi/qprog/workflows}/_graph_partitioning.py

@@ -20,9 +20,9 @@ import scipy.sparse.linalg as spla
 from pymetis import part_graph
 from sklearn.cluster import SpectralClustering
 
-from divi.interfaces import CircuitRunner
+from divi.backends import CircuitRunner
 from divi.qprog import QAOA, ProgramBatch, QuantumProgram
-from divi.qprog._qaoa import (
+from divi.qprog.algorithms._qaoa import (
     _SUPPORTED_INITIAL_STATES_LITERAL,
     GraphProblem,
     GraphProblemTypes,

{qoro_divi-0.3.3/divi/qprog → qoro_divi-0.3.4/divi/qprog/workflows}/_qubo_partitioning.py

@@ -12,8 +12,8 @@ import numpy as np
 import scipy.sparse as sps
 from dimod import BinaryQuadraticModel
 
-from divi.interfaces import CircuitRunner
-from divi.qprog._qaoa import QAOA, QUBOProblemTypes
+from divi.backends import CircuitRunner
+from divi.qprog.algorithms import QAOA, QUBOProblemTypes
 from divi.qprog.batch import ProgramBatch
 from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 from divi.qprog.quantum_program import QuantumProgram

{qoro_divi-0.3.3/divi/qprog → qoro_divi-0.3.4/divi/qprog/workflows}/_vqe_sweep.py

@@ -14,7 +14,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pennylane as qml
 
-from divi.qprog import VQE, ProgramBatch, VQEAnsatz
+from divi.qprog import VQE, Ansatz, ProgramBatch
 from divi.qprog.optimizers import MonteCarloOptimizer, Optimizer
 
 
@@ -392,7 +392,7 @@ class VQEHyperparameterSweep(ProgramBatch):
 
     def __init__(
         self,
-        ansatze: Sequence[VQEAnsatz],
+        ansatze: Sequence[Ansatz],
         molecule_transformer: MoleculeTransformer,
         optimizer: Optimizer | None = None,
         max_iterations: int = 10,
@@ -469,37 +469,49 @@ class VQEHyperparameterSweep(ProgramBatch):
         if self._executor is not None:
             self.join()
 
-        data = []
-        colors = ["blue", "g", "r", "c", "m", "y", "k"]
+        # Get the unique ansatz objects that were actually run
+        # Assumes `self.ansatze` is a list of the ansatz instances used.
+        unique_ansatze = self.ansatze
 
-        ansatz_list = list(VQEAnsatz)
+        # Create a stable color mapping for each unique ansatz object
+        colors = ["blue", "g", "r", "c", "m", "y", "k"]
+        color_map = {
+            ansatz: colors[i % len(colors)] for i, ansatz in enumerate(unique_ansatze)
+        }
 
         if graph_type == "scatter":
-            for ansatz, modifier in self.programs.keys():
+            # Plot each ansatz's results as a separate series for clarity
+            for ansatz in unique_ansatze:
+                modifiers = []
                 min_energies = []
-
-                curr_energies = self.programs[(ansatz, modifier)].losses[-1]
-                min_energies.append(
-                    (
-                        modifier,
-                        min(curr_energies.values()),
-                        colors[ansatz_list.index(ansatz)],
-                    )
+                for modifier in self.molecule_transformer.bond_modifiers:
+                    program_key = (ansatz, modifier)
+                    if program_key in self.programs:
+                        modifiers.append(modifier)
+                        curr_energies = self.programs[program_key].losses[-1]
+                        min_energies.append(min(curr_energies.values()))
+
+                # Use the new .name property for the label and the color_map
+                plt.scatter(
+                    modifiers,
+                    min_energies,
+                    color=color_map[ansatz],
+                    label=ansatz.name,
                 )
-                data.extend(min_energies)
-
-            x, y, z = zip(*data)
-            plt.scatter(x, y, color=z, label=ansatz)
 
         elif graph_type == "line":
-            for ansatz in self.ansatze:
+            for ansatz in unique_ansatze:
                 energies = []
                 for modifier in self.molecule_transformer.bond_modifiers:
                     energies.append(
                         min(self.programs[(ansatz, modifier)].losses[-1].values())
                     )
+
                 plt.plot(
-                    self.molecule_transformer.bond_modifiers, energies, label=ansatz
+                    self.molecule_transformer.bond_modifiers,
+                    energies,
+                    label=ansatz.name,
+                    color=color_map[ansatz],
                 )
 
         plt.xlabel(

qoro_divi-0.3.4/divi/reporting/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from ._pbar import make_progress_bar
+from ._qlogger import disable_logging, enable_logging
+from ._reporter import LoggingProgressReporter, ProgressReporter, QueueProgressReporter

qoro_divi-0.3.3/divi/qlogger.py → qoro_divi-0.3.4/divi/reporting/_qlogger.py

@@ -103,7 +103,8 @@ def enable_logging(level=logging.INFO):
     root_logger = logging.getLogger(__name__.split(".")[0])
 
     formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
     )
 
     handler = OverwriteStreamHandler(sys.stdout)

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/divi/utils.py

@@ -35,9 +35,10 @@ def convert_qubo_matrix_to_pennylane_ising(
 ) -> tuple[qml.operation.Operator, float]:
     """Convert QUBO matrix to Ising Hamiltonian in Pennylane.
 
-    The conversion follows the mapping:
-    - QUBO variables x_i ∈ {0,1} map to Ising variables s_i ∈ {-1,1} via s_i = 2x_i - 1
-    - This transforms a QUBO problem into an equivalent Ising problem
+    The conversion follows the mapping from QUBO variables x_i ∈ {0,1} to
+    Ising variables σ_i ∈ {-1,1} via the transformation x_i = (1 - σ_i)/2. This
+    transforms a QUBO minimization problem into an equivalent Ising minimization
+    problem.
 
     Args:
         qubo_matrix: The QUBO matrix Q where the objective is to minimize x^T Q x
@@ -56,17 +57,24 @@ def convert_qubo_matrix_to_pennylane_ising(
     is_sparse = sps.issparse(qubo_matrix)
     backend = sps if is_sparse else np
 
+    symmetrized_qubo = (qubo_matrix + qubo_matrix.T) / 2
+
     # Gather non-zero indices in the upper triangle of the matrix
     triu_matrix = backend.triu(
-        qubo_matrix,
+        symmetrized_qubo,
         **(
             {"format": qubo_matrix.format if qubo_matrix.format != "coo" else "csc"}
             if is_sparse
             else {}
         ),
     )
-    rows, cols = triu_matrix.nonzero()
-    values = triu_matrix[rows, cols].A1 if is_sparse else triu_matrix[rows, cols]
+
+    if is_sparse:
+        coo_mat = triu_matrix.tocoo()
+        rows, cols, values = coo_mat.row, coo_mat.col, coo_mat.data
+    else:
+        rows, cols = triu_matrix.nonzero()
+        values = triu_matrix[rows, cols]
 
     n = qubo_matrix.shape[0]
     linear_terms = np.zeros(n)

{qoro_divi-0.3.3 → qoro_divi-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qoro-divi"
-version = "0.3.3"
+version = "0.3.4"
 description = "A Python library to automate generating, parallelizing, and executing quantum programs."
 authors = ["Ahmed Darwish <ahmed@qoroquantum.de>", "Stephen DiAdamo <stephen@qoroquantum.de>"]
 readme = "README.md"

qoro_divi-0.3.3/divi/qprog/__init__.py

@@ -1,13 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-# isort: skip_file
-from .quantum_program import QuantumProgram
-from .batch import ProgramBatch
-from ._qaoa import QAOA, GraphProblem
-from ._vqe import VQE, VQEAnsatz
-from ._graph_partitioning import GraphPartitioningQAOA, PartitioningConfig
-from ._qubo_partitioning import QUBOPartitioningQAOA
-from ._vqe_sweep import VQEHyperparameterSweep, MoleculeTransformer
-from .optimizers import ScipyOptimizer, ScipyMethod, MonteCarloOptimizer