qaoalib 0.2.1__tar.gz → 0.3.0__tar.gz

qaoalib-0.3.0/MANIFEST.in

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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qaoalib
-Version: 0.2.1
+Version: 0.3.0
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee
@@ -13,23 +13,30 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: qiskit
 Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_algorithms
 Requires-Dist: qiskit_aer
-Requires-Dist: numpy==1.26.0
+Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: pytest
 Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: pydantic
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # 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 +45,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.0}/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.0/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.0/qaoalib/solver/lcc_vqe.py

@@ -0,0 +1,118 @@
+import numpy as np
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import ParameterVector
+from qiskit.quantum_info import SparsePauliOp, Pauli
+from qiskit_optimization import QuadraticProgram
+
+from .vqe import VQE
+
+class LCCVQE(VQE):
+    """
+    LCC for VQE ansatz with circular entanglement.
+    * Only works for one-local (Z) or two-local (ZZ) operations.
+    * Currently only consider the TwoLocal ansatz with RY rotation, CZ entanglement, and reps=1.
+    """
+
+    def __init__(
+        self,
+        quadratic_program: QuadraticProgram,
+        shots: int = None,
+        sampler=None,
+        estimator=None,
+        optimizer=None,
+    ) -> None:
+        super().__init__(
+            quadratic_program,
+            reps=1,
+            shots=shots,
+            sampler=sampler,
+            estimator=estimator,
+            optimizer=optimizer,
+        )
+
+    @staticmethod
+    def get_pauli_indices(pauli: Pauli) -> list[int]:
+        return np.argwhere(pauli.z).reshape(-1).tolist()
+
+    @staticmethod
+    def generate_local_ansatz(num_qubits: int) -> QuantumCircuit:
+        qc = QuantumCircuit(num_qubits)
+        theta = ParameterVector('θ', 2 * num_qubits)
+
+        # First layer RY
+        for k in range(num_qubits):
+            qc.ry(theta[k], k)
+
+        # Entangling CNOT
+        if num_qubits == 6:
+            for j, k in [(0, 1), (1, 2), (3, 4), (4, 5)]:
+                qc.cz(j, k)
+        else:
+            for k in range(num_qubits - 1):
+                qc.cz(k, k + 1)
+
+        # Second layer RY
+        for k in range(num_qubits):
+            qc.ry(theta[num_qubits + k], k)
+
+        return qc
+
+    def _distance(self, i, j):
+        return min(abs(i - j), abs(i + self.num_qubits - j), abs(j - i + self.num_qubits))
+
+    def generate_pubs(
+        self,
+        params: list[float] | np.ndarray,
+    ) -> list[tuple[QuantumCircuit, SparsePauliOp, np.ndarray]]:
+        pubs = []
+
+        for observable in self.hamiltonian:
+            pauli_indices = self.get_pauli_indices(observable.paulis[0])
+            if len(pauli_indices) == 1:
+                # one-local, 3-qubit
+                qc = self.generate_local_ansatz(3)
+                local_ob = SparsePauliOp('IZI', observable.coeffs[0])
+                i = pauli_indices[0]
+                first_layer = np.array([(i - 1), i, (i + 1)]) % self.num_qubits
+
+            elif len(pauli_indices) == 2:
+                # two-local
+                i, j = pauli_indices
+                if self._distance(i, j) == 1:
+                    # 4-qubit
+
+                    qc = self.generate_local_ansatz(4)
+                    local_ob = SparsePauliOp('IZZI', observable.coeffs[0])
+
+                    if i == 0 and j == self.num_qubits - 1:
+                        first_layer = np.array([j - 1, j, i, i + 1]) % self.num_qubits
+                    else:
+                        first_layer = np.array([i - 1, i, j, j + 1]) % self.num_qubits
+
+                elif self._distance(i, j) == 2:
+                    # 5-qubit
+                    qc = self.generate_local_ansatz(5)
+                    local_ob = SparsePauliOp('IZIZI', observable.coeffs[0])
+
+                    if i + 2 == j:
+                        first_layer = np.array([i - 1, i, i + 1, j, j + 1]) % self.num_qubits
+                    else:
+                        first_layer = np.array([j - 1, j, i - 1, i, i + 1]) % self.num_qubits
+
+                elif self._distance(i, j) > 2:
+                    # 6-qubit
+                    qc = self.generate_local_ansatz(6)
+                    local_ob = SparsePauliOp('IZIIZI', observable.coeffs[0])
+                    first_layer = np.array([i - 1, i, i + 1, j - 1, j, j + 1]) % self.num_qubits
+            else:
+                raise ValueError(f'Pauli indices must be of 1 or 2 length. Got {len(pauli_indices)} instead.')
+
+            second_layer = first_layer + self.num_qubits
+            param_indices = np.hstack([first_layer, second_layer]).tolist()
+
+            # construct pub
+            params = np.asarray(params)
+            pubs.append((qc, local_ob, params[param_indices]))
+
+        return pubs

{qaoalib-0.2.1 → qaoalib-0.3.0}/qaoalib/solver/vqe.py

@@ -21,12 +21,11 @@ class VQE:
     def __init__(
         self,
         quadratic_program: QuadraticProgram,
-        ansatz: QuantumCircuit = None,
-        reps: int = 1,
+        ansatz: QuantumCircuit,
         shots: int = None,
         sampler=None,
         estimator=None,
-        optimizer=None,        
+        optimizer=None,
     ) -> None:
         self.qp = quadratic_program
         self.converter = QuadraticProgramToQubo()
@@ -37,7 +36,7 @@ class VQE:
         self.offset: float = offset
 
         self.num_qubits = hamiltonian.num_qubits
