qaoalib 0.2.1__tar.gz → 0.3.1__tar.gz

qaoalib-0.3.1/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

{qaoalib-0.2.1 → qaoalib-0.3.1}/PKG-INFO

@@ -1,35 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qaoalib
-Version: 0.2.1
+Version: 0.3.1
 Summary: A package for QAOA Maxcut calculations
-Home-page: https://github.com/xenoicwyce/qaoalib
-Author: Xinwei Lee
-Author-email: xenoicwyce@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/xenoicwyce/qaoalib
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
 Requires-Dist: qiskit
 Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_algorithms
 Requires-Dist: qiskit_aer
-Requires-Dist: numpy==1.26.0
-Requires-Dist: scipy
 Requires-Dist: pytest
 Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: pydantic
+Dynamic: license-file
 
 # qaoalib
-A package for QAOA Max-cut Calculations.
+Implementations of VQA simulations for combinatorial optimization (mainly with graph and Max-cut).
 
-Packages required:
-- numpy
-- networkx
-- matplotlib
-- qiskit
+v0.2 works towards adapting the circuit simulations with new Qiskit primitives: `Sampler` and `Estimator` (starting from Qiskit 1.0).
 
 # How to install
 You can install from the PyPI:
@@ -38,6 +31,21 @@ pip install --upgrade qaoalib
 ```
 
 # Usage
+Solving Max-cut with VQE:
+```
+import networkx as nx
+from qaoalib.solver import VQE
+from qiskit_optimization.applications import Maxcut
+
+G = nx.random_regular_graph(3, 6) # 3-regular graph wtih 6 nodes
+qp = Maxcut(G).to_quadratic_program()
+ansatz = # some preferred ansatz
+solver = VQE(qp, ansatz)
+result = solver.solve()
+print(result)
+```
+
+# Usage (legacy)
 Calculate Max-cut expectation with `Qmc` or `QmcFastKron` (faster version):
 ```
 import networkx as nx

{qaoalib-0.2.1 → qaoalib-0.3.1}/README.md

@@ -1,11 +1,7 @@
 # qaoalib
-A package for QAOA Max-cut Calculations.
+Implementations of VQA simulations for combinatorial optimization (mainly with graph and Max-cut).
 
-Packages required:
-- numpy
-- networkx
-- matplotlib
-- qiskit
+v0.2 works towards adapting the circuit simulations with new Qiskit primitives: `Sampler` and `Estimator` (starting from Qiskit 1.0).
 
 # How to install
 You can install from the PyPI:
@@ -14,6 +10,21 @@ pip install --upgrade qaoalib
 ```
 
 # Usage
+Solving Max-cut with VQE:
+```
+import networkx as nx
+from qaoalib.solver import VQE
+from qiskit_optimization.applications import Maxcut
+
+G = nx.random_regular_graph(3, 6) # 3-regular graph wtih 6 nodes
+qp = Maxcut(G).to_quadratic_program()
+ansatz = # some preferred ansatz
+solver = VQE(qp, ansatz)
+result = solver.solve()
+print(result)
+```
+
+# Usage (legacy)
 Calculate Max-cut expectation with `Qmc` or `QmcFastKron` (faster version):
 ```
 import networkx as nx

qaoalib-0.3.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools", "wheel", "numpy", "networkx"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qaoalib"
+version = "0.3.1"
+description = "A package for QAOA Maxcut calculations"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "scipy",
+    "qiskit",
+    "qiskit_optimization",
+    "qiskit_algorithms",
+    "qiskit_aer",
+    "pytest",
+    "pytest-cov",
+    "matplotlib",
+    "networkx",
+    "pydantic",
+]
+
+[project.urls]
+Homepage = "https://github.com/xenoicwyce/qaoalib"

qaoalib-0.3.1/qaoalib/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+from .utils import *
+
+__version__ = version("qaoalib")

