qoro-divi 0.2.0b1__py3-none-any.whl → 0.5.0__py3-none-any.whl

divi/qprog/_vqe.py

@@ -1,275 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from enum import Enum
-
-import numpy as np
-import pennylane as qml
-import sympy as sp
-
-from divi.circuits import MetaCircuit
-from divi.qprog import QuantumProgram
-from divi.qprog.optimizers import 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,
-        symbols,
-        bond_length: float,
-        coordinate_structure: list[tuple[float, float, float]],
-        charge: float = 0,
-        n_layers: int = 1,
-        ansatz=VQEAnsatz.HARTREE_FOCK,
-        optimizer=Optimizer.MONTE_CARLO,
-        max_iterations=10,
-        **kwargs,
-    ) -> None:
-        """
-        Initialize the VQE problem.
-
-        Args:
-            symbols (list): The symbols of the atoms in the molecule
-            bond_length (float): The bond length to consider
-            coordinate_structure (list): The coordinate structure of the molecule, represented in unit lengths
-            charge (float): the charge of the molecule. Defaults to 0.
-            ansatz (VQEAnsatz): 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.symbols = symbols
-        self.coordinate_structure = coordinate_structure
-        self.bond_length = bond_length
-        self.charge = charge
-        if len(self.coordinate_structure) != len(self.symbols):
-            raise ValueError(
-                "The number of symbols must match the number of coordinates"
-            )
-
-        self.n_layers = n_layers
-        self.results = {}
-        self.ansatz = ansatz
-        self.optimizer = optimizer
-        self.max_iterations = max_iterations
-        self.current_iteration = 0
-
-        self.cost_hamiltonian = self._generate_hamiltonian_operations()
-
-        super().__init__(**kwargs)
-
-        self._meta_circuits = self._create_meta_circuits_dict()
-
-    def _generate_hamiltonian_operations(self) -> qml.operation.Operator:
-        """
-        Generate the Hamiltonian operators for the given bond length.
-
-        Returns:
-            The Hamiltonian corresponding to the VQE problem.
-        """
-
-        coordinates = [
-            (
-                coord_0 * self.bond_length,
-                coord_1 * self.bond_length,
-                coord_2 * self.bond_length,
-            )
-            for (coord_0, coord_1, coord_2) in self.coordinate_structure
-        ]
-
-        coordinates = np.array(coordinates)
-        molecule = qml.qchem.Molecule(self.symbols, coordinates, charge=self.charge)
-        hamiltonian, qubits = qml.qchem.molecular_hamiltonian(molecule)
-
-        self.n_qubits = qubits
-        self.n_electrons = molecule.n_electrons
-
-        self.n_params = self.ansatz.n_params(
-            self.n_qubits, n_electrons=self.n_electrons
-        )
-
-        constant_terms_idx = list(
-            filter(
-                lambda x: all(
-                    isinstance(term, qml.I) for term in hamiltonian[x].terms()[1]
-                ),
-                range(len(hamiltonian)),
-            )
-        )
-
-        self.loss_constant = sum(
-            map(lambda x: hamiltonian[x].scalar.item(), constant_terms_idx)
-        )
-
-        for idx in constant_terms_idx:
-            hamiltonian -= hamiltonian[idx]
-
-        return hamiltonian.simplify()
-
-    def _create_meta_circuits_dict(self) -> dict[str, MetaCircuit]:
-        weights_syms = sp.symarray("w", (self.n_layers, self.n_params))
-
-        def _prepare_circuit(ansatz, hamiltonian, params):
-            """
-            Prepare the circuit for the VQE problem.
-            Args:
-                ansatz (Ansatze): The ansatz to use
-                hamiltonian (qml.Hamiltonian): The Hamiltonian to use
-                params (list): The parameters to use for the ansatz
-            """
-            self._set_ansatz(ansatz, params)
-
-            # Even though in principle we want to sample from a state,
-            # we are applying an `expval` operation here to make it compatible
-            # with the pennylane transforms down the line, which complain about
-            # the `sample` operation.
-            return qml.expval(hamiltonian)
-
-        return {
-            "cost_circuit": self._meta_circuit_factory(
-                qml.tape.make_qscript(_prepare_circuit)(
-                    self.ansatz, 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.
-
-        In this method, we generate bulk circuits based on the selected parameters.
-        We generate circuits for each bond length and each ansatz and optimization choice.
-
-        The structure of the circuits is as follows:
-        - For each bond length:
-            - For each ansatz:
-                - Generate the circuit
-        """
-
-        for p, params_group in enumerate(self._curr_params):
-            circuit = self._meta_circuits[
-                "cost_circuit"
-            ].initialize_circuit_from_params(params_group, tag_prefix=f"{p}")
-
-            self.circuits.append(circuit)
-
-    def _run_optimization_circuits(self, store_data, data_file):
-        if self.cost_hamiltonian is None or len(self.cost_hamiltonian) == 0:
-            raise RuntimeError(
-                "Hamiltonian operators must be generated before running the VQE"
-            )
-
-        return super()._run_optimization_circuits(store_data, data_file)

