qoro-divi 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

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()

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

divi/{parallel_simulator.py → 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)

divi/{qoro_service.py → 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)
 

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

divi/{circuits.py → 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:

divi/{qasm.py → 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",

divi/{exp → 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)

divi/qprog/__init__.py

@@ -5,9 +5,22 @@
 # 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 .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

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

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

divi/qprog/{_qaoa.py → 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()