qaoalib-0.3.1/qaoalib/ansatz.py

@@ -0,0 +1,222 @@
+import numpy as np
+import networkx as nx
+
+from qiskit import QuantumCircuit
+from qiskit.quantum_info import SparsePauliOp
+from qiskit.circuit import ParameterVector
+from qiskit.circuit.library import PauliEvolutionGate
+
+
+def generate_sum_x_pauli_str(length):
+    ret = []
+    for i in range(length):
+        paulis = ['I'] * length
+        paulis[i] = 'X'
+        ret.append(''.join(paulis))
+
+    return ret
+
+def qaoa(problem_ham: SparsePauliOp, reps: int = 1) -> QuantumCircuit:
+    r"""
+    Input:
+    - problem_ham: Problem Hamiltonian to construct the QAOA circuit.
+    Standard procedure would be:
+    ```
+        hamiltonian, offset = qubo.to_ising()
+        qc = qaoa_circuit_from_qubo(hamiltonian)
+    ```
+
+    Returns:
+    - qc: A QuantumCircuit object representing the QAOA circuit e^{-i\beta H_M} e^{-i\gamma H_C}.
+    """
+    num_qubits = problem_ham.num_qubits
+
+    gamma = ParameterVector(name=r'$\gamma$', length=reps)
+    beta = ParameterVector(name=r'$\beta$', length=reps)
+
+    mixer_ham = SparsePauliOp(generate_sum_x_pauli_str(num_qubits))
+
+    qc = QuantumCircuit(num_qubits)
+    qc.h(range(num_qubits))
+
+    for p in range(reps):
+        exp_gamma = PauliEvolutionGate(problem_ham, time=gamma[p])
+        exp_beta = PauliEvolutionGate(mixer_ham, time=beta[p])
+        qc.append(exp_gamma, qargs=range(num_qubits))
+        qc.append(exp_beta, qargs=range(num_qubits))
+
+    return qc
+
+def multi_angle_qaoa(problem_ham: SparsePauliOp, reps: int = 1) -> QuantumCircuit:
+    r"""
+    Input:
+    - problem_ham: Problem Hamiltonian to construct the QAOA circuit.
+    Standard procedure would be:
+    ```
+        hamiltonian, offset = qubo.to_ising()
+        qc = qaoa_circuit_from_qubo(hamiltonian)
+    ```
+
+    Returns:
+    - qc: A QuantumCircuit object representing the QAOA circuit e^{-i\beta H_M} e^{-i\gamma H_C}.
+    """
+    num_qubits = problem_ham.num_qubits
+
+    gamma = ParameterVector(name=r'$\gamma$', length=len(problem_ham) * reps)
+    beta = ParameterVector(name=r'$\beta$', length=num_qubits * reps)
+
+    qc = QuantumCircuit(num_qubits)
+    qc.h(range(num_qubits))
+
+    for p in range(reps):
+        for idx, term in enumerate(problem_ham):
+            exp_gamma = PauliEvolutionGate(term, time=gamma[p * num_qubits + idx])
+            qc.append(exp_gamma, qargs=range(num_qubits))
+        for i in range(num_qubits):
+            qc.rx(beta[p * num_qubits + i], i)
+
+    return qc
+
+def two_local(num_qubits: int, reps: int = 1, entanglement: str = 'linear') -> QuantumCircuit:
+    # only linear or circular entanglement
+    if entanglement not in ['linear', 'circular']:
+        raise ValueError(f'Entanglment must be linear or circular, got {entanglement} instead.')
+
+    qc = QuantumCircuit(num_qubits)
+    params = ParameterVector('θ', num_qubits * (reps + 1))
+
+    for i in range(num_qubits):
+        qc.ry(params[i], i)
+
+    for r in range(1, reps + 1):
+        for i in range(num_qubits - 1):
+            qc.cz(i, i+1)
+        if entanglement == 'circular':
+            qc.cz(num_qubits - 1, 0)
+        for i in range(num_qubits):
+            qc.ry(params[r * num_qubits + i], i)
+
+    return qc
+
+def _det_warm_start_angle(ci: float, epsilon: float):
+    if ci <= epsilon:
+        return 2 * np.arcsin(np.sqrt(epsilon))
+    elif ci >= 1 - epsilon:
+        return 2 * np.arcsin(np.sqrt(1 - epsilon))
+    else:
+        return 2 * np.arcsin(np.sqrt(ci))
+
+def warm_start_qaoa(
+    problem_ham: SparsePauliOp,
+    relaxed_qp_solution: list[float],
+    depth: int = 1,
+    regularization: float = 0.01,
+    flip_solution_indices: bool = False,
+) -> QuantumCircuit:
+    r"""
+    Input:
+    - problem_ham: Problem Hamiltonian to construct the QAOA circuit.
+    - relaxed_qp_solution: The solution for the relaxed quadratic program.
+
+    Returns:
+    - qc: A QuantumCircuit object representing the QAOA circuit e^{-i\beta H_M} e^{-i\gamma H_C}.
+    """
+    num_qubits = problem_ham.num_qubits
+    if num_qubits != len(relaxed_qp_solution):
+        raise ValueError(f'The number of qubits and the length of the solution must be equal.')
+
+    # try setting this to True if doesn't work, as Qiskit works with reversed indices.
+    if flip_solution_indices:
+        relaxed_qp_solution = relaxed_qp_solution[::-1]
+
+    gamma = ParameterVector(name=r'$\gamma$', length=depth)
+    beta = ParameterVector(name=r'$\beta$', length=depth)
+
+    # calculate the thetas for warm start
+    reg_warm_start_angle = lambda ci: _det_warm_start_angle(ci, regularization)
+    theta = list(map(reg_warm_start_angle, relaxed_qp_solution))
+
+    qc = QuantumCircuit(num_qubits)
+
+    # initial layer
+    for i in range(num_qubits):
+        qc.ry(theta[i], i)
+
+    for p in range(depth):
+        # phase separation
+        exp_gamma = PauliEvolutionGate(problem_ham, time=gamma[p])
+        qc.append(exp_gamma, qargs=range(num_qubits))
+
+        # mixer
+        for i in range(num_qubits):
+            qc.ry(-theta[i], i)
+            qc.rz(beta[p], i)
+            qc.ry(theta[i], i)
+
+    return qc
+
+def rzy_gate(theta: float) -> QuantumCircuit:
+    """
+    Add RZY gate to QuantumCircuit object, with Z acting on q1 and Y acting on q0 (following qiskit convention).
+    RZY(theta) = exp(-i * theta * kron(Y, Z)).
+    """
+    qc = QuantumCircuit(2, name='Rzy')
+    qc.rx(np.pi/2, 1)
+    qc.cx(0, 1)
+    qc.rz(theta, 1)
+    qc.cx(0, 1)
+    qc.rx(-np.pi/2, 1)
+    return qc
+
+def drop_weights(G: nx.Graph) -> nx.Graph:
+    G_unweighted = G.copy()
+    for _, _, data in G_unweighted.edges(data=True):
+        data['weights'] = 1.0
+
+    return G_unweighted
+
+def ihva_from_graph(G: nx.Graph, reps: int = 1, weighted_gates: bool = False) -> QuantumCircuit:
+    num_nodes = len(G.nodes)
+    num_edges = len(G.edges)
+    edge_buffer = []
+    G_unweighted = drop_weights(G)
+    while G_unweighted.edges:
+        tree = nx.maximum_spanning_tree(G_unweighted)
+        edge_buffer += list(tree.edges)
+        G_unweighted.remove_edges_from(tree.edges)
+
+    qc = QuantumCircuit(num_nodes)
+    qc.h(range(num_nodes))
+    params = ParameterVector('θ', num_edges * reps)
+    for r in range(reps):
+        for idx, edge in enumerate(edge_buffer):
+            if r % 2 == 0:
+                i, j = edge
+            else:
+                j, i = edge
+            gate_weight = G[i][j]['weight'] if weighted_gates else 1.0
+            qc.append(rzy_gate(gate_weight * params [r * num_edges + idx] ), qargs=[i, j])
+
+    return qc
+
+def linear_ansatz(num_qubits: int, reps: int = 1) -> QuantumCircuit:
+    qc = QuantumCircuit(num_qubits)
+    params = ParameterVector('θ', num_qubits * reps)
+
+    # initial state
+    qc.h(range(num_qubits - 1)) # leave the last qubit with state |0>
+
+    for r in range(reps):
+        for i in range(num_qubits):
+            qc.ry(params[r * num_qubits + i], i)
+
+    return qc
+
+def pure_rx_ansatz(num_qubits: int) -> QuantumCircuit:
+    params = ParameterVector('θ', num_qubits)
+    qc = QuantumCircuit(num_qubits)
+
+    for i in range(num_qubits):
+        qc.rx(params[i], i)
+
+    return qc