divi/qprog/_vqe_sweep.py

@@ -1,144 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from functools import partial
-from itertools import product
-from typing import Literal
-
-import matplotlib.pyplot as plt
-
-from divi.qprog import VQE, ProgramBatch, VQEAnsatz
-
-from .optimizers import Optimizer
-
-
-class VQEHyperparameterSweep(ProgramBatch):
-    """Allows user to carry out a grid search across different values
-    for the ansatz and the bond length used in a VQE program.
-    """
-
-    def __init__(
-        self,
-        bond_lengths: list[float],
-        ansatze: list[VQEAnsatz],
-        symbols: list[str],
-        coordinate_structure: list[tuple[float, float, float]],
-        charge: float = 0,
-        optimizer: Optimizer = Optimizer.MONTE_CARLO,
-        max_iterations: int = 10,
-        **kwargs,
-    ):
-        """Initiates the class.
-
-        Args:
-            bond_lengths (list): The bond lengths to consider.
-            ansatze (list): The ansatze to use for the VQE problem.
-            symbols (list): The symbols of the atoms in the molecule.
-            coordinate_structure (list): The coordinate structure of the molecule.
-            optimizer (Optimizers): The optimizer to use.
-            max_iterations (int): Maximum number of iteration optimizers.
-        """
-        super().__init__(backend=kwargs.pop("backend"))
-
-        self.ansatze = ansatze
-        self.bond_lengths = [round(bnd, 9) for bnd in bond_lengths]
-        self.max_iterations = max_iterations
-
-        self._constructor = partial(
-            VQE,
-            symbols=symbols,
-            coordinate_structure=coordinate_structure,
-            charge=charge,
-            optimizer=optimizer,
-            max_iterations=self.max_iterations,
-            backend=self.backend,
-            **kwargs,
-        )
-
-    def create_programs(self):
-        if len(self.programs) > 0:
-            raise RuntimeError(
-                "Some programs already exist. "
-                "Clear the program dictionary before creating new ones by using batch.reset()."
-            )
-
-        super().create_programs()
-
-        for ansatz, bond_length in product(self.ansatze, self.bond_lengths):
-            _job_id = (ansatz, bond_length)
-            self.programs[_job_id] = self._constructor(
-                job_id=_job_id,
-                bond_length=bond_length,
-                ansatz=ansatz,
-                losses=self._manager.list(),
-                final_params=self._manager.list(),
-                progress_queue=self._queue,
-            )
-
-    def aggregate_results(self):
-        if len(self.programs) == 0:
-            raise RuntimeError("No programs to aggregate. Run create_programs() first.")
-
-        if self._executor is not None:
-            self.wait_for_all()
-
-        if any(len(program.losses) == 0 for program in self.programs.values()):
-            raise RuntimeError(
-                "Some/All programs have empty losses. Did you call run()?"
-            )
-
-        all_energies = {key: prog.losses[-1] for key, prog in self.programs.items()}
-
-        smallest_key = min(all_energies, key=lambda k: min(all_energies[k].values()))
-        smallest_value = min(all_energies[smallest_key].values())
-
-        return smallest_key, smallest_value
-
-    def visualize_results(self, graph_type: Literal["line", "scatter"] = "line"):
-        """
-        Visualize the results of the VQE problem.
-        """
-        if graph_type not in ["line", "scatter"]:
-            raise ValueError(
-                f"Invalid graph type: {graph_type}. Choose between 'line' and 'scatter'."
-            )
-
-        if self._executor is not None:
-            self.wait_for_all()
-
-        data = []
-        colors = ["blue", "g", "r", "c", "m", "y", "k"]
-
-        ansatz_list = list(VQEAnsatz)
-
-        if graph_type == "scatter":
-            for ansatz, bond_length in self.programs.keys():
-                min_energies = []
-
-                curr_energies = self.programs[(ansatz, bond_length)].losses[-1]
-                min_energies.append(
-                    (
-                        bond_length,
-                        min(curr_energies.values()),
-                        colors[ansatz_list.index(ansatz)],
-                    )
-                )
-                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:
-                energies = []
-                for bond_length in self.bond_lengths:
-                    energies.append(
-                        min(self.programs[(ansatz, bond_length)].losses[-1].values())
-                    )
-                plt.plot(self.bond_lengths, energies, label=ansatz)
-
-        plt.xlabel("Bond length")
-        plt.ylabel("Energy level")
-        plt.legend()
-        plt.show()

