qaoalib 0.2.0__tar.gz → 0.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.2.0
+Version: 0.2.1
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee

qaoalib-0.2.1/qaoalib/solver/__init__.py

@@ -0,0 +1 @@
+from .vqe import VQE

qaoalib-0.2.1/qaoalib/version.py

@@ -0,0 +1 @@
+__version__ = '0.2.1'

{qaoalib-0.2.0 → qaoalib-0.2.1}/qaoalib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.2.0
+Version: 0.2.1
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee

{qaoalib-0.2.0 → qaoalib-0.2.1}/qaoalib.egg-info/SOURCES.txt

@@ -13,17 +13,6 @@ qaoalib.egg-info/requires.txt
 qaoalib.egg-info/top_level.txt
 qaoalib/models/__init__.py
 qaoalib/models/result.py
-qaoalib/qaoa/__init__.py
-qaoalib/qaoa/layerwise.py
-qaoalib/qaoa/qis.py
-qaoalib/qaoa/qmc.py
-qaoalib/qaoa/strategy.py
-qaoalib/qaoa/utils.py
-qaoalib/qaoa/landscape/__init__.py
-qaoalib/qaoa/landscape/base.py
-qaoalib/qaoa/landscape/direct_numpy.py
-qaoalib/qaoa/landscape/hadamard_test.py
-qaoalib/qaoa/landscape/hybrid_fast.py
 qaoalib/solver/__init__.py
 qaoalib/solver/vqe.py
 test/test.py

qaoalib-0.2.1/test/test.py

@@ -0,0 +1,5 @@
+from qaoalib import *
+from qaoalib.models import *
+from qaoalib.solver import *
+# from qaoalib.qaoa import *
+# from qaoalib.qaoa.landscape import *

qaoalib-0.2.0/qaoalib/qaoa/__init__.py

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

qaoalib-0.2.0/qaoalib/qaoa/landscape/__init__.py

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

qaoalib-0.2.0/qaoalib/qaoa/landscape/base.py

@@ -1,90 +0,0 @@
-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.2.0/qaoalib/qaoa/landscape/direct_numpy.py

@@ -1,79 +0,0 @@
-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.2.0/qaoalib/qaoa/landscape/hadamard_test.py

@@ -1,39 +0,0 @@
-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.2.0/qaoalib/qaoa/landscape/hybrid_fast.py

@@ -1,44 +0,0 @@
-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

qaoalib-0.2.0/qaoalib/qaoa/layerwise.py