qaoalib-0.3.1/qaoalib/legacy/qaoa/__init__.py

@@ -0,0 +1,3 @@
+from .qmc import Qmc, QmcFastKron
+from .layerwise import Layerwise
+from .utils import *

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/__init__.py

@@ -0,0 +1,3 @@
+from .direct_numpy import DirectNumpy
+from .hybrid_fast import HybridFast
+from .hadamard_test import HadamardTest

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/base.py

@@ -0,0 +1,90 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+DEFAULT_RTOL = 1e-5
+DEFAULT_ATOL = 1e-8
+
+class QmcLandscapeBase:
+    """
+    This is a base class.
+    It should be only used for inhertiance.
+    """
+    def __init__(self, G, prev_params=None):
+        if prev_params is not None:
+            if len(prev_params) % 2:
+                raise ValueError(f'Constructor failed. prev_params must have even length, got {len(prev_params)}.')
+        self.graph = G
+        self.num_qubits = len(G.nodes)
+        self.edge_list = list(G.edges)
+        self.prev_params = prev_params
+        self.grange = None
+        self.brange = None
+        self.exp_arr = None
+        self.depth = 1 if prev_params is None else len(prev_params)//2+1
+        self.npts = None
+
+    def _meshgrid(self):
+        gmin, gmax = min(self.grange), max(self.grange)
+        bmin, bmax = min(self.brange), max(self.brange)
+        gspace = np.linspace(gmin, gmax, self.npts)
+        bspace = np.linspace(bmin, bmax, self.npts)
+        return np.meshgrid(gspace, bspace)
+
+    def get_max(self, rtol=DEFAULT_RTOL, atol=DEFAULT_ATOL):
+        if self.exp_arr is None:
+            raise ValueError('Grid not found. Run create_grid() method first.')
+
+        gmesh, bmesh = self._meshgrid()
+        exp_max = np.max(self.exp_arr)
+        whr = np.where(np.isclose(self.exp_arr, exp_max, rtol=rtol, atol=atol))
+        indices = zip(whr[0], whr[1])
+        angle_list = [(gmesh[idx], bmesh[idx]) for idx in indices]
+        return (exp_max, angle_list)
+
+    def get_min(self, rtol=DEFAULT_RTOL, atol=DEFAULT_ATOL):
+        if self.exp_arr is None:
+            raise ValueError('Grid not found. Run create_grid() method first.')
+
+        gmesh, bmesh = self._meshgrid()
+        exp_min = np.min(self.exp_arr)
+        whr = np.where(np.isclose(self.exp_arr, exp_min, rtol=rtol, atol=atol))
+        indices = zip(whr[0], whr[1])
+        angle_list = [(gmesh[idx], bmesh[idx]) for idx in indices]
+        return (exp_min, angle_list)
+
+    def show_landscape(self, **plot_options):
+        defaults = {
+            'figsize': (16, 9),
+        }
+        defaults.update(plot_options)
+        figsize = defaults['figsize']
+
+        fig, ax = plt.subplots(subplot_kw={'projection': '3d'}, figsize=figsize)
+
+        if self.exp_arr is None:
+            raise ValueError('Grid not found. Run create_grid() method first.')
+
+        gmesh, bmesh = self._meshgrid()
+        surf = ax.plot_surface(gmesh, bmesh, self.exp_arr, cmap='coolwarm')
+        ax.set_xlabel('gamma')
+        ax.set_ylabel('beta')
+        ax.set_zlabel('expectation')
+        fig.colorbar(surf, shrink=.5)
+
+        plt.show()
+
+    def show_heatmap(self, legacy=False):
+        if self.exp_arr is None:
+            raise ValueError('Grid not found. Run create_grid() method first.')
+
+        if legacy:
+            plt.xlabel('norm(gamma_p)')
+            plt.ylabel('norm(beta_p)')
+            plt.imshow(self.exp_arr, cmap='coolwarm', origin='lower', extent=[0, 1, 0, 1])
+        else:
+            fig, ax = plt.subplots()
+            gmesh, bmesh = self._meshgrid()
+            ax.pcolormesh(gmesh, bmesh, self.exp_arr, cmap='coolwarm')
+            ax.set_xlabel('gamma')
+            ax.set_ylabel('beta')
+            plt.show()

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/direct_numpy.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+from .base import QmcLandscapeBase
+from ..utils import I, Z, plus
+from ..utils import rx, make_params_vec
+
+
+class DirectNumpy(QmcLandscapeBase):
+    def __init__(self, G, prev_params=None):
+        super().__init__(G, prev_params)
+        self.plusxn = self._mplus()
+        self.hamiltonian = self._hmt()
+
+    def _mplus(self):
+        ans = plus
+        for q in range(1, self.num_qubits):
+            ans = np.kron(ans, plus)
+        return ans
+
+    def _hmt(self):
+        N = 2 ** self.num_qubits
+        ans = np.zeros((N, N))
+        for u, v in self.edge_list:
+            ans += np.eye(N) - self.tensor(Z, [u, v])
+        return ans/2
+
+    def tensor(self, u3, qubits):
+        if 0 in qubits:
+            ans = u3
+        else:
+            ans = I
+
+        for idx in range(1, self.num_qubits):
+            if idx in qubits:
+                ans = np.kron(ans, u3)
+            else:
+                ans = np.kron(ans, I)
+        return ans
+
+    def ucost(self, q1, q2, gamma):
+        return np.diag(np.exp(1j*gamma/2*np.diag(np.eye(2**self.num_qubits)-self.tensor(Z, [q1, q2]))))
+
+    def umixer_all(self, beta):
+        return self.tensor(rx(2*beta), list(range(self.num_qubits)))
+
+    def ansatz(self, gamma_vec, beta_vec):
+        ans = self.plusxn
+        for gamma, beta in zip(gamma_vec, beta_vec):
+            for u, v in self.edge_list:
+                ans = self.ucost(u, v, gamma) @ ans
+            ans = self.umixer_all(beta) @ ans
+        return ans
+
+    def expectation(self, params):
+        if self.plusxn is None or self.hamiltonian is None:
+            self.plusxn = self._mplus()
+            self.hamiltonian = self._hmt()
+        depth = len(params)//2
+        gamma_vec = params[:depth]
+        beta_vec = params[depth:]
+        ansatz = self.ansatz(gamma_vec, beta_vec)
+        ans = ansatz.conj().T @ self.hamiltonian @ ansatz
+        ans = ans[0][0]
+        if np.isclose(ans.real, np.abs(ans)):
+            return ans.real
+        else:
+            return ans
+
+    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
+        self.grange = (gmin, gmax)
+        self.brange = (bmin, bmax)
+        self.npts = npts
+        gmesh, bmesh = self._meshgrid()
+        gg = gmesh.reshape((-1,))
+        bb = bmesh.reshape((-1,))
+
+        exp_arr = np.array(list(map(self.expectation, make_params_vec(gg, bb, self.prev_params))))\
+                        .reshape((npts, npts))
+        self.exp_arr = exp_arr

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/hadamard_test.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+from .base import QmcLandscapeBase
+from ..utils import interp, ht_expectation
+from ..qis import hadamard_test_circuits, run_many_circuits
+
+
+class HadamardTest(QmcLandscapeBase):
+    def __init__(self, G, prev_params=None):
+        super().__init__(G, prev_params)
+
+    def get_circuits(self, params):
+        return hadamard_test_circuits(self.graph, params)
+
+    def expectation_grid(self, gspace, bspace, npts, prev_params=None):
+        qc_list = []
+        for beta in bspace:
+            for gamma in gspace:
+                if prev_params is None:
+                    qc_list += self.get_circuits([gamma, beta])
+                else:
+                    qc_list += self.get_circuits(interp(prev_params, [gamma, beta]))
+
+        sv_list = run_many_circuits(qc_list)
+        exp_arr = np.array(list(map(ht_expectation, sv_list)))\
+                    .reshape((npts*npts, len(self.edge_list)))
+        exp_arr = np.sum(exp_arr, axis=1).reshape((npts, npts))
+        return exp_arr
+
+    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
+        self.grange = (gmin, gmax)
+        self.brange = (bmin, bmax)
+        self.npts = npts
+        gmesh, bmesh = self._meshgrid()
+
+        gspace = np.linspace(gmin, gmax, npts)
+        bspace = np.linspace(bmin, bmax, npts)
+        exp_arr = self.expectation_grid(gspace, bspace, npts, self.prev_params)
+        self.exp_arr = exp_arr

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/hybrid_fast.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+from .base import QmcLandscapeBase
+from ..utils import I, Z, interp
+from ..qis import qaoa_circuit, run_many_circuits
+from ...math import fast_kron
+
+
+class HybridFast(QmcLandscapeBase):
+    def __init__(self, G, prev_params=None):
+        super().__init__(G, prev_params)
+
+    def get_circuit(self, params):
+        return qaoa_circuit(self.graph, params)
+
+    def _fast_kron_exp(self, sv):
+        sum_ = 0
+        for edge in self.edge_list:
+            kron_list = [Z if i in edge else I for i in range(self.num_qubits)]
+            kron_list.reverse()
+            sum_ += (sv.conj().T @ fast_kron(kron_list, sv)).item().real
+        # return a single expectation value
+        return (len(self.edge_list) - sum_)/2
+
+    def expectation_grid(self, gspace, bspace, npts, prev_params=None):
+        if prev_params is None:
+            qc_list = [self.get_circuit([gamma, beta]) for beta in bspace for gamma in gspace]
+        else:
+            qc_list = [self.get_circuit(interp(prev_params, [gamma, beta]))
+                        for beta in bspace for gamma in gspace]
+        ansatz_list = run_many_circuits(qc_list)
+        exp_arr = np.array(list(map(self._fast_kron_exp, ansatz_list))).reshape((npts, npts))
+        return exp_arr
+
+    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
+        self.grange = (gmin, gmax)
+        self.brange = (bmin, bmax)
+        self.npts = npts
+        gmesh, bmesh = self._meshgrid()
+
+        gspace = np.linspace(gmin, gmax, npts)
+        bspace = np.linspace(bmin, bmax, npts)
+        exp_arr = self.expectation_grid(gspace, bspace, npts, self.prev_params)
+        self.exp_arr = exp_arr