eqc-models 0.10.0__py3-none-any.whl → 0.10.3__py3-none-any.whl

{eqc_models-0.10.0.data → eqc_models-0.10.3.data}/platlib/eqc_models/base/polynomial.py

@@ -117,12 +117,15 @@ class PolynomialModel(PolynomialMixin, EqcModel):
 
     @property
     def qubo(self) -> QUBO:
+        polynomial = self.polynomial
+        coefficients = polynomial.coefficients
+        indices = polynomial.indices
         try:
-            if np.all([len(self.polynomial.indices[i]) == 2 for i in range(len(self.polynomial.indices))]):
+            if np.all([len(indices[i]) == 2 for i in range(len(indices))]):
                 bin_n = 0
                 bits = []
-                C, J = self._quadratic_polynomial_to_qubo_coefficients(self.polynomial.coefficients,
-                                                                       self.polynomial.indices, self.n)
+                C, J = self._quadratic_polynomial_to_qubo_coefficients(coefficients,
+                                                                       indices, self.n)
                 # upper_bound is an array of the maximum values each variable can take
                 upper_bound = self.upper_bound
                 if np.sum(upper_bound) != upper_bound.shape[0]:
@@ -158,6 +161,7 @@ class PolynomialModel(PolynomialMixin, EqcModel):
                 raise OperatorNotAvailableError("QUBO operator not available")
         except OperatorNotAvailableError as e:
             print(e)
+            raise
 
     def _quadratic_polynomial_to_qubo_coefficients(self, coefficients, indices, num_variables):
         """

eqc_models-0.10.3.data/platlib/eqc_models/combinatorics/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .setcover import SetCoverModel
+from .setpartition import SetPartitionModel
+
+__all__ = ["SetCoverModel", "SetPartitionModel"]

{eqc_models-0.10.0.data → eqc_models-0.10.3.data}/platlib/eqc_models/combinatorics/setcover.py

@@ -37,44 +37,61 @@ class SetCoverModel(ConstrainedQuadraticModel):
         List of weights where each weight is the cost of choosing the subset
         corresponding to the index of the weight.
 
+
     >>> X = [set(['A', 'B']), set(['B', 'C']), set(['C'])]
     >>> weights = [2, 2, 1]
     >>> model = SetCoverModel(X, weights)
-    >>> model.penalty_multiplier = 2
+    >>> model.penalty_multiplier = 8
+    >>> lhs, rhs = model.constraints
+    >>> lhs
+    array([[ 1,  0,  0,  0,  0],
+           [ 1,  1,  0, -1,  0],
+           [ 0,  1,  1,  0, -1]])
     >>> from eqc_models.solvers import Dirac3IntegerCloudSolver
     >>> solver = Dirac3IntegerCloudSolver()
     >>> response = solver.solve(model, relaxation_schedule=1, num_samples=5) #doctest: +ELLIPSIS
     20...
     >>> solutions = response["results"]["solutions"]
     >>> solutions[0]
-    [1, 0, 1, 0, 0, 0]
-    >>> model.decode(solutions[0])
-    [{'B', 'A'}, {'C'}]
+    [1, 0, 1, 0, 0]
+    >>> selections = model.decode(solutions[0])
+    >>> assert {'B', 'A'} in selections
+    >>> assert {'C'} in selections
+    >>> assert len(selections) == 2
 
     """
 
     def __init__(self, subsets, weights):
         # ensure that X is ordered
-        self.X = X = list(subsets)
-        self.S = S = set()
+        self.S = S = list(subsets)
+        self.universal_set = U = set()
 
         for x in subsets:
-            S = S.union(x)
+            U.update(x)
         # elements is sorted to maintain consistent output
-        elements = [a for a in S]
+        elements = [a for a in U]
         elements.sort()
         # constraints 
         A = []
         b = []
-        variables = [f'x_{i}' for i in range(len(X))]
+        variables = [f'x_{i}' for i in range(len(S))]
         pos = 0
+        num_slacks = 0
+        slack_ub = []
         for a in elements:
