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

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

@@ -2,7 +2,7 @@
 from typing import Tuple, Union, List
 import numpy as np
 from eqc_models.base.base import EqcModel
-from eqc_models.base.operators import Polynomial
+from eqc_models.base.operators import Polynomial, QUBO, OperatorNotAvailableError
 from eqc_models.base.constraints import ConstraintsMixIn
 
 class PolynomialMixin:
@@ -114,6 +114,89 @@ class PolynomialModel(PolynomialMixin, EqcModel):
     def polynomial(self) -> Polynomial:
         coefficients, indices = self.H
         return Polynomial(coefficients=coefficients, indices=indices)
+
+    @property
+    def qubo(self) -> QUBO:
+        try:
+            if np.all([len(self.polynomial.indices[i]) == 2 for i in range(len(self.polynomial.indices))]):
+                bin_n = 0
+                bits = []
+                C, J = self._quadratic_polynomial_to_qubo_coefficients(self.polynomial.coefficients,
+                                                                       self.polynomial.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]:
+                    for i in range(upper_bound.shape[0]):
+                        bits.append(1 + np.floor(np.log2(upper_bound[i])))
+                        bin_n += bits[-1]
+                    bin_n = int(bin_n)
+                    Q = np.zeros((bin_n, bin_n), dtype=np.float32)
+                    powers = [2 ** np.arange(bit_count) for bit_count in bits]
+                    blocks = []
+                    linear_blocks = []
+                    for i in range(len(powers)):
+                        # add the linear terms to the diagonal
+                        linear_blocks.append(C[i] * powers[i])
+                        row = []
+                        for j in range(len(powers)):
+                            mult = J[i, j]
+                            block = np.outer(powers[i], powers[j])
+                            block *= mult
+                            row.append(block)
+                        blocks.append(row)
+                    Q[:, :] = np.block(blocks)
+                    linear_operator = np.hstack(linear_blocks)
+                    Q += np.diag(linear_operator)
+                else:
+                    # in this case, the fomulation already has only binary variables
+                    Q = np.zeros_like(J)
+                    Q[:, :] = J
+                    Q += np.diag(np.squeeze(C))
+
+                return QUBO(Q)
+            else:
+                raise OperatorNotAvailableError("QUBO operator not available")
+        except OperatorNotAvailableError as e:
+            print(e)
+
+    def _quadratic_polynomial_to_qubo_coefficients(self, coefficients, indices, num_variables):
+        """
+        Transform polynomial into linear and quadratic qubo coefficient arrays.
+
+        Parameters
+        ----------
+        coefficients : List[float]
+            Coefficients of the polynomial terms, sorted according to the assumed format.
+        indices : List[Tuple[int, int]]
+            Sorted list of variable indices for the polynomial terms.
+        num_variables : int
+            Total number of variables in the polynomial.
+
+        Returns
+        -------
+        linear_coefficients : np.ndarray
+            1D array of linear coefficients.
+        quadratic_coefficients : np.ndarray
+            2D array of quadratic coefficients.
+        """
+        # Initialize arrays
+        linear_coefficients = np.zeros(num_variables, dtype=np.float32)
+        quadratic_coefficients = np.zeros((num_variables, num_variables), dtype=np.float32)
+
+        # Populate arrays
+        for coeff, index in zip(coefficients, indices):
+            if index[0] == 0:  # Linear term
+                linear_coefficients[index[1] - 1] += coeff
+            else:  # Quadratic term
+                i, j = index
+                if i == j:
+                    quadratic_coefficients[i - 1, j - 1] += coeff
+                elif i != j:  # Symmetric terms
+                    quadratic_coefficients[i - 1, j - 1] += coeff / 2
+                    quadratic_coefficients[j - 1, i - 1] += coeff / 2
+
+        return linear_coefficients, quadratic_coefficients
+        
     
 class ConstrainedPolynomialModel(ConstraintsMixIn, PolynomialModel):
     """

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

@@ -0,0 +1,115 @@
+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/combinatorics/setcover.py

@@ -0,0 +1,93 @@
+r"""
+SetCoverModel solves the mathematical programming problem
+
+$$
+\mathrm{minimize}_x \sum_{x_i:X_i \in X} c_i x_i
+$$
+
+Subject to
+
+$$
+\sum_{i:a\in X_i} x_j \geq 1 \, \forall a \in A}
+$$$
+
+and 
+
+$$
+x_i \in \{0, 1\} \forall {x_i: X_i \in X}
+$$
+
+Where $S$ is a set of all elements, $X$ is a collection of sets $X_i$, and the union of all is equal to $S$. 
+
+"""
+
+from typing import List
+import numpy as np
+from eqc_models.base import ConstrainedQuadraticModel
+
+class SetCoverModel(ConstrainedQuadraticModel):
+    """
+    Parameters
+    -------------
+
+    subsets : List
+        List of sets where the union of all sets is S
+
+    weights : List
+        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
+    >>> 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'}]
+
+    """
+
+    def __init__(self, subsets, weights):
+        # ensure that X is ordered
+        self.X = X = list(subsets)
+        self.S = S = set()
+
+        for x in subsets:
+            S = S.union(x)
+        # elements is sorted to maintain consistent output
+        elements = [a for a in S]
+        elements.sort()
+        # constraints 
+        A = []
+        b = []
+        variables = [f'x_{i}' for i in range(len(X))]
+        pos = 0
+        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
+            A.append(constraint + slacks)
+            pos += 1
+            b.append(1)
+        n = len(variables)
+        J = np.zeros((n, n))
+        h = np.zeros((n, ))
+        h[:len(weights)] = weights
+        # 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))])
+
+    def decode(self, solution) -> List:
+        xbar = []
+        for i in range(len(self.X)):
+            if solution[i] > 0.5:
+                xbar.append(self.X[i])
+        return xbar

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

@@ -0,0 +1,25 @@
+# (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

@@ -0,0 +1,61 @@
+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.9.8.data → eqc_models-0.10.0.data}/platlib/eqc_models/graph/base.py

@@ -7,7 +7,34 @@ class GraphModel(QuadraticModel):
     """ """
     def __init__(self, G : nx.Graph):
         self.G = G
-        self.linear_objective, self.quad_objective = self.costFunction()
+        super().__init__(*self.costFunction())
+
+    @property
+    def linear_objective(self):
+        """Return linear terms as a vector."""
+        return self._H[0]
+
+    @property
+    def quad_objective(self):
+        """Return quadratic terms as a matrix."""
+        return self._H[1]
+
+    def costFunction(self):
+        """
+        Parameters
+        -------------
+
+        None
+
+        Returns
+        --------------
+
+        :C: linear operator (vector array of coefficients) for cost function
+        :J: quadratic operator (N by N matrix array of coefficients ) for cost function
+
+        """
+        raise NotImplementedError("GraphModel does not implement costFunction")
+
 
 class NodeModel(GraphModel):
     """ 