divi/utils.py

@@ -1,116 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from functools import reduce
-from warnings import warn
-
-import numpy as np
-import pennylane as qml
-import scipy.sparse as sps
-
-
-def _is_sanitized(
-    qubo_matrix: np.ndarray | sps.spmatrix,
-) -> np.ndarray | sps.spmatrix:
-    # Sanitize the QUBO matrix to ensure it is either symmetric or upper triangular.
-
-    is_sparse = sps.issparse(qubo_matrix)
-
-    return (
-        (
-            ((qubo_matrix != qubo_matrix.T).nnz == 0)
-            or ((qubo_matrix != sps.triu(qubo_matrix)).nnz == 0)
-        )
-        if is_sparse
-        else (
-            np.allclose(qubo_matrix, qubo_matrix.T)
-            or np.allclose(qubo_matrix, np.triu(qubo_matrix))
-        )
-    )
-
-
-def convert_qubo_matrix_to_pennylane_ising(
-    qubo_matrix: np.ndarray | sps.spmatrix,
-) -> 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
-
-    Args:
-        qubo_matrix: The QUBO matrix Q where the objective is to minimize x^T Q x
-
-    Returns:
-        A tuple of (Ising Hamiltonian as a PennyLane operator, constant term)
-    """
-
-    if not _is_sanitized(qubo_matrix):
-        warn(
-            "The QUBO matrix is neither symmetric nor upper triangular."
-            " Symmetrizing it for the Ising Hamiltonian creation."
-        )
-        qubo_matrix = (qubo_matrix + qubo_matrix.T) / 2
-
-    is_sparse = sps.issparse(qubo_matrix)
-    backend = sps if is_sparse else np
-
-    # Gather non-zero indices in the upper triangle of the matrix
-    triu_matrix = backend.triu(
-        qubo_matrix,
-        **(
-            {"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]
-
-    n = qubo_matrix.shape[0]
-    linear_terms = np.zeros(n)
-    constant_term = 0.0
-    ising_terms = []
-    ising_weights = []
-
-    for i, j, weight in zip(rows, cols, values):
-        weight = float(weight)
-        i, j = int(i), int(j)
-
-        if i == j:
-            # Diagonal elements
-            linear_terms[i] -= weight / 2
-            constant_term += weight / 2
-        else:
-            # Off-diagonal elements (i < j since we're using triu)
-            ising_terms.append([i, j])
-            ising_weights.append(weight / 4)
-
-            # Update linear terms
-            linear_terms[i] -= weight / 4
-            linear_terms[j] -= weight / 4
-
-            # Update constant term
-            constant_term += weight / 4
-
-    # Add the linear terms (Z operators)
-    for i, curr_lin_term in filter(lambda x: x[1] != 0, enumerate(linear_terms)):
-        ising_terms.append([i])
-        ising_weights.append(float(curr_lin_term))
-
-    # Construct the Ising Hamiltonian as a PennyLane operator
-    pauli_string = qml.Identity(0) * 0
-    for term, weight in zip(ising_terms, ising_weights):
-        if len(term) == 1:
-            # Single-qubit term (Z operator)
-            curr_term = qml.Z(term[0]) * weight
-        else:
-            # Two-qubit term (ZZ interaction)
-            curr_term = (
-                reduce(lambda x, y: x @ y, map(lambda x: qml.Z(x), term)) * weight
-            )
-
-        pauli_string += curr_term
-
-    return pauli_string.simplify(), constant_term

qoro_divi-0.2.0b1.dist-info/RECORD

@@ -1,58 +0,0 @@
-divi/__init__.py,sha256=WNAlzdjio0M5la_NTGk4-0AFqItI6HEBExRs6ck9j0Y,203
-divi/_pbar.py,sha256=YDTXMPa8INGzY2zJRloUj5YVINg6TYDqKDY4Yt1qtek,2051
-divi/circuits.py,sha256=tNNCZ61w06aaysOkr_1-USaeIDu63MbF1k1Ry7Y_T6g,4492
-divi/exp/cirq/__init__.py,sha256=TLt2WskG9j-y17Lv0Zgsg-gQgmZGFbp_lwHQYpj2GsM,312
-divi/exp/cirq/_lexer.py,sha256=x5UArrnN_JEyiq7E02ikq0wdmqZ2vEQ3_FADL1LIhQI,3187
-divi/exp/cirq/_parser.py,sha256=z_bSn4m03-sfRlN8eL99Mo4LnjY-zmR-Xt6UrjzstZc,29279
-divi/exp/cirq/_qasm_export.py,sha256=8C5xLYvIIkQTWWAAYo7ZjwtQjvYXNSflbf5UyUx6YUE,1024
-divi/exp/cirq/_qasm_import.py,sha256=HbehrgfLl3iDdRyWr4o26Bek3ZpN-_dvNVSexl5-aVE,969
-divi/exp/cirq/exception.py,sha256=w1w2vSubOGMRmyKBFqXejxfeIAzkPZ6V7gSrDX_ap4A,765
-divi/exp/scipy/_cobyla.py,sha256=cnCf5AsOM8JWIMiujuUbWMNOgmUr3ZET9y04hUyumHs,10937
-divi/exp/scipy/pyprima/LICENCE.txt,sha256=mXN5ssG_U6OR0v0yldznW_PJTtKNZIgu3jDRtRjLDdY,1533
-divi/exp/scipy/pyprima/__init__.py,sha256=WHV_bPKPLakKdP2TdecrbtMrZ7KR3qb1E3m5VkCjLSo,8956
-divi/exp/scipy/pyprima/cobyla/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-divi/exp/scipy/pyprima/cobyla/cobyla.py,sha256=zIHjhLDkzhijMrzypObgYjQQfelUdxp6VOKQd34m_oU,22281
-divi/exp/scipy/pyprima/cobyla/cobylb.py,sha256=DhOW4SnJ8ihLHybC4-1BK2X-5BFZlndEduuagmXQOVY,42091
-divi/exp/scipy/pyprima/cobyla/geometry.py,sha256=YtGsY-lXAKmsuBj_D59H97Z8acDl7fAJGt4QTEigsiU,10789
-divi/exp/scipy/pyprima/cobyla/initialize.py,sha256=QT9rpkO8IjlljA-z5wPxg7KFWtB_ae38Z7Ww0S-fMpU,9964
-divi/exp/scipy/pyprima/cobyla/trustregion.py,sha256=AD_tdF7VCt6xBrduv0KFr7VgyUoGdIIz4mwde_9dk0g,26021
-divi/exp/scipy/pyprima/cobyla/update.py,sha256=VuwqaE3wXxsGopPAkOAATmesLDUH-8WZrw3iRqu3jzs,14353
-divi/exp/scipy/pyprima/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-divi/exp/scipy/pyprima/common/_bounds.py,sha256=0tY542ERqX53I5lreyVUy9XVXfNFvt1bx9peKM70U3U,1683
-divi/exp/scipy/pyprima/common/_linear_constraints.py,sha256=piTatWAMPQo-nwFB14VpRQ6JphBgrBL8OjLysBrTlhI,2160
-divi/exp/scipy/pyprima/common/_nonlinear_constraints.py,sha256=evfY-4FWXKcGae658NXfrlSpCtkHRxCqSG-MyO-WDx4,2180
-divi/exp/scipy/pyprima/common/_project.py,sha256=dnQURl2ztxjGDvoYgMZGnEqUGLUoNUvBaLS12p9-qN0,8541
-divi/exp/scipy/pyprima/common/checkbreak.py,sha256=WrW_dAjZI_3iKvvG3eLTJCxcj5HkIksUBtQQ9BUdB_E,3549
-divi/exp/scipy/pyprima/common/consts.py,sha256=PiGCfDRy9fZjmGJBeCg25gULDfe1cv2HkjS6CQujphg,1313
-divi/exp/scipy/pyprima/common/evaluate.py,sha256=vzjNPdGiAFdD8qpUVp_V1b5f3t2pFyr2N-sMSnTE6OI,3156
-divi/exp/scipy/pyprima/common/history.py,sha256=m0cQ7VOGefWWKTPweqx3dvGZiyzGClTB0BjaKY5mOtQ,1362
-divi/exp/scipy/pyprima/common/infos.py,sha256=MzhS3XciMW5fg4ccW8ubZ3Mkdp2qT6sq56GAkYZikXI,704
-divi/exp/scipy/pyprima/common/linalg.py,sha256=HYoy6vYR2AMUVGSKbA8xj9tjvloMofk_s26N34qiFNk,14516
-divi/exp/scipy/pyprima/common/message.py,sha256=G2_hmqxKvZg0aGCXqw3VmXDxrle8k0Grujzb4iiuPLI,10086
-divi/exp/scipy/pyprima/common/powalg.py,sha256=Azla5UC3oPppDcSTub_1auLS_QXQ_aY1Djm4RT3HkV4,6825
-divi/exp/scipy/pyprima/common/preproc.py,sha256=Ye62rhEilf3ah9aiGc6cSLZg77_qAi3FPK2r4XvPxGk,14929
-divi/exp/scipy/pyprima/common/present.py,sha256=caedmqSB5ggGXNfky0A6v6FAdyaEGrbMEJqNh5Cf6l4,147
-divi/exp/scipy/pyprima/common/ratio.py,sha256=taadehpW0c3ULUggH5frIMpvTom53dsEhvFaXrIKvOI,1833
-divi/exp/scipy/pyprima/common/redrho.py,sha256=J6rJILcOoCeo942LUAXxpUvKLarUGNCGdC-zcmIlVHE,1264
-divi/exp/scipy/pyprima/common/selectx.py,sha256=mXVS2L6AuTmbOhpp1KlXwOBR54ttnbjwagYfnXhezJY,14713
-divi/interfaces.py,sha256=P-8lekQIGwbhHv4ewfMFtKYIjmQHu7nmscwAmxsx72U,594
-divi/parallel_simulator.py,sha256=SjL23zcS-AKyxHG8TeAowDFytpXAshhy64GEkEUnogs,8988
-divi/qasm.py,sha256=agHSRqkIYdfVx1w0zcaIXYe_KDpNz38tni-cu20SMN4,7418
-divi/qem.py,sha256=o6rMPUcxLuCBitBb8-QcxveUiKZVsP3HMamxyVFLi6M,6805
-divi/qlogger.py,sha256=VaCnw-u8VkR7JukjOp39r0V89wO-SSpDj5l50ejnHUg,3801
-divi/qoro_service.py,sha256=Ry7Pt7EZCpnwwLJ_5Fx2WhXHiFmI6z23zUdAaygkx3Y,11386
-divi/qprog/__init__.py,sha256=z8OTd_PdcnEvrcRGvoGsPjj8WYU8HuMHhNyuVMBsNAE,457
-divi/qprog/_graph_partitioning.py,sha256=61bkhz5VTS_pYHSEKCcnvaawD5p0AHk8Fh1EtEjdLkE,22006
-divi/qprog/_mlae.py,sha256=eLEJqYESZG3oI-XsRjgA5aoNs7Er_CspnJ0wJBX0qdU,5769
-divi/qprog/_qaoa.py,sha256=pDMf5RJQ2YHVYiHBpSPu0WkwD4JjF1ARubRD6xbtceA,15445
-divi/qprog/_vqe.py,sha256=JAow9uDTsAOa-n-N5t4CrA04uVuAbGi20s9qB-FSqYU,9427
-divi/qprog/_vqe_sweep.py,sha256=eKvF6sUeqkyRDKuRxd_k-WoQa9ARkzoOLKolLqkpd5s,4873
-divi/qprog/batch.py,sha256=lXID75p4xU88UbukhGIIv6SI1ZrPHsTBzS9u6fPVyhE,7960
-divi/qprog/optimizers.py,sha256=l19zIyt1l0IhUbLofEXlwE9XnsILk7ANlwACi3KKN4w,2034
-divi/qprog/quantum_program.py,sha256=ZMGPFLYZeLiOiU5S7NSlCPAY5vl0R_bv5SRYdEArjSM,16952
-divi/utils.py,sha256=EEyGakoz33AvU0Rq7iijL8AULMg4FGcGBtmOlpSw-tY,3603
-qoro_divi-0.2.0b1.dist-info/LICENSE,sha256=NS4JlQrgNwg1bvB3kE5shE-P4cJgnntgl-kClbOpG_Q,10760
-qoro_divi-0.2.0b1.dist-info/LICENSES/Apache-2.0.txt,sha256=yoILHpvVuguUBpk8UwMnzJbcHUUyst9iGNNuEwUtWVc,10270
-qoro_divi-0.2.0b1.dist-info/METADATA,sha256=8EdyoSoykA9n-MUceXeOP3YjJvXfkZ8lm_MM_iVl940,2073
-qoro_divi-0.2.0b1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-qoro_divi-0.2.0b1.dist-info/RECORD,,