@@ -1,184 +0,0 @@
-import pickle
-import numpy as np
-import matplotlib.pyplot as plt
-
-from matplotlib import cm
-
-from .utils import I, Z
-from .utils import rx
-
-class Layerwise:
-    def __init__(self, G):
-        self.graph = G
-        self.num_qubits = len(G.nodes)
-        self.edge_list = list(G.edges)
-        self.hamiltonian = self.get_maxcut_hmt()
-        self.maxcut = np.max(self.hamiltonian)
-        self.best_ansatz = self.plusxn()
-        self.best_params = None
-        self.exp_arr = None
-        self.npts = None
-        self.gmesh = None
-        self.bmesh = None
-        self.max_exps = None
-        self.depth = 0
-
-    def tensor_prod(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 plusxn(self):
-        N = 2 ** self.num_qubits
-        return np.ones((N, 1))/np.sqrt(N)
-
-    def get_maxcut_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_prod(Z, [u, v])
-        return ans/2
-
-    def ehz(self, gamma):
-        eigs = np.diag(self.hamiltonian)
-        return np.diag(np.exp(1j*gamma/2*eigs))
-
-    def ehx(self, beta):
-        return self.tensor_prod(rx(2*beta), list(range(self.num_qubits)))
-
-    def ansatz(self, gamma, beta):
-        ans = self.best_ansatz[:, -1][:, np.newaxis]
-        return self.ehx(beta) @ self.ehz(gamma) @ ans
-
-    def expectation(self, gamma, beta):
-        right = self.ansatz(gamma, beta)
-        left = right.conj().T
-        return (left @ self.hamiltonian @ right).real
-
-    def create_grid(self, npts, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
-        grange = np.linspace(gmin, gmax, npts)
-        brange = np.linspace(bmin, bmax, npts)
-        gmesh, bmesh = np.meshgrid(grange, brange)
-        gg = gmesh.reshape((-1,))
-        bb = bmesh.reshape((-1,))
-
-        exp_arr = np.array(list(map(self.expectation, gg, bb)))\
-                        .reshape((npts, npts))
-
-        self.npts = npts
-        self.gmesh = gmesh
-        self.bmesh = bmesh
-        if self.exp_arr is None:
-            self.exp_arr = exp_arr[:, :, np.newaxis]
-        else:
-            self.exp_arr = np.dstack((self.exp_arr, exp_arr))
-
-    # def get_max(self, p):
-    #     if self.exp_arr is None:
-    #         raise ValueError('Grid not found. Run create_grid() method first.')
-
-    #     exp_arr = self.exp_arr[:, :, p-1]
-    #     max_exp = np.max(exp_arr)
-    #     whr = np.where(np.isclose(exp_arr, max_exp))
-    #     indices = zip(whr[0], whr[1])
-    #     angle_list = [(self.gmesh[idx], self.bmesh[idx]) for idx in indices]
-    #     return (max_exp, angle_list)
-
-    def find_args(self, p, value):
-        """ Find the nearest args given a value. """
-
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        dist_arr = np.abs(self.exp_arr[:, :, p-1] - value)
-        nearest = np.min(dist_arr)
-        whr = np.where(np.isclose(dist_arr, nearest))
-        indices = zip(whr[0], whr[1])
-        angle_list = [(self.gmesh[idx], self.bmesh[idx]) for idx in indices]
-        return angle_list
-
-    def run(self, p_end, npts=50, cutoff=1.0):
-        for i in range(1, p_end + 1):
-            print(f'Creating grid for p={i}')
-            self.create_grid(npts)
-            max_exp = np.max(self.exp_arr[:, :, i-1])
-            best_params = self.find_args(i, cutoff * max_exp)[0] # take only one pair of angles
-
-            if self.max_exps is None:
-                self.max_exps = max_exp
-            else:
-                self.max_exps = np.hstack((self.max_exps, max_exp))
-
-            if self.best_params is None:
-                self.best_params = np.array(best_params)
-            else:
-                self.best_params = np.column_stack((self.best_params, best_params))
-
-            best_ansatz = self.ansatz(best_params[0], best_params[1])
-            self.best_ansatz = np.hstack((self.best_ansatz, best_ansatz))
-
-            self.depth += 1
-
-    def show_landscape(self, p, **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.gmesh is None or self.bmesh is None or self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        exp_arr = self.exp_arr[:, :, p-1]
-        surf = ax.plot_surface(self.gmesh, self.bmesh, exp_arr, cmap=cm.coolwarm)
-        ax.set_xlabel('gamma')
-        ax.set_ylabel('beta')
-        ax.set_zlabel('expectation')
-        fig.colorbar(surf, shrink=.5)
-
-        plt.show()
-
-    def show_heatmap(self, p):
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        exp_arr = self.exp_arr[:, :, p-1]
-        plt.xlabel('gamma_p/2pi')
-        plt.ylabel('beta_p/pi')
-        plt.imshow(exp_arr, cmap=cm.coolwarm, origin='lower', extent=[0, 1, 0, 1])
-
-    def plot_alpha(self, alpha=True):
-        p_range = range(1, self.depth + 1)
-
-        fig, ax = plt.subplots()
-        ax.set_xlabel('Circuit depth, $p$')
-        ax.grid(True)
-        ax.set_xticks(p_range)
-        if alpha:
-            ax.set_ylabel('Approx. ratio')
-            ax.plot(p_range, self.max_exps/self.maxcut, marker='.')
-        else:
-            ax.set_ylabel('Expectation')
-            ax.plot(p_range, self.max_exps, marker='.')
-
-        plt.show()
-
-    def status(self):
-        if not self.depth:
-            print('Paramters fixing not yet executed.')
-        else:
-            print(f'Parameters fixing executed up to p={self.depth}.')
-
-    def dump(self, path):
-        with open(path, 'wb') as f:
-            pickle.dump(self, f)

qaoalib-0.2.0/qaoalib/qaoa/qis.py

@@ -1,59 +0,0 @@
-from qiskit import QuantumRegister, QuantumCircuit
-from qiskit import Aer, execute
-
-
-sv_backend = Aer.get_backend('statevector_simulator')
-aer_backend = Aer.get_backend('aer_simulator')
-
-def qaoa_circuit(G, params):
-    """
-    QAOA circuit for Max-cut \sum(I-ZZ). No longer follow qiskit QAOA circuit.
-    If want to reproduce the circuit used in qiskit \sum(-ZZ), substitute
-    gamma as -gamma will do.
-    """
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-
-    q = QuantumRegister(len(G.nodes))
-    qc = QuantumCircuit(q)
-
-    qc.h(q)
-    for p in range(depth):
-        for u, v, d in G.edges(data=True):
-            weight = d.get('weight', 1)
-            qc.cx(u, v)
-            qc.rz(-gamma[p]*weight, v)
-            qc.cx(u, v)
-        qc.rx(2*beta[p], q)
-    return qc
-
-def hadamard_test_circuits(G, params):
-    """
-    Return a list of QuantumCircuit's for hadamard tests.
-    """
-    qc_list = []
-    ansatz_circ = qaoa_circuit(G, params)
-
-    for u, v in G.edges:
-        q = QuantumRegister(1)
-        ansatz = QuantumRegister(ansatz_circ.num_qubits)
-        qc = QuantumCircuit(q, ansatz)
-
-        qc.h(q)
-        qc.append(ansatz_circ, ansatz)
-        qc.cz(q, ansatz[u])
-        qc.cz(q, ansatz[v])
-        qc.h(q)
-
-        # bit reversal is required to calculate probabilities
-        qc = qc.reverse_bits()
-        qc_list.append(qc)
-
-    return qc_list
-
-def run_many_circuits(qc_list):
-    job = execute(qc_list, sv_backend)
-    result = job.result()
-    # return a list of np.ndarray of statevectors
-    return [result.get_statevector(idx) for idx in range(len(qc_list))]

qaoalib-0.2.0/qaoalib/qaoa/qmc.py

@@ -1,51 +0,0 @@
-import numpy as np
-from qiskit import Aer, execute
-
-from .qis import qaoa_circuit, sv_backend
-from .utils import expectation, I, Z
-from ..math import fast_kron
-
-
-class Qmc:
-    def __init__(self, G, params):
-        self.graph = G
-        self.params = params
-        self.circuit = qaoa_circuit(self.graph, self.params)
-        self.result = None
-        self.expectation = None
-
-    def run(self, backend_name='qasm_simulator', **execute_kw):
-        qc = self.circuit
-        if backend_name == 'qasm_simulator':
-            qc.measure_all()
-
-        backend = Aer.get_backend(backend_name)
-        job = execute(self.circuit, backend, **execute_kw)
-        result = job.result()
-        if backend_name == 'qasm_simulator':
-            self.result = result.get_counts()
-        elif backend_name == 'statevector_simulator':
-            self.result = np.asarray(result.get_statevector())
-
-        self.expectation = expectation(self.graph, self.result)
-
-
-class QmcFastKron(Qmc):
-    def __init__(self, G, params):
-        super().__init__(G, params)
-
-    def _fast_kron_exp(self, sv):
-        sum_ = 0
-        for u, v, d in self.graph.edges(data=True):
-            edge = (u,v)
-            kron_list = [Z if i in edge else I for i in range(len(self.graph.nodes))]
-            kron_list.reverse()
-            weight = d.get('weight', 1)
-            sum_ += weight * (1 - (sv.conj().T @ fast_kron(kron_list, sv)).item().real)
-        # return a single expectation value
-        return sum_/2
-
-    def run(self, **execute_kw):
-        job = execute(self.circuit, sv_backend, **execute_kw) # currently only support sv type
-        self.result = job.result().get_statevector()
-        self.expectation = self._fast_kron_exp(self.result)

qaoalib-0.2.0/qaoalib/qaoa/strategy.py

@@ -1,70 +0,0 @@
-import numpy as np
-from typing import TYPE_CHECKING, Optional, Union, Sequence
-from typing_extensions import TypeAlias
-# from .params import Params
-
-if TYPE_CHECKING:
-    import numpy.typing as npt
-
-Params: TypeAlias = Union[Sequence[float], "npt.NDArray[np.float_]"]
-
-
-def interp():
-    ...
-
-def bilinear(
-    prev_params: Params,
-    pp_params: Params,
-    gamma_bound: Optional[tuple[float, float]] = None,
-    beta_bound: Optional[tuple[float, float]] = None,
-) -> "npt.NDArray[np.float_]":
-    if gamma_bound is None:
-        gamma_bound = (0, np.pi)
-    if beta_bound is None:
-        beta_bound = (0, np.pi/2)
-
-    prev_params = np.asarray(prev_params)
-    pp_params = np.asarray(pp_params) # prev_prev_params (p-2)
-
-    # split into gamma and beta
-    prev_gb = np.split(prev_params, 2)
-    pp_gb = np.split(pp_params, 2)
-
-    new_gb = []
-    for i in range(2):
-        delta2 = prev_gb[i][-2] - pp_gb[i][-1]
-        pp_gb[i] = np.hstack([pp_gb[i], prev_gb[i][-1] - delta2])
-
-        diff = prev_gb[i] - pp_gb[i]
-        new_x = prev_gb[i] + diff
-
-        delta3 = new_x[-1] - new_x[-2]
-        new_x = np.hstack([new_x, new_x[-1] + delta3])
-
-        if i == 0:
-            new_x = np.clip(new_x, *gamma_bound)
-        else:
-            new_x = np.clip(new_x, *beta_bound)
-
-        new_gb.append(new_x)
-
-    return np.hstack(new_gb)
-
-
-def params_fixing(
-    prev_params: Params,
-    gamma_bound: Optional[tuple[float, float]] = None,
-    beta_bound: Optional[tuple[float, float]] = None,
-) -> "npt.NDArray[np.float_]":
-    if gamma_bound is None:
-        gamma_bound = (0, np.pi)
-    if beta_bound is None:
-        beta_bound = (0, np.pi/2)
-
-    prev_params = np.asarray(prev_params)
-    gamma, beta = np.split(prev_params)
-
-    gamma = np.hstack([gamma, np.random.uniform(*gamma_bound)])
-    beta = np.hstack([beta, np.random.uniform(*beta_bound)])
-
-    return np.hstack([gamma, beta])

qaoalib-0.2.0/qaoalib/qaoa/utils.py

@@ -1,135 +0,0 @@
-import numpy as np
-
-
-# globals
-I = np.eye(2)
-X = np.array([
-    [0, 1],
-    [1, 0],
-])
-Z = np.array([
-    [1, 0],
-    [0, -1],
-])
-cnot = np.array([
-    [1, 0, 0, 0],
-    [0, 1, 0, 0],
-    [0, 0, 0, 1],
-    [0, 0, 1, 0],
-])
-plus = np.ones((2, 1)) * 1/np.sqrt(2)
-
-# functions
-def split_gb(params):
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-    return gamma, beta
-
-def random_qaoa_params(p, grange=None, brange=None):
-    """Generate random QAOA parameters."""
-    if grange is None:
-        grange = (0, 2*np.pi)
-    if brange is None:
-        brange = (0, np.pi)
-
-    rng = np.random.default_rng()
-    # rng.uniform(low=0., high=1., size=None)
-    grand = rng.uniform(grange[0], grange[1], p)
-    brand = rng.uniform(brange[0], brange[1], p)
-    return np.hstack([grand, brand])
-
-def interp(old_params, new_params):
-    gamma, beta = split_gb(old_params)
-    new_gamma, new_beta = split_gb(new_params)
-    return np.hstack((gamma, new_gamma, beta, new_beta)).tolist()
-
-def interp_rand(params, grange=None, brange=None):
-    """
-    Adds a new random angle to the params array, and return
-    the params required by (p+1).
-    """
-    if grange is None:
-        grange = (0, 2*np.pi)
-    if brange is None:
-        brange = (0, np.pi)
-
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-
-    rng = np.random.default_rng()
-    grand = rng.uniform(grange[0], grange[1], 1)
-    brand = rng.uniform(brange[0], brange[1], 1)
-    return np.hstack([gamma, grand, beta, brand])
-
-def rx(theta):
-    return np.array([
-        [np.cos(theta/2), -1j*np.sin(theta/2)],
-        [-1j*np.sin(theta/2), np.cos(theta/2)],
-    ])
-
-def rz(theta):
-    return np.array([
-        [np.exp(-1j*theta/2), 0],
-        [0, np.exp(1j*theta/2)],
-    ])
-
-def make_params_vec(gamma1d, beta1d, prev_params=None):
-    if prev_params is None:
-        return zip(gamma1d, beta1d)
-
-    npts = gamma1d.shape[0]
-    depth = len(prev_params)//2
-    prev_gamma = prev_params[:depth]
-    prev_beta = prev_params[depth:]
-
-    gamma_list = (np.zeros((npts, depth)) + np.array(prev_gamma)).T.tolist()
-    beta_list = (np.zeros((npts, depth)) + np.array(prev_beta)).T.tolist()
-
-    return zip(*gamma_list, gamma1d, *beta_list, beta1d)
-
-def ht_expectation(sv):
-    zero, one = np.split(sv, 2)
-    zero_prob = np.sum(np.abs(zero)**2)
-    one_prob = np.sum(np.abs(one)**2)
-    return zero_prob - one_prob
-
-def _cut_value(G, eigenstate):
-    eigenstate = eigenstate[::-1]
-    cut = 0
-    for u, v, d in G.edges(data=True):
-        if eigenstate[u] != eigenstate[v]:
-            weight = d.get('weight', 1)
-            cut += weight
-    return cut
-
-def _sv2dict(sv):
-    num_qubits = np.log2(sv.shape[0])
-    if num_qubits % 1:
-        raise ValueError('Input vector is not a valid statevector.')
-    num_qubits = int(num_qubits)
-
-    sv_dict = {
-        f'{idx:0{num_qubits}b}': sv[idx]
-        for idx in range(2**num_qubits)
-    }
-    return sv_dict
-
-def expectation(G, counts_or_sv):
-    sum_ = 0
-    if isinstance(counts_or_sv, dict):
-        counts = counts_or_sv
-        total = sum(counts.values())
-        for eigs, count in counts.items():
-            sum_ += _cut_value(G, eigs) * count / total
-        return sum_
-
-    elif isinstance(counts_or_sv, np.ndarray):
-        sv = _sv2dict(counts_or_sv)
-        for eigs, count in sv.items():
-            sum_ += _cut_value(G, eigs) * (np.abs(sv[eigs])**2)
-        return sum_
-
-    else:
-        raise TypeError(f'Unrecognized type {type(counts_or_sv)}.')

qaoalib-0.2.0/qaoalib/solver/__init__.py

@@ -1 +0,0 @@
-from vqe import VQE

qaoalib-0.2.0/qaoalib/version.py

@@ -1 +0,0 @@
-__version__ = '0.2.0'

qaoalib-0.2.0/test/test.py

@@ -1,3 +0,0 @@
-from qaoalib import *
-from qaoalib.qaoa import *
-from qaoalib.qaoa.landscape import *