qaoalib 0.1.6__tar.gz → 0.1.8__tar.gz

qaoalib-0.1.8/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: qaoalib
+Version: 0.1.8
+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
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# qaoalib
+A package for QAOA Max-cut Calculations.
+
+Packages required:
+- numpy
+- networkx
+- matplotlib
+- qiskit
+
+# How to install
+You can install from the PyPI:
+```
+pip install --upgrade qaoalib
+```
+
+# Usage
+Calculate Max-cut expectation with `Qmc` or `QmcFastKron` (faster version):
+```
+import networkx as nx
+from qaoalib.qaoa import Qmc, QmcFastKron
+
+G = nx.fast_gnp_random_graph(10, 0.5)  # Random graph with 10 nodes
+params = [0.2, 0.4, 0.3, 0.5]          # 4 params, depth = 2
+
+qmc = Qmc(G, params) # or QmcFastKron(G, params)
+qmc.run()
+print(qmc.expectation)
+```
+
+Plot landscapes of the QAOA Max-cut expectation function:
+```
+import networkx as nx
+from qaoalib.qaoa.landscape import HybridFast
+
+G = nx.fast_gnp_random_graph(10, 0.5)
+prev_params = [0.1, 0.2] # previous parameters (gamma1, beta1)
+
+ins = HybridFast(G, prev_params) # plots the landscape wrt gamma2 and beta2 with previous parameters given.
+ins.create_grid()
+ins.show_landscape()
+```

qaoalib-0.1.8/README.md

@@ -0,0 +1,41 @@
+# qaoalib
+A package for QAOA Max-cut Calculations.
+
+Packages required:
+- numpy
+- networkx
+- matplotlib
+- qiskit
+
+# How to install
+You can install from the PyPI:
+```
+pip install --upgrade qaoalib
+```
+
+# Usage
+Calculate Max-cut expectation with `Qmc` or `QmcFastKron` (faster version):
+```
+import networkx as nx
+from qaoalib.qaoa import Qmc, QmcFastKron
+
+G = nx.fast_gnp_random_graph(10, 0.5)  # Random graph with 10 nodes
+params = [0.2, 0.4, 0.3, 0.5]          # 4 params, depth = 2
+
+qmc = Qmc(G, params) # or QmcFastKron(G, params)
+qmc.run()
+print(qmc.expectation)
+```
+
+Plot landscapes of the QAOA Max-cut expectation function:
+```
+import networkx as nx
+from qaoalib.qaoa.landscape import HybridFast
+
+G = nx.fast_gnp_random_graph(10, 0.5)
+prev_params = [0.1, 0.2] # previous parameters (gamma1, beta1)
+
+ins = HybridFast(G, prev_params) # plots the landscape wrt gamma2 and beta2 with previous parameters given.
+ins.create_grid()
+ins.show_landscape()
+```

qaoalib-0.1.8/qaoalib/data/graph.py

@@ -0,0 +1,18 @@
+from typing import Sequence
+from pydantic import BaseModel
+
+
+class GraphData(BaseModel):
+    n_nodes: int
+    edges: list[Sequence[int]]
+    n_edges: int
+    shift: float
+    true_obj: int
+
+
+class RegGraphData(GraphData):
+    deg: int
+
+
+class GnpGraphData(GraphData):
+    prob: float

qaoalib-0.1.8/qaoalib/data/result.py

@@ -0,0 +1,26 @@
+from typing import Union, Any
+from typing_extensions import TypeAlias
+from pydantic import BaseModel
+
+from .graph import RegGraphData, GnpGraphData
+
+SingleTrialDict: TypeAlias = dict[int, Any]
+MultipleTrialDict: TypeAlias = dict[int, list[Any]]
+
+
+class Result(BaseModel):
+    graph: Union[RegGraphData, GnpGraphData]
+    expectations: SingleTrialDict
+    alpha: SingleTrialDict
+    initial_params: SingleTrialDict
+    opt_params: SingleTrialDict
+    nfev: SingleTrialDict
+
+
+class PfResult(BaseModel):
+    graph: Union[RegGraphData, GnpGraphData]
+    expectations: MultipleTrialDict
+    alpha: MultipleTrialDict
+    initial_params: MultipleTrialDict
+    opt_params: MultipleTrialDict
+    nfev: MultipleTrialDict

{qaoalib-0.1.6 → qaoalib-0.1.8}/qaoalib/qaoa/qmc.py

@@ -5,6 +5,7 @@ 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
@@ -28,6 +29,7 @@ class Qmc:
 
         self.expectation = expectation(self.graph, self.result)
 
+
 class QmcFastKron(Qmc):
     def __init__(self, G, params):
         super().__init__(G, params)
@@ -38,14 +40,8 @@ class QmcFastKron(Qmc):
             edge = (u,v)
             kron_list = [Z if i in edge else I for i in range(len(self.graph.nodes))]
             kron_list.reverse()
-            sum_ += d.get("weight",1) * (1 - (sv.conj().T @ fast_kron(kron_list, sv)).item().real)
-            
- 
-        # for edge in self.graph.edges:
-        #     kron_list = [Z if i in edge else I for i in range(len(self.graph.nodes))]
-        #     kron_list.reverse()
-        #     sum_ += (sv.conj().T @ fast_kron(kron_list, sv)).item().real
-
+            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
 

qaoalib-0.1.8/qaoalib/qaoa/strategy.py

@@ -0,0 +1,70 @@
+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.1.6 → qaoalib-0.1.8}/qaoalib/utils.py

