qoro-divi 0.2.0b1__py3-none-any.whl

divi/qprog/_mlae.py

@@ -0,0 +1,182 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from functools import reduce
+
+import numpy as np
+import scipy.optimize as optimize
+from qiskit import QuantumCircuit
+from qiskit_algorithms import EstimationProblem, MaximumLikelihoodAmplitudeEstimation
+
+from divi.circuits import Circuit
+from divi.qprog.quantum_program import QuantumProgram
+
+
+class BernoulliA(QuantumCircuit):
+    """A circuit representing the Bernoulli A operator."""
+
+    def __init__(self, probability):
+        super().__init__(1)
+
+        theta_p = 2 * np.arcsin(np.sqrt(probability))
+        self.ry(theta_p, 0)
+
+
+class BernoulliQ(QuantumCircuit):
+    """A circuit representing the Bernoulli Q operator."""
+
+    def __init__(self, probability):
+        super().__init__(1)
+
+        self._theta_p = 2 * np.arcsin(np.sqrt(probability))
+        self.ry(2 * self._theta_p, 0)
+
+    def power(self, k):
+        # implement the efficient power of Q
+        q_k = QuantumCircuit(1)
+        q_k.ry(2 * k * self._theta_p, 0)
+        return q_k
+
+
+class MLAE(QuantumProgram):
+    """
+    An implementation of the Maximum Likelihood Amplitude Estimateion described in
+    https://arxiv.org/pdf/1904.10246
+    """
+
+    def __init__(
+        self,
+        grovers: list[int],
+        qubits_to_measure: list[int],
+        probability: float,
+        **kwargs,
+    ):
+        """
+        Initializes the MLAE problem.
+        args:
+            grovers (list): A list of non-negative integers corresponding to the powers of the Grover
+            operator for each iteration
+            qubits: An integer or list of integers containing the index of the qubits to measure
+            probability: The probability of being in the good state to estimate
+            shots: The number of shots to run for each circuit. Default set at 5000.
+        """
+
+        super().__init__(**kwargs)
+
+        self.grovers = grovers
+        self.qubits_to_measure = qubits_to_measure
+        self.probability = probability
+        self.likelihood_functions = []
+
+    def _create_meta_circuits_dict(self):
+        return super()._create_meta_circuits_dict()
+
+    def _generate_circuits(self, params=None, **kwargs):
+        """
+        Generates the circuits that perform step one of the MLAE algorithm,
+            the quantum amplitude amplification.
+
+        Inputs a selection of m values corresponding to the powers of the
+            Grover operatorfor each iteration.
+
+        Returns:
+            A list of QASM circuits to run on various devices
+        """
+        self.circuits.clear()
+
+        A = BernoulliA(self.probability)
+        Q = BernoulliQ(self.probability)
+
+        problem = EstimationProblem(
+            state_preparation=A,
+            grover_operator=Q,
+            objective_qubits=self.qubits_to_measure,
+        )
+
+        qiskit_circuits = MaximumLikelihoodAmplitudeEstimation(
+            self.grovers
+        ).construct_circuits(problem)
+
+        for circuit, grover in zip(qiskit_circuits, self.grovers):
+            circuit.measure_all()
+            self.circuits.append(Circuit(circuit, tags=[f"{grover}"]))
+
+    def run(self, store_data=False, data_file=None):
+        self._generate_circuits()
+        self._dispatch_circuits_and_process_results(
+            store_data=store_data, data_file=data_file
+        )
+
+    def _post_process_results(self, results):
+        """
+        Generates the likelihood function for each circuit of the quantum
+        amplitude amplification. These likelihood functions will then
+        be combined to create a maximum likelihood function to analyze.
+
+        Returns:
+            A callable maximum likelihood function
+        """
+
+        # Define the necessary variables Nk, Mk, Lk
+        for label, shots_dict in results.items():
+            mk = int(label)
+            Nk = 0
+            hk = 0
+            for key, shots in shots_dict.items():
+                Nk += shots
+                hk += shots if key.count("1") == len(key) else 0
+
+            def likelihood_function(theta, mk=mk, hk=hk, Nk=Nk):
+                as_theta = np.arcsin(np.sqrt(theta))
+                return ((np.sin((2 * mk + 1) * as_theta)) ** (2 * hk)) * (
+                    (np.cos((2 * mk + 1) * as_theta)) ** (2 * (Nk - hk))
+                )
+
+            self.likelihood_functions.append(likelihood_function)
+
+    def generate_maximum_likelihood_function(self, factor=1.0):
+        """
+        Post-processing takes in likelihood functions.
+
+        A large factor (e.g. 1e200) should be used for visualization purposes.
+        Returns:
+            The maximum likelihood function.
+        """
+
+        def combined_likelihood_function(theta):
+            return (
+                reduce(
+                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
+                )
+                * factor
+            )
+
+        self.maximum_likelihood_fn = combined_likelihood_function
+
+        return combined_likelihood_function
+
+    def estimate_amplitude(self, factor):
+        """
+        Uses the maximum likelihood function to ascertain
+        a value for the amplitude.
+
+        Returns
+            Estimation of the amplitude
+        """
+
+        def minimum_likelihood_function(theta):
+            # The factor to set to -10e30 in the older branch
+            return (
+                reduce(
+                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
+                )
+                * factor
+            )
+
+        # create the range of possible amplitudes
+        amplitudes = np.linspace(0, 1, 100)
+
+        bounds = [(min(amplitudes), max(amplitudes))]
+
+        return optimize.differential_evolution(minimum_likelihood_function, bounds).x[0]