@@ -22,22 +49,6 @@ class NodeModel(GraphModel):
         names = [node for node in self.G.nodes]
         names.sort()
         return names
-
-    def costFunction(self):
-        """ 
-        Parameters
-        -------------
-        
-        None
-        
-        Returns
-        --------------
-        
-        :C: linear operator (vector array of coefficients) for cost function
-        :J: quadratic operator (N by N matrix array of coefficients ) for cost function
-        
-        """
-        raise NotImplementedError("NodeModel does not implement costFunction")
     
     def modularity(self, partition : Set[Set]) -> float:
         """ Calculate modularity from a partition (set of communities) """

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

@@ -0,0 +1,148 @@
+from typing import Tuple
+import numpy as np
+import scipy.sparse as sp
+import networkx as nx
+from math import modf
+from eqc_models.graph.base import GraphModel
+
+
+class GraphPartitionModel(GraphModel):
+    """
+    A model for graph partitioning into `k` parts with objective and constraints
+    derived from the Laplacian matrix and additional penalties for balance and constraints.
+    """
+
+    def __init__(self, G: nx.Graph, k: int = 2, weight: str = "weight", alpha: float = 1.0, beta_obj: float = 1.0,
+                 gamma: float = 1.0):
+        """
+        Parameters:
+        -----------
+        G : nx.Graph
+            The graph to partition.
+        k : int
+            The number of partitions.
+        weight : str
+            The key for edge weights in the graph.
+        alpha : float
+            The penalty multiplier for balance constraints.
+        beta_obj : float
+            The penalty multiplier for minimizing edge cuts (Laplacian term).
+        gamma : float
+            The penalty multiplier for assignment constraints.
+        """
+        self._G = G
+        self._k = k
+        self._weight = weight
+        self._alpha = alpha
+        self._beta_obj = beta_obj
+        self._gamma = gamma
+        self._laplacian = nx.laplacian_matrix(G, weight=weight)
+        self._num_nodes = G.number_of_nodes()
+        self._sorted_nodes = sorted(G.nodes)
+        self._constraints_offset = 0
+        self._balanced_partition_offset = 0
+        self.set_and_validate_k()
+        self._objective_matrix = self.initialize_model()
+        super().__init__(self._G)
+
+    def set_and_validate_k(self):
+        """
+        Sets k and encoding length for a graph problem
+        """
+        # modf(x) = (fractional, integer) decomposition.
+        # Make sure fractional portion is zero. Convert to int if so.
+        assert modf(self._k)[0] == 0, "'k' must be an integer."
+
+        # it's an int, so set self.k
+        self._k = int(self._k)
+
+        # Verify k >= 2
+        assert self._k >= 2, f"ERROR, k={self._k}: k must be greater than or equal to 2."
+
+        # Verify that k makes sense
+        assert self._k <= self._num_nodes, (
+            f"ERROR, k={self._k}: k must be less than number of nodes or variables. k = {self._k} and "
+            f"number of nodes = {self._num_nodes}"
+        )
+
+    def initialize_model(self):
+        """
+        Build the objective matrix and constraints for the k-partition problem.
+        """
+        if self._k == 2:
+            # For 2 partitions, construct a simpler QUBO from the Laplacian matrix
+            return self.get_two_partition_qubo()
+        else:
+            # For k > 2, construct a block-diagonal Laplacian with balance and constraints
+            laplacian_blocks = 0.5 * sp.block_diag([self._laplacian] * self._k, format="csr")
+            balance_term = self.get_balanced_partition_term()
+            constraints = self.get_constraints()
+            return (
+                self._alpha * balance_term
+                + self._gamma * constraints
+                + self._beta_obj * laplacian_blocks
+            )
+
+    def get_balanced_partition_term(self) -> sp.spmatrix:
+        """
+        Construct the quadratic penalty term for balanced partitions.
+        """
+        I_k = sp.identity(self._k)
+        Ones_n = np.ones((self._num_nodes, self._num_nodes))
+        balanced_partition_term = sp.kron(I_k, Ones_n, format="csr")
+        balanced_partition_term -= (
+            2 * self._num_nodes / self._k * sp.identity(balanced_partition_term.shape[0])
+        )
+        self._balanced_partition_offset = self._num_nodes**2 / self._k
+        return balanced_partition_term
+
+    def get_constraints(self) -> sp.spmatrix:
+        """
+        Construct the quadratic penalty term for assignment constraints.
+        """
+        I_n = sp.identity(self._num_nodes)
+        Ones_k = np.ones((self._k, self._k))
+        constraints = sp.kron(Ones_k, I_n, format="csr")
+        constraints -= 2 * sp.identity(constraints.shape[0])
+        self._constraints_offset = self._num_nodes
+        return constraints
+
+    def get_two_partition_qubo(self) -> sp.spmatrix:
+        """
+        Construct the QUBO matrix for two partitions using adjacency and penalties.
+        """
+        Garr = nx.to_scipy_sparse_matrix(self._G, weight=self._weight, nodelist=self._sorted_nodes)
+        Q = (
+            self._alpha * np.ones(Garr.shape, dtype=np.float32)
+            - self._beta_obj * Garr
+        )
+        degrees = Garr.sum(axis=1).A1  # Convert sparse matrix to 1D array
+        diag = self._beta_obj * degrees - self._alpha * (self._num_nodes - 1)
+        np.fill_diagonal(Q, diag)
+        return sp.csr_matrix(Q)
+
+    def evaluate(self, solution: np.ndarray) -> float:
+        """
+        Evaluate the objective function for a given solution.
+        """
+        assert len(solution) == self._objective_matrix.shape[0], "Solution size mismatch."
+        return float(solution.T @ self._objective_matrix @ solution)
+
+    def decode(self, solution: np.ndarray) -> dict:
+        """
+        Decode the solution vector into a partition assignment.
+        """
+        if self._k == 2:
+            return {node: int(solution[i]) for i, node in enumerate(self._sorted_nodes)}
+        else:
+            partitions, nodes = np.where(solution.reshape((self._k, self._num_nodes)) == 1)
+            return {self._sorted_nodes[node]: int(partition) for partition, node in zip(partitions, nodes)}
+
+    def costFunction(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        Return the linear and quadratic components of the objective function.
+        """
+        Q = self._objective_matrix
+        h = Q.diagonal()
+        J = 2 * sp.triu(Q, k=1).tocsr() # Extract upper triangular part for quadratic terms
+        return h, J

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

@@ -0,0 +1,28 @@
+from typing import List
+import networkx as nx
+from .quadraticmodel import QuadraticModel
+
+class GraphModel(QuadraticModel):
+
+    def __init__(self, G : nx.Graph):
+        self.G = G
+
+class TwoPartitionModel(GraphModel):
+    """ Create a model where the variables are node-based """
+
+    @property
+    def variables(self) -> List[str]:
+        """ Provide a variable name to index lookup, order enforced by sorting the list before returning """
+        names = [node.name for node in self.G.nodes]
+        names.sort()
+        return names
+    
+class EdgeModel(GraphModel):
+    """ Create a model where the variables are edge-based """
+
+    @property
+    def variables(self) -> List[str]:
+        """ Provide a variable name to index lookup, order enforced by sorting the list before returning """
+        names = [f"({u},{v})" for u, v in self.G.edges]
+        names.sort()
+        return names