-        self.ansatz = self.generate_full_ansatz(hamiltonian.num_qubits, reps) if ansatz is None else ansatz
+        self.ansatz = ansatz
 
         backend_sv = AerSimulator(method='statevector')
         backend_mps = AerSimulator(method='matrix_product_state')
@@ -48,33 +47,16 @@ class VQE:
 
         self.optimal_params = None
         self.optimal_solution = None
-    
-    @staticmethod
-    def generate_full_ansatz(num_qubits: int, reps: int) -> QuantumCircuit:
-        qc = QuantumCircuit(num_qubits)
-        theta = ParameterVector('θ', (reps + 1) * num_qubits)
-        
-        for k in range(num_qubits):
-            qc.ry(theta[k], k)
-
-        for r in range(1, reps + 1):
-            for k in range(num_qubits):
-                qc.cz(k, (k + 1) % num_qubits)
-
-            for k in range(num_qubits):
-                qc.ry(theta[r * num_qubits + k], k)
-
-        return qc
-    
+
     def generate_random_params(self, scale=TWO_PI):
         return np.random.rand(self.ansatz.num_parameters) * scale
-    
+
     def generate_pubs(
-        self, 
+        self,
         params: list[float] | np.ndarray,
     ) -> list[tuple[QuantumCircuit, SparsePauliOp, np.ndarray]]:
         return [(self.ansatz, self.hamiltonian, params)]
-    
+
     def compute_energy(self, params: list[float] | np.ndarray) -> float:
         """
         Computes the sum of expectation of the ZZ terms.
@@ -83,14 +65,14 @@ class VQE:
         results = self.estimator.run(pubs).result()
         evs = [result.data.evs for result in results]
         return sum(evs)
-    
+
     def _sample_optimal_circuit(self) -> dict[str, int]:
         """
-        Run the full circuit with sampler to get the solution. 
+        Run the full circuit with sampler to get the solution.
         """
         if self.optimal_params is None:
             raise ValueError('Problem not yet solved. Run LCCVQE.solve() to solve the problem.')
-        
+
         ansatz = self.ansatz.copy()
         ansatz.measure_all()
         result = self.sampler.run([(ansatz, self.optimal_params)], shots=self.shots).result()[0]
@@ -103,13 +85,13 @@ class VQE:
         for bit_string, count in counts.items():
             if count == highest_count:
                 return list(map(int, bit_string[::-1])) # flip the bit-string due to qiskit ordering
-            
+
     def get_qp_solution(self) -> list[float]:
         qubo_solution = self._sample_most_likely()
         return self.converter.interpret(qubo_solution)
 
     def solve(
-        self, 
+        self,
         initial_point: list[float] | np.ndarray = None,
         run_sampler: bool = False,
     ) -> OptimizerResult:
@@ -120,7 +102,7 @@ class VQE:
             initial_point = self.generate_random_params()
         else:
             assert np.asarray(initial_point).shape[0] == self.ansatz.num_parameters, 'Parameter length does not match.'
-        
+
         def obj_func(params):
             return self.compute_energy(params)
 

qaoalib-0.3.0/qaoalib/version.py

@@ -0,0 +1 @@
+0.3.0

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qaoalib
-Version: 0.2.1
+Version: 0.3.0
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee
@@ -13,23 +13,30 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: qiskit
 Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_algorithms
 Requires-Dist: qiskit_aer
-Requires-Dist: numpy==1.26.0
+Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: pytest
 Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: pydantic
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # 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 +45,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.0}/qaoalib.egg-info/SOURCES.txt

@@ -1,7 +1,10 @@
 LICENSE
+MANIFEST.in
 README.md
+requirements.txt
 setup.py
 qaoalib/__init__.py
+qaoalib/ansatz.py
 qaoalib/json.py
 qaoalib/math.py
 qaoalib/utils.py
@@ -14,5 +17,5 @@ qaoalib.egg-info/top_level.txt
 qaoalib/models/__init__.py
 qaoalib/models/result.py
 qaoalib/solver/__init__.py
-qaoalib/solver/vqe.py
-test/test.py
+qaoalib/solver/lcc_vqe.py
+qaoalib/solver/vqe.py

{qaoalib-0.2.1 → qaoalib-0.3.0}/qaoalib.egg-info/requires.txt

@@ -1,7 +1,8 @@
 qiskit
 qiskit_optimization
+qiskit_algorithms
 qiskit_aer
-numpy==1.26.0
+numpy
 scipy
 pytest
 pytest-cov

qaoalib-0.3.0/requirements.txt

@@ -0,0 +1,11 @@
+qiskit
+qiskit_optimization
+qiskit_algorithms
+qiskit_aer
+numpy
+scipy
+pytest
+pytest-cov
+matplotlib
+networkx
+pydantic

{qaoalib-0.2.1 → qaoalib-0.3.0}/setup.py

@@ -3,7 +3,11 @@ from setuptools import setup, find_packages
 with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
-exec(open('qaoalib/version.py').read()) # puts __version__ into the namespace
+with open("qaoalib/version.py", "r") as f:
+    __version__ = f.read().strip()
+
+with open("requirements.txt", "r") as f:
+    requirements = [package.strip() for package in f]
 
 setup(
     name="qaoalib",
@@ -21,16 +25,5 @@ setup(
     ],
     packages=find_packages(exclude=["test*"]),
     python_requires=">=3.9",
-    install_requires=[
-        "qiskit",
-        "qiskit_optimization",
-        "qiskit_aer",
-        "numpy==1.26.0",
-        "scipy",
-        "pytest",
-        "pytest-cov",
-        "matplotlib",
-        "networkx",
-        "pydantic",
-    ],
+    install_requires=requirements,
 )

qaoalib-0.2.1/qaoalib/version.py

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

qaoalib-0.2.1/test/test.py

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