divi/qprog/_qaoa.py

@@ -0,0 +1,440 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from enum import Enum
+from functools import reduce
+from typing import Literal, Optional, get_args
+from warnings import warn
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import pennylane as qml
+import pennylane.qaoa as pqaoa
+import rustworkx as rx
+import scipy.sparse as sps
+import sympy as sp
+from qiskit_optimization import QuadraticProgram
+from qiskit_optimization.converters import QuadraticProgramToQubo
+from qiskit_optimization.problems import VarType
+
+from divi.circuits import MetaCircuit
+from divi.qprog import QuantumProgram
+from divi.qprog.optimizers import Optimizer
+from divi.utils import convert_qubo_matrix_to_pennylane_ising
+
+GraphProblemTypes = nx.Graph | rx.PyGraph
+QUBOProblemTypes = list | np.ndarray | sps.spmatrix | QuadraticProgram
+
+
+def draw_graph_solution_nodes(main_graph, partition_nodes):
+    # Create a dictionary for node colors
+    node_colors = [
+        "red" if node in partition_nodes else "lightblue" for node in main_graph.nodes()
+    ]
+
+    plt.figure(figsize=(10, 8))
+
+    pos = nx.spring_layout(main_graph)
+
+    nx.draw_networkx_nodes(main_graph, pos, node_color=node_colors, node_size=500)
+    nx.draw_networkx_edges(main_graph, pos)
+    nx.draw_networkx_labels(main_graph, pos, font_size=10, font_weight="bold")
+
+    # Remove axes
+    plt.axis("off")
+
+    # Show the plot
+    plt.tight_layout()
+    plt.show()
+
+
+class GraphProblem(Enum):
+    MAX_CLIQUE = ("max_clique", "Zeros", "Superposition")
+    MAX_INDEPENDENT_SET = ("max_independent_set", "Zeros", "Superposition")
+    MAX_WEIGHT_CYCLE = ("max_weight_cycle", "Superposition", "Superposition")
+    MAXCUT = ("maxcut", "Superposition", "Superposition")
+    MIN_VERTEX_COVER = ("min_vertex_cover", "Ones", "Superposition")
+
+    # This is an internal problem with no pennylane equivalent
+    EDGE_PARTITIONING = ("", "", "")
+
+    def __init__(
+        self,
+        pl_string: str,
+        constrained_initial_state: str,
+        unconstrained_initial_state: str,
+    ):
+        self.pl_string = pl_string
+
+        # Recommended initial state as per Pennylane's documentation.
+        # Value is duplicated if not applicable to the problem
+        self.constrained_initial_state = constrained_initial_state
+        self.unconstrained_initial_state = unconstrained_initial_state
+
+
+_SUPPORTED_INITIAL_STATES_LITERAL = Literal[
+    "Zeros", "Ones", "Superposition", "Recommended"
+]
+
+
+def _convert_quadratic_program_to_pennylane_ising(qp: QuadraticProgram):
+    qiskit_sparse_op, constant = qp.to_ising()
+
+    pauli_list = qiskit_sparse_op.paulis
+
+    pennylane_ising = 0.0
+    for pauli_string, coeff in zip(pauli_list.z, qiskit_sparse_op.coeffs):
+        sanitized_coeff = coeff.real if np.isreal(coeff) else coeff
+
+        curr_term = (
+            reduce(
+                lambda x, y: x @ y,
+                map(lambda x: qml.Z(x), np.flatnonzero(pauli_string)),
+            )
+            * sanitized_coeff.item()
+        )
+
+        pennylane_ising += curr_term
+
+    return pennylane_ising, constant.item(), pauli_list.num_qubits
+
+
+def _resolve_circuit_layers(
+    initial_state, problem, graph_problem, **kwargs
+) -> tuple[qml.operation.Operator, qml.operation.Operator, Optional[dict], str]:
+    """
+    Generates the cost and mixer hamiltonians for a given problem, in addition to
+    optional metadata returned by Pennylane if applicable
+    """
+
+    if isinstance(problem, GraphProblemTypes):
+        is_constrained = kwargs.pop("is_constrained", True)
+
+        if graph_problem == GraphProblem.MAXCUT:
+            params = (problem,)
+        else:
+            params = (problem, is_constrained)
+
+        if initial_state == "Recommended":
+            resolved_initial_state = (
+                graph_problem.constrained_initial_state
+                if is_constrained
+                else graph_problem.constrained_initial_state
+            )
+        else:
+            resolved_initial_state = initial_state
+
+        return *getattr(pqaoa, graph_problem.pl_string)(*params), resolved_initial_state
+    else:
+        if isinstance(problem, QuadraticProgram):
+            cost_hamiltonian, constant, n_qubits = (
+                _convert_quadratic_program_to_pennylane_ising(problem)
+            )
+        else:
+            cost_hamiltonian, constant = convert_qubo_matrix_to_pennylane_ising(problem)
+
+            n_qubits = problem.shape[0]
+
+        return (
+            cost_hamiltonian,
+            pqaoa.x_mixer(range(n_qubits)),
+            {"constant": constant},
+            "Superposition",
+        )
+
+
+class QAOA(QuantumProgram):
+    def __init__(
+        self,
+        problem: GraphProblemTypes | QUBOProblemTypes,
+        graph_problem: Optional[GraphProblem] = None,
+        n_layers: int = 1,
+        initial_state: _SUPPORTED_INITIAL_STATES_LITERAL = "Recommended",
+        optimizer: Optimizer = Optimizer.MONTE_CARLO,
+        max_iterations: int = 10,
+        **kwargs,
+    ):
+        """
+        Initialize the QAOA problem.
+
+        Args:
+            problem: The problem to solve, can either be a graph or a QUBO.
+                For graph inputs, the graph problem to solve must be provided
+                through the `graph_problem` variable.
+            graph_problem (str): The graph problem to solve.
+            n_layers (int): number of QAOA layers
+            initial_state (str): The initial state of the circuit
+        """
+
+        if isinstance(problem, QUBOProblemTypes):
+            if graph_problem is not None:
+                warn("Ignoring the 'problem' argument as it is not applicable to QUBO.")
+
+            self.graph_problem = None
+
+            if isinstance(problem, QuadraticProgram):
+                if (
+                    any(var.vartype != VarType.BINARY for var in problem.variables)
+                    or problem.linear_constraints
+                    or problem.quadratic_constraints
+                ):
+                    warn(
+                        "Quadratic Program contains non-binary variables. Converting to QUBO."
+                    )
+                    self._qp_converter = QuadraticProgramToQubo()
+                    problem = self._qp_converter.convert(problem)
+
+                self.n_qubits = problem.get_num_vars()
+            else:
+                if isinstance(problem, list):
+                    problem = np.array(problem)
+
+                if problem.ndim != 2 or problem.shape[0] != problem.shape[1]:
+                    raise ValueError(
+                        "Invalid QUBO matrix."
+                        f" Got array of shape {problem.shape}."
+                        " Must be a square matrix."
+                    )
+
+                self.n_qubits = problem.shape[1]
+        else:
+            if not isinstance(graph_problem, GraphProblem):
+                raise ValueError(
+                    f"Unsupported Problem. Got '{graph_problem}'. Must be one of type divi.qprog.GraphProblem."
+                )
+
+            self.graph_problem = graph_problem
+            self.n_qubits = problem.number_of_nodes()
+
+        self.problem = problem
+
+        if initial_state not in get_args(_SUPPORTED_INITIAL_STATES_LITERAL):
+            raise ValueError(
+                f"Unsupported Initial State. Got {initial_state}. Must be one of: {get_args(_SUPPORTED_INITIAL_STATES_LITERAL)}"
+            )
+
+        # Local Variables
+        self.n_layers = n_layers
+        self.optimizer = optimizer
+        self.max_iterations = max_iterations
+        self.current_iteration = 0
+        self._solution_nodes = None
+        self.n_params = 2
+        self._is_compute_probabilites = False
+
+        # Shared Variables
+        self.probs = kwargs.pop("probs", {})
+
+        (
+            self.cost_hamiltonian,
+            self.mixer_hamiltonian,
+            *problem_metadata,
+            self.initial_state,
+        ) = _resolve_circuit_layers(
+            initial_state=initial_state,
+            problem=problem,
+            graph_problem=graph_problem,
+            **kwargs,
+        )
+        self.problem_metadata = problem_metadata[0] if problem_metadata else {}
+
+        self.loss_constant = self.problem_metadata.get("constant", 0.0)
+
+        kwargs.pop("is_constrained", None)
+        super().__init__(**kwargs)
+
+        self._meta_circuits = self._create_meta_circuits_dict()
+
+    @property
+    def solution(self):
+        return (
+            self._solution_nodes
+            if self.graph_problem is not None
+            else self._solution_bitstring
+        )
+
+    def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
+        """
+        Generate the meta circuits for the QAOA problem.
+
+        In this method, we generate the scaffolding for the circuits that will be
+        executed during optimization.
+        """
+
+        betas = sp.symarray("β", self.n_layers)
+        gammas = sp.symarray("γ", self.n_layers)
+
+        sym_params = np.vstack((betas, gammas)).transpose()
+
+        def _qaoa_layer(params):
+            gamma, beta = params
+            pqaoa.cost_layer(gamma, self.cost_hamiltonian)
+            pqaoa.mixer_layer(beta, self.mixer_hamiltonian)
+
+        def _prepare_circuit(hamiltonian, params, final_measurement):
+            """
+            Prepare the circuit for the QAOA problem.
+            Args:
+                hamiltonian (qml.Hamiltonian): The Hamiltonian term to measure
+            """
+
+            # Note: could've been done as qml.[Insert Gate](wires=range(self.n_qubits))
+            # but there seems to be a bug with program capture in Pennylane.
+            # Maybe check when a new version comes out?
+            if self.initial_state == "Ones":
+                for i in range(self.n_qubits):
+                    qml.PauliX(wires=i)
+            elif self.initial_state == "Superposition":
+                for i in range(self.n_qubits):
+                    qml.Hadamard(wires=i)
+
+            qml.layer(_qaoa_layer, self.n_layers, params)
+
+            if final_measurement:
+                return qml.probs()
+            else:
+                return qml.expval(hamiltonian)
+
+        return {
+            "cost_circuit": self._meta_circuit_factory(
+                qml.tape.make_qscript(_prepare_circuit)(
+                    self.cost_hamiltonian, sym_params, final_measurement=False
+                ),
+                symbols=sym_params.flatten(),
+            ),
+            "meas_circuit": self._meta_circuit_factory(
+                qml.tape.make_qscript(_prepare_circuit)(
+                    self.cost_hamiltonian, sym_params, final_measurement=True
+                ),
+                symbols=sym_params.flatten(),
+            ),
+        }
+
+    def _generate_circuits(self):
+        """
+        Generate the circuits for the QAOA problem.
+
+        In this method, we generate bulk circuits based on the selected parameters.
+        """
+
+        circuit_type = (
+            "cost_circuit" if not self._is_compute_probabilites else "meas_circuit"
+        )
+
+        for p, params_group in enumerate(self._curr_params):
+            circuit = self._meta_circuits[circuit_type].initialize_circuit_from_params(
+                params_group, tag_prefix=f"{p}"
+            )
+
+            self.circuits.append(circuit)
+
+    def _post_process_results(self, results):
+        """
+        Post-process the results of the QAOA problem.
+
+        Returns:
+            (dict) The losses for each parameter set grouping.
+        """
+
+        if self._is_compute_probabilites:
+            return {
+                outer_k: {
+                    inner_k: inner_v / self.backend.shots
+                    for inner_k, inner_v in outer_v.items()
+                }
+                for outer_k, outer_v in results.items()
+            }
+
+        losses = super()._post_process_results(results)
+
+        return losses
+
+    def _run_final_measurement(self):
+        self._is_compute_probabilites = True
+
+        self._curr_params = np.array(self.final_params)
+
+        self.circuits[:] = []
+
+        self._generate_circuits()
+
+        self.probs.update(self._dispatch_circuits_and_process_results())
+
+        self._is_compute_probabilites = False
+
+    def compute_final_solution(self):
+        """
+        Computes and extracts the final solution from the QAOA optimization process.
+        This method performs the following steps:
+            1. Identifies the best solution index based on the lowest loss value from the last optimization step.
+            2. Executes the final measurement circuit to obtain the probability distributions of solutions.
+            3. Retrieves the bitstring representing the best solution, correcting for endianness.
+            4. Depending on the problem type:
+            - For QUBO problems, stores the solution as a NumPy array of bits.
+            - For graph problems, stores the solution as a list of node indices corresponding to '1's in the bitstring.
+            5. Returns the total circuit count and total runtime for the optimization process.
+        Returns:
+            tuple: A tuple containing:
+            - int: The total number of circuits executed.
+            - float: The total runtime of the optimization process.
+        Raises:
+            RuntimeError: If more than one/no matching key is found for the best solution index.
+        """
+
+        # Convert losses dict to list to apply ordinal operations
+        final_losses_list = list(self.losses[-1].values())
+
+        # Get the index of the smallest loss in the last operation
+        best_solution_idx = min(
+            range(len(final_losses_list)),
+            key=lambda x: final_losses_list.__getitem__(x),
+        )
+
+        # Insert the measurement circuit here
+        self._run_final_measurement()
+
+        # Find the key matching the best_solution_idx with possible metadata in between
+        pattern = re.compile(rf"^{best_solution_idx}(?:_[^_]*)*_0$")
+        matching_keys = [k for k in self.probs.keys() if pattern.match(k)]
+
+        # Some minor sanity checks
+        if len(matching_keys) == 0:
+            raise RuntimeError("No matching key found.")
+        if len(matching_keys) > 1:
+            raise RuntimeError(f"More than one matching key found.")
+
+        best_solution_key = matching_keys[0]
+        # Retrieve the probability distribution dictionary of the best solution
+        best_solution_probs = self.probs[best_solution_key]
+
+        # Retrieve the bitstring with the actual best solution
+        # Reverse to account for the endianness difference
+        best_solution_bitstring = max(best_solution_probs, key=best_solution_probs.get)[
+            ::-1
+        ]
+
+        if isinstance(self.problem, QUBOProblemTypes):
+            self._solution_bitstring = np.fromiter(
+                best_solution_bitstring, dtype=np.int32
+            )
+
+        if isinstance(self.problem, GraphProblemTypes):
+            self._solution_nodes = [
+                m.start() for m in re.finditer("1", best_solution_bitstring)
+            ]
+
+        return self._total_circuit_count, self._total_run_time
+
+    def draw_solution(self):
+        if self.graph_problem is None:
+            raise RuntimeError(
+                "The problem is not a graph problem. Cannot draw solution."
+            )
+
+        if not self._solution_nodes:
+            self.compute_final_solution()
+
+        draw_graph_solution_nodes(self.problem, self._solution_nodes)