-            variables.append(f"s_{pos}")
-            constraint = [1 if a in X[i] else 0 for i in range(len(X))]
-            slacks = [0 for i in range(len(S))]
-            slacks[pos] = -1
+            num_sets = sum([1 if a in S[i] else 0 for i in range(len(S))])
+            assert num_sets >= 1, "Invalid subsets, check the universal set"
+            if num_sets > 1:
+                num_slacks += 1
+            slack_ub.append(num_sets-1)
+        for i, a in enumerate(elements):
+            constraint = [1 if a in S[j] else 0 for j in range(len(S))]
+            slacks = [0 for i in range(num_slacks)]
+            if slack_ub[i] > 0:
+                variables.append(f"s_{pos}")
+                slacks[pos] = -1
+                pos += 1
             A.append(constraint + slacks)
-            pos += 1
             b.append(1)
         n = len(variables)
         J = np.zeros((n, n))
@@ -83,11 +100,12 @@ class SetCoverModel(ConstrainedQuadraticModel):
         # call the superclass constructor with the objective and constraints
         super(SetCoverModel, self).__init__(h, J, np.array(A), np.array(b))
         # set upper bound on the variables to be 1 for x_i and the length of X minus 1 for the slacks
-        self.upper_bound = np.array([1 for i in range(len(weights))] + [len(X)-1 for i in range(n-len(weights))])
+        slack_ub = [val for val in slack_ub if val > 0]
+        self.upper_bound = np.array([1 for i in range(len(weights))] + slack_ub)
 
     def decode(self, solution) -> List:
         xbar = []
-        for i in range(len(self.X)):
+        for i in range(len(self.S)):
             if solution[i] > 0.5:
-                xbar.append(self.X[i])
+                xbar.append(self.S[i])
         return xbar

{eqc_models-0.10.0.data/platlib/eqc_models/assignment → eqc_models-0.10.3.data/platlib/eqc_models/combinatorics}/setpartition.py

@@ -86,6 +86,8 @@ class SetPartitionModel(ConstrainedPolynomialModel):
         b = np.ones((A.shape[0],))
         n = A.shape[1]
 
+        self.upper_bound = np.ones((n,), np.int32)
+
         # Define the linear objective function based on subset weights
         self.linear_objective = np.array(weights).reshape((n, 1))
         self.quad_objective = np.zeros((n, n)) #np.zeros_like(J)

eqc_models-0.10.3.data/platlib/eqc_models/graph/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .maxcut import MaxCutModel
+from .partition import GraphPartitionModel
+
+__all__ = ["MaxCutModel", "GraphPartitionModel"]

{eqc_models-0.10.0.data → eqc_models-0.10.3.data}/platlib/eqc_models/graph/maxkcut.py

@@ -1,20 +1,24 @@
 # (C) Quantum Computing Inc., 2024.
+from typing import Tuple
 import numpy as np
 import networkx as nx
 from .base import NodeModel
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
 
-
-class MaxKCutModel(NodeModel):
+class MaxKCutModel(ConstrainedQuadraticModel):
+    _objective = None
 
     def __init__(self, G : nx.Graph, k : int):
-        super(MaxKCutModel, self).__init__(G)
+        self.G = G
         self.k = k
-        self.lhs = None
-        self.rhs = None
-        self._objective = None
-        self._J = None
-        self._C = None
-
+        A, b = self._build_constraints()
+        c, J = self.costFunction()
+        ConstrainedQuadraticModel.__init__(self, c, J, A, b)
+        if k < 3:
+            raise ValueError("k must be greater than 2")
+        n = len(G.nodes) * k
+        self.upper_bound = np.ones((n,))
+        
     def decode(self, solution: np.ndarray) -> np.ndarray:
         """ Override the default decoding to use a the max cut metric to determine a solution """
 
@@ -22,7 +26,8 @@ class MaxKCutModel(NodeModel):
         # rather than the same cutoff per node, use the max value per partition
         decoded_solution = np.zeros_like(solution, dtype=np.int32)
         k = self.k