@@ -1,7 +1,10 @@
+from typing import Union, Literal, Optional
 import warnings
 import numpy as np
 import networkx as nx
 
+from .data.graph import RegGraphData, GnpGraphData
+
 
 def get_info(filename, indicator, mode='get-numeric'):
     try:
@@ -122,7 +125,7 @@ def _reg_params(degree, node, seed=None):
 
     return list(G.edges), shift, cost
 
-def load_data_prototype(graph_type, G=None, **data_kw):
+def load_data_prototype(graph_type, G=None, solve_brute=True, **data_kw):
     data = {
         'node': 0,
         'edges': [],
@@ -148,7 +151,8 @@ def load_data_prototype(graph_type, G=None, **data_kw):
         data['edges'] = list(G.edges)
         data['n_edge'] = len(G.edges)
         data['shift'] = -data['n_edge']/2.0
-        data['true_obj'], _ = maxcut_brute(G)
+        if solve_brute:
+            data['true_obj'], _ = maxcut_brute(G)
 
         if graph_type == 'reg':
             data['degree'] = len(list(G.neighbors(0)))
@@ -260,3 +264,43 @@ def post_process(data):
         for p, arr in data['expectations'].items():
             data['energies'][p] = -(np.asarray(arr) + data['shift'])
             data['alpha'][p] = np.asarray(arr) / data['true_obj']
+
+def convert_graph(
+    G: nx.Graph,
+    graph_type: Literal['reg', 'gnp'],
+    prob: Optional[float] = None,
+    solve_brute: bool = True,
+) -> Union[RegGraphData, GnpGraphData]:
+
+    if solve_brute:
+        true_obj, _ = maxcut_brute(G)
+    else:
+        true_obj = 0
+
+    n_nodes = len(G.nodes)
+    edges = list(G.edges)
+    n_edges = len(G.edges)
+    shift = -n_edges / 2.0
+
+    if graph_type == 'reg':
+        deg = len(list(G.neighbors(0)))
+        return RegGraphData(
+            deg=deg,
+            n_nodes=n_nodes,
+            edges=edges,
+            n_edges=n_edges,
+            shift=shift,
+            true_obj=true_obj,
+        )
+
+    elif graph_type == 'gnp':
+        if prob is None:
+            raise ValueError('`prob` must be passed for Gnp graphs.')
+        return GnpGraphData(
+            prob=prob,
+            n_nodes=n_nodes,
+            edges=edges,
+            n_edges=n_edges,
+            shift=shift,
+            true_obj=true_obj,
+        )

qaoalib-0.1.8/qaoalib/version.py

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

qaoalib-0.1.8/qaoalib.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: qaoalib
+Version: 0.1.8
+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
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# qaoalib
+A package for QAOA Max-cut Calculations.
+
+Packages required:
+- numpy
+- networkx
+- matplotlib
+- qiskit
+
+# How to install
+You can install from the PyPI:
+```
+pip install --upgrade qaoalib
+```
+
+# Usage
+Calculate Max-cut expectation with `Qmc` or `QmcFastKron` (faster version):
+```
+import networkx as nx
+from qaoalib.qaoa import Qmc, QmcFastKron
+
+G = nx.fast_gnp_random_graph(10, 0.5)  # Random graph with 10 nodes
+params = [0.2, 0.4, 0.3, 0.5]          # 4 params, depth = 2
+
+qmc = Qmc(G, params) # or QmcFastKron(G, params)
+qmc.run()
+print(qmc.expectation)
+```
+
+Plot landscapes of the QAOA Max-cut expectation function:
+```
+import networkx as nx
+from qaoalib.qaoa.landscape import HybridFast
+
+G = nx.fast_gnp_random_graph(10, 0.5)
+prev_params = [0.1, 0.2] # previous parameters (gamma1, beta1)
+
+ins = HybridFast(G, prev_params) # plots the landscape wrt gamma2 and beta2 with previous parameters given.
+ins.create_grid()
+ins.show_landscape()
+```

{qaoalib-0.1.6 → qaoalib-0.1.8}/qaoalib.egg-info/SOURCES.txt

@@ -11,10 +11,14 @@ qaoalib.egg-info/SOURCES.txt
 qaoalib.egg-info/dependency_links.txt
 qaoalib.egg-info/requires.txt
 qaoalib.egg-info/top_level.txt
+qaoalib/data/__init__.py
+qaoalib/data/graph.py
+qaoalib/data/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-0.1.6/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: qaoalib
-Version: 0.1.6
-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
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# qaoalib
-A package for QAOA Maxcut Calculations.
-
-Packages required:
-- numpy
-- networkx
-- matplotlib
-- qiskit
-
-# How to install
-You can install from the PyPI:
-```
-pip install --upgrade qaoalib
-```

qaoalib-0.1.6/README.md

@@ -1,14 +0,0 @@
-# qaoalib
-A package for QAOA Maxcut Calculations.
-
-Packages required:
-- numpy
-- networkx
-- matplotlib
-- qiskit
-
-# How to install
-You can install from the PyPI:
-```
-pip install --upgrade qaoalib
-```

qaoalib-0.1.6/qaoalib/version.py

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

qaoalib-0.1.6/qaoalib.egg-info/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.1
-Name: qaoalib
-Version: 0.1.6
-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
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# qaoalib
-A package for QAOA Maxcut Calculations.
-
-Packages required:
-- numpy
-- networkx
-- matplotlib
-- qiskit
-
-# How to install
-You can install from the PyPI:
-```
-pip install --upgrade qaoalib
-```