-        for i, u in enumerate(self.variables):
+        G = self.G
+        for i, u in enumerate(G.nodes):
             idx = slice(k*i, k*(i+1))
             spins = solution[idx]
             mx = np.max(spins)
@@ -35,9 +40,9 @@ class MaxKCutModel(NodeModel):
     def partition(self, solution):
         """ Return a dictionary with the partition number of each node """
         k = self.k
-        n = len(self.variables)
+        G = self.G
         partition_num = {}
-        for i, u in enumerate(self.variables):
+        for i, u in enumerate(G.nodes):
             for j in range(k):
                 if solution[i*k+j] == 1:
                     partition_num[u] = j+1
@@ -50,10 +55,10 @@ class MaxKCutModel(NodeModel):
                 cut_size += 1
         return cut_size
 
-    def _build_objective(self):
+    def costFunction(self) -> Tuple:
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -70,12 +75,12 @@ class MaxKCutModel(NodeModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += -1
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def _build_constraints(self):
 
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
 
@@ -86,78 +91,31 @@ class MaxKCutModel(NodeModel):
             i = node_map.index(u)
             ibase = i * self.k
             A[i, ibase:ibase+self.k] = 1
-        self.lhs = A
-        self.rhs = b
-
-    def build(self, multiplier=None):
-        """ Create the constraints and objective and Hamiltonian """
-
-        # there are k * m variables in this problem where m is the number of nodes in the graph
-        node_map = self.variables
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        self.upper_bound = np.ones((n,))
-        
-        self._build_objective()
-        if multiplier is None:
-            multiplier = np.max(np.abs(self._objective[1]))
-        self._build_constraints()
-
-        self._C, self._J = self.buildH(multiplier)
-        self.sum_constraint = m
-
-    def buildH(self, multiplier):
-        """ Combine the objective and penalties using the multiplier """
-
-        objC, objJ = self.objective
-        lhs, rhs = self.constraints
-        Pq = lhs.T@lhs
-        Pl = -2 * rhs.T@lhs
-        offset = rhs.T@rhs
-        n = self.n
-        J = np.zeros((n, n), np.float32)
-        C = np.zeros([n, 1], np.float32)
-        C += objC
-        J[:,:] += objJ
-        C += multiplier * Pl.reshape((n, 1))
-        J[:,:] += multiplier * Pq
-        return C, J
+        return A, b
 
     @property
     def constraints(self):
         """ Return LHS, RHS in numpy matrix format """
-        if self.rhs is None:
-            self.build()
+
         return self.lhs, self.rhs
 
     @property
     def objective(self):
         """ Return the quadratic objective as NxN+1 matrix """
 
-        if self._objective is None:
-            self.build()
         return self._objective
 
-    @property
-    def H(self):
-        """ Return the Hamiltonian as parts C, J """
-
-        if self._C is None:
-            self.build()
-        return self._C, self._J
-    
 class WeightedMaxKCutModel(MaxKCutModel):
 
     def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
-        super().__init__(G, k)
+        super(WeightedMaxCutModel).__init__(G, k)
 
         self.weight_label = weight_label
     
     def _build_objective(self):
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -174,7 +132,7 @@ class WeightedMaxKCutModel(MaxKCutModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += G[u][v][self.weight_label]
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def getCutSize(self, partition):
         cut_size = 0

{eqc_models-0.10.0.data → eqc_models-0.10.3.data}/platlib/eqc_models/solvers/qciclient.py

@@ -68,10 +68,19 @@ class QciClientMixin:
             client = QciClient(url=self.url, api_token=self.api_token)
         return client
 
+    def getMetrics(self, job_id : str) -> Dict:
+        """
+        Returns a dictionary containing the job metrics.
+
+        """
+        client = self.client
+        metrics = client.get_job_metrics(job_id=job_id)
+        return metrics
+
 class Dirac1Mixin:
     sampler_type = "dirac-1"
     requires_operator = "qubo"
-    max_upper_bound = 1
+    max_upper_bound = 205 # log encoding beyond this level has inherent issues
     job_params_names = ["num_samples", "alpha", "atol"]
 
 class QuboSolverMixin:
@@ -141,7 +150,7 @@ class Dirac3Mixin:
         poly_indices = polynomial.indices
         data = []
         # must find these attributes of the polynomial before uploading
-        max_degree = 0
+        max_degree = 2
         min_degree = len(poly_indices[-1])
         num_variables = 0
         for i in range(len(poly_coeffs)):

{eqc_models-0.10.0.dist-info → eqc_models-0.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.10.0
+Version: 0.10.3
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -22,6 +22,7 @@ Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: sphinx_rtd_theme<2,>=1.3.0; extra == "dev"
+Dynamic: license-file
 
 # EQC Models
 

eqc_models-0.10.3.dist-info/RECORD

@@ -0,0 +1,59 @@
+eqc_models-0.10.3.data/platlib/compile_extensions.py,sha256=ivFZ87WFzBITU7IwK_72C41MDNMortJIF8tKevm2aW4,1946
+eqc_models-0.10.3.data/platlib/eqc_models/__init__.py,sha256=WPUijJz2-4UZU-ZTqBofDc-Yaah24geHdmF16SkwIj4,683
+eqc_models-0.10.3.data/platlib/eqc_models/decoding.py,sha256=G3JgbIFzvZ3DIKW0kZ1JeTMIZmrc8hy9kzdbX2Xv5Og,637
+eqc_models-0.10.3.data/platlib/eqc_models/algorithms/__init__.py,sha256=lzQoMMSs2QTqp5suEYNvcQaSEN16d0LwIsZ1mRstumU,135
+eqc_models-0.10.3.data/platlib/eqc_models/algorithms/base.py,sha256=qfQQTwuVyewn7Qpg1_SVoD_7TsdA8vdwSKGqOeZSmNI,204
+eqc_models-0.10.3.data/platlib/eqc_models/algorithms/penaltymultiplier.py,sha256=SndGxCZDS3JTaxFOPJpTBumFdIKcB0dKwSHwfl_BI6o,7845
+eqc_models-0.10.3.data/platlib/eqc_models/allocation/__init__.py,sha256=op_udrapTlWrakTuQId3M0ggo-Y1w4nGJLPcYKOQ-8I,239
+eqc_models-0.10.3.data/platlib/eqc_models/allocation/allocation.py,sha256=PAQn4M75Zegeoy0i6r3hycWs4TKeRglHk05TvwZOoLk,15506
+eqc_models-0.10.3.data/platlib/eqc_models/allocation/portbase.py,sha256=BTnYYduHydPbrE2yQr_Sgv3XJACH_GpIJstuMrfGqCU,3269
+eqc_models-0.10.3.data/platlib/eqc_models/allocation/portmomentum.py,sha256=oMod63rNDC-01dLZjmhUb24SN3_GVgfc6CItgQL_obI,3756
+eqc_models-0.10.3.data/platlib/eqc_models/assignment/__init__.py,sha256=CX_QYl8P1meajV8gcVs6hm07VhoLVe8uu436t7-1XQo,86
+eqc_models-0.10.3.data/platlib/eqc_models/assignment/qap.py,sha256=WMiQQmTORsgi2w7kbmMA1xo-93dESLECWqYTF-zkmTs,2963
+eqc_models-0.10.3.data/platlib/eqc_models/assignment/setpartition.py,sha256=5SQxF_ZlQk4ubWf5_3TgL83k01hAakUP-5AydlD-BvE,161
+eqc_models-0.10.3.data/platlib/eqc_models/base/__init__.py,sha256=RwZguuucmsuOSVqfPLBqj-wzinBOzcgO-2ifFU-DCqg,2885
+eqc_models-0.10.3.data/platlib/eqc_models/base/base.py,sha256=tL6z0MW4ffMKWlozZ0CH4soTiKxSlMXqyVDctaA110U,6405
+eqc_models-0.10.3.data/platlib/eqc_models/base/constraints.py,sha256=KMPyCdt_8GMWLnVEdpzw1T1WqXm2f7Lh629ClUH7XDY,8271
+eqc_models-0.10.3.data/platlib/eqc_models/base/operators.py,sha256=9nCeN6fRP-_YBfs-Gm57D-O_376qcOQiqGDuVlSlf00,7392
+eqc_models-0.10.3.data/platlib/eqc_models/base/polyeval.c,sha256=OHAMclzGp8GW6JPF2cANT8tTA4Wj0n82nucfJquMkO8,438431
+eqc_models-0.10.3.data/platlib/eqc_models/base/polyeval.cpython-310-darwin.so,sha256=EqawhkeRtBexOXXkt-k12SIN76LAlVCIW9taTWFn0GA,101136
+eqc_models-0.10.3.data/platlib/eqc_models/base/polyeval.pyx,sha256=76Bf99Jt1_rLh5byrZxAjavE2F4_yCysirViqOBFIXw,2547
+eqc_models-0.10.3.data/platlib/eqc_models/base/polynomial.py,sha256=FQA26ihFlwfHz9k9XP3qDM0hl5Ko4rtUxiXloj3ail4,13056
+eqc_models-0.10.3.data/platlib/eqc_models/base/quadratic.py,sha256=BHZKniUvSq30pZgzguVasdO39BCEYue_wi5AIklPGS8,8062
+eqc_models-0.10.3.data/platlib/eqc_models/combinatorics/__init__.py,sha256=BhzcVxwpWu2b4jIe0bmPzD5VmSyzwp0oW2q9iYx2IUs,167
+eqc_models-0.10.3.data/platlib/eqc_models/combinatorics/setcover.py,sha256=T5hXoE9Ecw3mTHPLmifBwTzpF_4MhoCUgo2rkSOWt5s,3396
+eqc_models-0.10.3.data/platlib/eqc_models/combinatorics/setpartition.py,sha256=ZD69kgEYSU3KWnx0b4MVCP8XSxbA_VCXOW22_Yssl_M,6254
+eqc_models-0.10.3.data/platlib/eqc_models/graph/__init__.py,sha256=zlPE_c92wsuzz_wQLs0nxYi7tHCYxrPs-yOa9BhQAIo,162
+eqc_models-0.10.3.data/platlib/eqc_models/graph/base.py,sha256=j48OwhorZ5jTlTysTmMiXCeiAdj6jylBREk3NxCpFLI,2072
+eqc_models-0.10.3.data/platlib/eqc_models/graph/hypergraph.py,sha256=ABvutT0NOdIEpUF4TjUzboE4Y_J5iUZyj6-AzKr4R28,13268
+eqc_models-0.10.3.data/platlib/eqc_models/graph/maxcut.py,sha256=o8xVsAwTa9jcpmsIoCQ5z7HSstVdraT8TENomdT519o,4132
+eqc_models-0.10.3.data/platlib/eqc_models/graph/maxkcut.py,sha256=rEDBjto2MbuPh4c0RwTOZoVffKgcriqHNOZAIuBlclQ,4654
+eqc_models-0.10.3.data/platlib/eqc_models/graph/partition.py,sha256=HMpRRipLp14x8pHucY-g6fU7v0PGoy1pf_KpzbanfD0,5800
+eqc_models-0.10.3.data/platlib/eqc_models/ml/__init__.py,sha256=CLfraacr0FrD5ynxlNB6cyNy0lpbavcQT45TvkDrNvY,369
+eqc_models-0.10.3.data/platlib/eqc_models/ml/classifierbase.py,sha256=1yXufiUGpaiBjI2evMiwfYn-Zr-SnWwCnvtREqprtJw,2184
+eqc_models-0.10.3.data/platlib/eqc_models/ml/classifierqboost.py,sha256=5Dcpd0DjpMmlUULyZFKKWm4UuZpeMaknWKViiIjwc0U,18978
+eqc_models-0.10.3.data/platlib/eqc_models/ml/classifierqsvm.py,sha256=b6TdwlghR84UoQpfUThwMwNF_wmkABbCqOn6T1uY2dA,6636
+eqc_models-0.10.3.data/platlib/eqc_models/ml/clustering.py,sha256=yhh6jlgwZiQVn9h2pnYBlzVTCocK7rzsEurSQxCn5FQ,9486
+eqc_models-0.10.3.data/platlib/eqc_models/ml/clusteringbase.py,sha256=AvQbt6jeocBAGCuAmXHKyr3wLWqYUtBDq9PbsEOSlSc,2632
+eqc_models-0.10.3.data/platlib/eqc_models/ml/cvqboost_hamiltonian.pyx,sha256=3PMmEJ_xfmmWXGfire0t-WASnmKj6-CblufgQ2NTARo,2111
+eqc_models-0.10.3.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.c,sha256=ZoKgm_uGjTewhk4W6s-x8QoFuZO0KVkxILIFh6JKsoI,1851
+eqc_models-0.10.3.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.h,sha256=aOImMG5pziUnZxGpDXyWjLrvcY7ZdsczwwSQ2ay4T88,272
+eqc_models-0.10.3.data/platlib/eqc_models/ml/decomposition.py,sha256=Nsnq0GmINpbGOszndgCHXqKdECNpiNiampBrHPU_Gjg,8943
+eqc_models-0.10.3.data/platlib/eqc_models/ml/forecast.py,sha256=fFcBxQK9ZryfEuyvlr9HXicHoZRzLFybimYYttzhI9E,7403
+eqc_models-0.10.3.data/platlib/eqc_models/ml/forecastbase.py,sha256=s-6nUMvtYqG07r7MmmkFVj8_QqgeGkD-HVoEEDTE2bk,3654
+eqc_models-0.10.3.data/platlib/eqc_models/ml/regressor.py,sha256=LA1woXCnefG0wfoOxilX1kszgCUmfNcbQgs_WZ4Ai0o,5683
+eqc_models-0.10.3.data/platlib/eqc_models/ml/regressorbase.py,sha256=H5E8-8pUji1oH5JRdS37LJQoHuKt2JU8eXCZp-ZaEM4,2109
+eqc_models-0.10.3.data/platlib/eqc_models/ml/reservoir.py,sha256=cPRvpCaWLYTBkui35jCssHcOPQgSQZallrG6Ac9djVI,2827
+eqc_models-0.10.3.data/platlib/eqc_models/sequence/__init__.py,sha256=VXlYufO3GYFsM00oii9Cite2WsQEF8XTwRcjLPH_Zlg,92
+eqc_models-0.10.3.data/platlib/eqc_models/sequence/tsp.py,sha256=YM641FTyK5NkgRGxHrU1QmMkEU0gf77nEmIElTqa6Qw,7680
+eqc_models-0.10.3.data/platlib/eqc_models/solvers/__init__.py,sha256=hTjJI4F0FNDgQlK_oRHJxLIkg6of3I1-nEqU_3RL4Gk,542
+eqc_models-0.10.3.data/platlib/eqc_models/solvers/qciclient.py,sha256=uZrtK03oA9ozTGD--hUicmu8zoHYkuIaJ924tOtGwzU,27269
+eqc_models-0.10.3.data/platlib/eqc_models/utilities/__init__.py,sha256=SI2U7JKmPWSiq-F1WcSyfd7l9V6nbOZv_p8quMAZaT0,340
+eqc_models-0.10.3.data/platlib/eqc_models/utilities/fileio.py,sha256=alWPTfjGFx6Iio9HZAAWtYcLmZsBBifg6S6_YbFMQhk,1088
+eqc_models-0.10.3.data/platlib/eqc_models/utilities/polynomial.py,sha256=blXfu7Ehz9lT4nEmIinRzJOL27_qUHSbQ57zxmwDJCA,4735
+eqc_models-0.10.3.data/platlib/eqc_models/utilities/qplib.py,sha256=Do-MjmCFdI5HyDOAjfoz4_5lugySLMBlMAWDLUWx2OA,15796
+eqc_models-0.10.3.dist-info/licenses/LICENSE.txt,sha256=8eh0oqsNNVR1Jk-13gkqRRSo2axtUU5kp2KzH4f9u3U,11354
+eqc_models-0.10.3.dist-info/METADATA,sha256=FnNDJZMf48W-Xe09DRn9T4iEJjHoXJleIui-4Dy23nU,7129
+eqc_models-0.10.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+eqc_models-0.10.3.dist-info/top_level.txt,sha256=9ZfFeKNEvkRlKWoUnfcZ9TzmTdgdsuPEnTPy11Hqf4Q,30
+eqc_models-0.10.3.dist-info/RECORD,,

{eqc_models-0.10.0.dist-info → eqc_models-0.10.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

eqc_models-0.10.0.data/platlib/eqc_models/base.py

@@ -1,115 +0,0 @@
-import os
-import logging
-from typing import (Dict, List, Tuple)
-import numpy as np
-from eqc_direct.client import EqcClient
-
-log = logging.getLogger(name=__name__)
-
-# base class 
-class EqcModel:
-    """ EqcModel subclasses must provide these properties/methods. 
-    
-    :decode: takes a raw solution and translates it into the original problem
-      formulation 
-    :H: property which returns a Hamiltonian operator 
-    :levels: property to set the number of levels in each qudit
-    :qudit_limits: maximjm value permitted for each qudit """
-
-    _levels = 100
-    _domains = None
-    _H = None
-    _machine_slacks = 0
-    
-    def decode(self, solution : np.ndarray) -> np.ndarray:
-        """ Interpret the solution given the norm value and domains """
-        
-        # ignore any slacks that may have been added during encoding
-        solution = solution[:self.n]
-        if self._domains is not None:
-            multipliers = self.domains / self.sum_constraint
-        else:
-            multipliers = self.sum_constraint / np.sum(solution)
-        
-        return multipliers * solution
-    
-    def encode(self, norm_value:float=1000) -> np.ndarray:
-        """ Encode Hamiltonian into the domain of the device """
-
-        raise NotImplementedError()
-
-    def encode_sum_constraint(self, levels):
-        new_sc = self.n * (levels-1) * self.sum_constraint / (np.sum(self.domains))
-        return new_sc
-
-    @property
-    def domains(self) -> np.array:
-        return self._domains
-
-    @domains.setter
-    def domains(self, value):
-        self._domains = value
-
-    @property
-    def n(self) -> int:
-        return int(max(self.domains.shape))
-    
-    def processH(self, H : np.ndarray) -> np.ndarray:
-        """ By default, do nothing to H """
-
-        return H
-
-    @property
-    def H(self) -> Dict[str, np.ndarray]:
-        """ Matrix of a quadratic operator with the first column containing
-        the linear terms and the remaining columns containing a symmetric
-        quadratic matrix"""
-        return self._H
-
-    @H.setter
-    def H(self, value : Dict[str, np.ndarray]):
-        """ The H setter ensures that matrices order 2 and above are symmetric """
-
-        H = self.processH(value)
-        self._H = H
-
-    @property
-    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
-        H = self.H
-        coeff = []
-        idx = []
-        poly_orders = {"C": 1, "J": 2, "T": 3, "Q": 4, "P": 5}
-        key_len = max([poly_orders[k] for k, v in H.items() if v is not None])
-        
-        
-    @property
-    def machine_slacks(self):
-        """ Number of slack qudits to add to the model """
-        return self._machine_slacks
-
-    @machine_slacks.setter
-    def machine_slacks(self, value:int):
-        assert int(value) == value, "value not integer"
-        self._machine_slacks = value
-
-class ModelSolver:
-    """ Provide a common interface for solver implementations. 
-    Store a model, implement a solve method."""
-
-    def __init__(self, model : EqcModel, levels : int = 200):
-        self.model = model
-        self._levels = levels
-
-    def solve(self, *args, **kwargs) -> Dict:
-        raise NotImplementedError()
-
-    @property
-    def levels(self) -> int:
-        """ This integer value indicates the number of distinct 
-        states each qudit can represent. These levels are separated
-        by some constant value with the first level taking the value 0. """
-        return self._levels
-
-    @levels.setter
-    def levels(self, value : int):
-        self._levels = value

eqc_models-0.10.0.data/platlib/eqc_models/communitydetection.py

@@ -1,25 +0,0 @@
-# (C) Quantum Computing Inc., 2024.
-import numpy as np
-import networkx as nx
-from .graphs import GraphModel
-
-class CommunityDetectionModel(GraphModel):
-    """ 
-    This model is the generic n-community model, which requires enforcing 
-    membership to a single community
-    
-    """
-
-    def __init__(self, G : nx.Graph, num_communities : int):
-        super(CommunityDetectionModel, self).__init__(G)
-        self.cnum_communities = num_communities
-
-    def build(self):
-        # num_nodes = len(self.G.nodes)
-        # num_variables = num_nodes * self.num_communities
-        # lhs = np.zeros((num_nodes, num_variables), dtype=np.int32)
-        # rhs = np.ones((num_nodes, 1), dtype=np.int32)
-        # for i in range(num_nodes):
-        #     lhs[i, 3*i:3*(i+1)] = 1
-        # self.constraints = lhs, rhs
-        raise NotImplementedError("Community Detection is not implemented yet")

eqc_models-0.10.0.data/platlib/eqc_models/eqcdirectsolver.py

@@ -1,61 +0,0 @@
-from typing import Dict
-import logging
-import numpy as np
-from eqc_direct.client import EqcClient
-from .base import ModelSolver
-
-log = logging.getLogger(name=__name__)
-
-class EqcDirectMixin:
-
-    ip_addr = None
-    port = None
-
-    def connect(self, ip_addr : str, port : str):
-        """ Explicitly set device address, if environment is configured with the connection, this call is not required """
-        self.ip_addr = ip_addr
-        self.port = port
-
-    @property
-    def client(self):
-    
-        params = {}
-        if self.ip_addr is not None:
-            params["ip_address"] = self.ip_addr
-        if self.port is not None:
-            params["port"] = self.port
-        return EqcClient(**params)
-
-class EqcDirectSolver(ModelSolver, EqcDirectMixin):
-
-    def solve(self, relaxation_schedule:int=2, precision : float = 1.0) -> Dict:
-        model = self.model
-        poly_coefficients, poly_indices = model.sparse
-        scval = model.encode_sum_constraint(self.levels)
-        
-        client = self.client
-        lock_id, start_ts, end_ts = client.wait_for_lock()
-        log.debug("Got device lock id %s. Wait time %f", lock_id, end_ts - start_ts)
-        resp = None
-        try:
-            log.debug("Calling device with parameters relaxation_schedule %d sum_constraint %s lock_id %s solution_precision %f",
-                      relaxation_schedule, scval, lock_id, precision)
-            resp = client.process_job(poly_coefficients=poly_coefficients,
-                                      poly_indices=poly_indices,
-                                      relaxation_schedule=relaxation_schedule,
-                                      sum_constraint = scval,
-                                      lock_id = lock_id,
-                                      solution_precision=precision)
-            log.debug("Received response with status %s", resp["err_desc"])
-            log.debug("Runtime %f resulting in energy %f", resp["runtime"], resp["energy"])
-            log.debug("Distillation runtime %s resulting in energy %f", resp["distilled_runtime"], resp["distilled_energy"])
-        finally:
-            client.release_lock(lock_id=lock_id)
-        if resp is not None:
-            solution = resp["solution"]
-            energy = resp["energy"]
-            runtime = resp["runtime"]
-            dirac3_sol = np.array(solution)
-        else:
-            raise RuntimeError("FAILED TO GET RESPONSE")
-        return resp

eqc_models-0.10.0.data/platlib/eqc_models/graph/__init__.py

@@ -1,5 +0,0 @@
-# (C) Quantum Computing Inc., 2024.
-
-from .maxcut import MaxCutModel
-
-__all__ = ["MaxCutModel"]