eqc-models 0.9.8__py3-none-any.whl

eqc_models-0.9.8.data/platlib/eqc_models/base/polyeval.pyx

@@ -0,0 +1,72 @@
+import numpy as np
+cimport numpy as cnp
+cnp.import_array()
+fDTYPE = np.float64
+ctypedef cnp.float64_t fDTYPE_t
+iDTYPE = np.int64
+ctypedef cnp.int64_t iDTYPE_t
+
+def poly_eval(coeff, indices, solution):
+    cdef int i
+    cdef int n = 0
+    cdef cnp.ndarray values
+    # assert len(solution.shape) == 2, "Solution must be 2-d array"
+    # assert len(coeff.shape) == 1, "Coefficients must be 1-d array"
+    # assert len(indices.shape) == 2, "Inidices must be 2-d array"
+    # assert indices.shape[0] == coeff.shape[0], "Indices and coefficients must have the same first dimension"
+    if len(solution.shape) == 1:
+        n = solution.shape[0]
+        solution = solution.reshape((1, n))
+    # convert the solution to floating point instead of int
+    if solution.dtype == np.int64:
+        solution = solution.astype(np.float64)
+    values = np.zeros((solution.shape[0],))
+#    print(coeff.dtype, indices.dtype, solution.dtype)
+    for i in range(solution.shape[0]):
+        values[i] = poly_eval_c(coeff, indices, solution[i])
+    return np.squeeze(values)
+
+cdef double poly_eval_c(cnp.ndarray[fDTYPE_t, ndim=1] coeff, cnp.ndarray[iDTYPE_t, ndim=2] indices,
+                             cnp.ndarray[fDTYPE_t, ndim=1] solution):
+    # verify data types
+    # assert coeff.dtype == fDTYPE
+    # assert indices.dtype == iDTYPE
+    # check some bounds for memory safety
+    # assert indices.shape[0] == coeff.shape[0]
+    if np.max(indices) > solution.shape[0]:
+        raise ValueError("indices describe different size solution than provided")
+    elif np.min(indices) < 0:
+        raise ValueError("indices includes negative values, which must all be positive")
+
+    # streamline this code
+    #   objective = 0
+    #   for i in range(len(self.coefficients)):
+    #       term = self.coefficients[i]
+    #       for j in self.indices[i]:
+    #           if j > 0:
+    #               term *= solution[j-1]
+    #       objective += term
+    #   return objective
+    #
+
+    cdef int coeff_count = coeff.shape[0]
+    cdef int degree_count = indices.shape[1]
+    cdef double term = 0
+    cdef double ttl = 0
+    cdef int i = 0
+    cdef int j = 0
+    cdef double value = 0
+
+    # initialize terms, compute 
+    for i in range(coeff_count):
+        term = coeff[i]
+        for j in range(degree_count):
+            if indices[i, j] > 0:
+                term *= solution[indices[i, j] - 1]
+        ttl += term
+
+    # collapse terms into first index and return 
+    # for i in range(1, coeff_count):
+    #     terms[0] += terms[i]
+
+    return ttl # terms[0]

eqc_models-0.9.8.data/platlib/eqc_models/base/polynomial.py

@@ -0,0 +1,274 @@
+# (C) Quantum Computing Inc., 2024.
+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.constraints import ConstraintsMixIn
+
+class PolynomialMixin:
+    """This class provides an instance method and property that
+    manage polynomial models.
+    """
+
+    @property
+    def H(self) -> Tuple[np.ndarray, np.ndarray]:
+        """ 
+        Hamiltonian specified as a polynomial : coefficients, indices 
+        
+        indices are of the format [0, idx-1, ..., idx-d] which must be non-decreasing
+        and each idx-j is a 1-based index of the variable which is a power in the 
+        term. For a polynomial where the highest degree is 3 and specifying a term 
+        such as x_1x_2, the index array is [0, 1, 2]. Another example, x_1^2x_2 is
+        [1, 1, 2].
+
+        """
+        return self.coefficients, self.indices
+    
+    @H.setter
+    def H(self, value : Tuple[np.ndarray, np.ndarray]):
+        """ Set H directly as coefficients, indices """
+
+        coefficients, indices = value
+        self.coefficients = coefficients
+        self.indices = indices
+
+    @property
+    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
+        return self.H
+    
+    def evaluate(self, solution : np.ndarray) -> float:
+        """ 
+        Evaluate polynomial at solution 
+        
+        :solution: 1-d numpy array with the same length as the number of variables
+
+        returns a floating point value
+
+        """
+
+        value = self.polynomial.evaluate(np.array(solution))
+
+        return value
+    
+    @property
+    def dynamic_range(self) -> float:
+        """
+        Dynamic range is a measure in decibels of the ratio of the largest
+        magnitude coefficient in a problem to the smallest non-zero magnitude
+        coefficient. 
+
+        The possible range of values are all greater than or equal to 0. The
+        calculation is performed by finding the lowest non-zero of the 
+        absolute value of all the coefficients, which could be empty. In that
+        case, the dynamic range is undefined, so an exception is raised. If
+        it is positive, then the maximum of the absolute values is divided
+        by the lowest. The base-10 logarithm of that value is taken and mul-
+        tiplied by 10. This is the dynamic range.
+
+        Returns
+        ----------
+        
+        float
+        
+        """
+        H = self.H
+        coefficients = np.array(H[0])
+        try:
+            lowest = np.min(np.abs(coefficients[coefficients!=0]))
+        except IndexError:
+            raise ValueError("Dynamic range of a Hamiltonian of all 0 is undefined")
+        highest  = np.max(np.abs(coefficients))
+        return 10*np.log10(highest / lowest)
+        
+class PolynomialModel(PolynomialMixin, EqcModel):
+    """
+    Polynomial model base class.
+
+    Parameters
+    ------------
+    coefficients: An array of polynomial coeffients.
+    indices: An array of polynomial indices.
+
+    Examples
+    ------------
+
+    >>> coeffs = np.array([1, 2, 3])
+    >>> indices = np.array([[0, 0, 1], [0, 1, 1], [1, 1, 1]])
+    >>> from eqc_models.base.polynomial import PolynomialModel        
+    >>> polynomial = PolynomialModel(coeffs, indices)
+    >>> solution = np.array([1, 1, 1])
+    >>> value = polynomial.evaluate(solution)
+    >>> int(value)
+    6
+    >>> polynomial.H # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    (array([1, 2, 3]), array([[0, 0, 1],
+       [0, 1, 1],
+       [1, 1, 1]]))    
+    """
+
+    def __init__(self, coefficients : Union[List, np.ndarray], indices : Union[List, np.ndarray]) -> None:
+        self.coefficients = coefficients
+        self.indices = indices
+
+    @property
+    def polynomial(self) -> Polynomial:
+        coefficients, indices = self.H
+        return Polynomial(coefficients=coefficients, indices=indices)
+    
+class ConstrainedPolynomialModel(ConstraintsMixIn, PolynomialModel):
+    """
+    Constrained Polynomial model base class.
+
+    Parameters
+    ------------
+    coefficients: An array of polynomial coeffients.
+    indices: An array of polynomial indices.
+    lhs: Left hand side of the linear constraints.
+    rhs: Right hand side of the linear constraints.
+
+    """
+
+    def __init__(self, coefficients : Union[List, np.ndarray], indices : Union[List, np.ndarray],
+                 lhs : np.ndarray, rhs: np.ndarray):
+        self.coefficients = np.array(coefficients)
+        self.indices = np.array(indices).astype(np.int64)
+        self.max_order = self.indices.shape[1]
+        self.lhs = lhs
+        self.rhs = rhs
+
+    @property
+    def penalties(self):
+        """ 
+        Penalty terms specified as a polynomial: coefficients, indices 
+        
+        indices are of the format [0, idx-1, ..., idx-d] which must be non-decreasing
+        and each idx-j is a 1-based index of the variable which is a power in the 
+        term. For a polynomial where the highest degree is 3 and specifying a term 
+        such as x_1x_2, the index array is [0, 1, 2]. Another example, x_1^2x_2 is
+        [1, 1, 2].
+
+        Only linear equality constraints are supported. Translate Ax=b into 
+        penalties using the superclass.
+        """
+
+        indices = []
+        coefficients = []
+        def lpad(index):
+            missing = self.max_order - len(index)
+            if missing > 0:
+                index = (0,) * missing + index
+            assert len(index) > 0
+            return np.array(index)
+        Pl, Pq = super(ConstrainedPolynomialModel, self).penalties
+        for i in range(Pl.shape[0]):
+            if Pl[i] != 0:
+                indices.append(lpad((0, i+1)))
+                coefficients.append(Pl[i])
+            for j in range(i, Pq.shape[1]):
+                if Pq[i, j] != 0:
+                    indices.append(lpad((i+1, j+1)))
+                    value = Pq[i, j]
+                    if i!=j:
+                        value += Pq[j, i]
+                    coefficients.append(value)
+        return coefficients, indices
+    
+    def evaluatePenalties(self, solution : np.ndarray, include_offset=False) -> float:
+        """
+        Take the polynomial form of the penalties from the penalties property
+        and evaluate the solution. The offset can be included by passing a True
+        value to the `include_offset` keyword argument.
+
+        Parameters
+        -----------
+
+        solution : np.ndarray
+            Solution to evaluate for a penalty value
+        include_offset : bool
+            Optional argument indicating whether or not to include the offset value.
+
+        Returns
+        ---------
+
+        Penalty value : float
+
+        Examples 
+        ---------
+
+        >>> coeff = np.array([-1.0, -1.0])
+        >>> indices = np.array([(0, 1), (0, 2)])
+        >>> lhs = np.array([[1.0, 1.0]])
+        >>> rhs = np.array([1.0])
+        >>> model = ConstrainedPolynomialModel(coeff, indices, lhs, rhs)
+        >>> sol = np.array([1.0, 1.0])
+        >>> lhs@sol - rhs
+        array([1.])
+        >>> model.evaluatePenalties(sol)+model.offset
+        1.0
+        >>> model.evaluatePenalties(sol)
+        0.0
+        >>> model.evaluatePenalties(sol, include_offset=True)
+        1.0
+        
+        """
+
+# get the coefficients and indices for the penalty polynomial
+# use the Polynomial operator to evaluate the solution
+        coefficients, indices = self.penalties
+        solution = np.array(solution, dtype=np.float64)
+        polynomial = Polynomial(coefficients, indices)
+        if include_offset:
+            value = self.offset
+        else:
+            value = 0
+        value += polynomial.evaluate(solution)
+        return value
+        
+    def evaluateObjective(self, solution : np.ndarray) -> float:
+        """
+        Take the polynomial coeff and indices from constructor and evalute the 
+        solution with it.
+
+        Parameters
+        -----------
+
+        solution : np.ndarray
+            Soluttion to evaluate the objective value
+
+        Returns
+        --------
+
+        objective value : float
+
+        """
+        coefficients = self.coefficients
+        indices = self.indices
+        solution = np.array(solution, dtype=np.float64)
+        polynomial = Polynomial(coefficients, indices)
+        return polynomial.evaluate(solution)
+
+    @property
+    def H(self) -> Tuple[np.ndarray, np.ndarray]:
+        """ Provide the sparse format for the Hamiltonian """
+
+        p_coeff, p_indices = self.penalties
+        coefficients, indices = self.coefficients, self.indices
+        terms = {}
+        alpha = self.alpha
+        for index, coeff in zip(p_indices, p_coeff):
+            index = tuple(index)
+            assert len(index) > 1
+            if index not in terms:
+                terms[index] = alpha * coeff
+            else:
+                terms[index] += alpha * coeff
+        for index, coeff in zip(indices, coefficients):
+            index = tuple(index)
+            if index not in terms:
+                terms[index] = coeff
+            else:
+                terms[index] += coeff
+        indices = [index for index in terms.keys()]
+        indices.sort()
+        coefficients = [terms[tuple(index)] for index in indices]
+        return coefficients, indices

eqc_models-0.9.8.data/platlib/eqc_models/base/quadratic.py

@@ -0,0 +1,250 @@
+# (C) Quantum Computing Inc., 2024.
+from typing import Tuple
+import warnings
+import numpy as np
+from eqc_models.base.base import EqcModel
+from eqc_models.base.constraints import ConstraintsMixIn
+from eqc_models.base.operators import QUBO, Polynomial
+
+
+class QuadraticMixIn:
+    """
+    This class provides an instance method and property that
+    manage quadratic models.
+
+    """
+
+    @property
+    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
+        """ 
+        Put the linear and quadratic terms in a sparse (poly) format 
+        
+        Returns
+        ----------
+        
+        coefficients: List
+        indices: List
+
+        """
+        C, J = self.H
+        C = np.squeeze(C)
+        n = self.n
+        indices = []
+        coefficients = []
+        # build a key (ordered tuple of indices) of length 2 for each element
+        for i in range(n):
+            if C[i] != 0:
+                key = (0, i+1)
+                indices.append(key)
+                coefficients.append(C[i])
+        # make J upper triangular
+        J = np.triu(J) + np.tril(J, -1).T
+        for i in range(n):
+            for j in range(i, n):
+                val = J[i, j]
+                if val != 0:
+                    key = (i+1, j+1)
+                    indices.append(key)
+                    coefficients.append(val)
+        
+        return np.array(coefficients, dtype=np.float32), np.array(indices, dtype=np.int32)
+    
+    @property
+    def polynomial(self) -> Polynomial:
+        coefficients, indices = self.sparse
+        return Polynomial(coefficients=coefficients, indices=indices)
+
+    def evaluate(self, solution: np.ndarray) -> float:
+        """ 
+        Evaluate the solution using the original operator. 
+         
+        """
+
+        sol = np.array(solution)
+        C, J = self.H
+        return np.squeeze(sol.T @ J @ sol + C.T @ sol)
+    
+    @property
+    def dynamic_range(self) -> float:
+        """
+        Dynamic range is a measure in decibels of the ratio of the largest
+        magnitude coefficient in a problem to the smallest non-zero magnitude
+        coefficient. 
+
+        The possible range of values are all greater than or equal to 0. The
+        calculation is performed by finding the lowest non-zero of the 
+        absolute value of all the coefficients, which could be empty. The
+        values are in two arrays, so the minimum and maximum values of these
+        arrays are compared to each other. When there is no non-zero in either
+        of the arrays, then an exception is raised indicating that the dynamic
+        range of an operator of all zeros is undefined. If the lowest value is 
+        positive, then the maximum of the absolute values is divided by the 
+        lowest. The base-10 logarithm of that value is taken and multiplied by 
+        10. This is the dynamic range.
+
+        Returns
+        ----------
+        
+        float
+        
+        """
+        C, J = self.H
+        # if either C or J are all 0, then set min to very large value
+        try:
+            min_c = np.min(np.abs(C[C!=0]))
+        except IndexError:
+            min_c = 1e308
+        try:
+            min_j = np.min(np.abs(J[J!=0]))
+        except IndexError:
+            min_j = 1e308
+        max_c = np.max(np.abs(C))
+        max_j = np.max(np.abs(J))
+        lowest = min_c if min_c < min_j else min_j
+        highest = max_c if max_c > max_j else max_j
+        if lowest > highest:
+            raise ValueError("Dynamic range of a Hamiltonian of all 0 is undefined")
+        return 10*np.log10(highest / lowest)
+
+    @property
+    def qubo(self) -> QUBO:
+        """
+        Transform the model into QUBO form. Use `upper_bound` to determine
+        a log-encoding of the variables.
+        
+        """
+        bin_n = 0
+        bits = []
+        # 
+        C, J = self.H
+        # 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)
+            Q.shape
+            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)
+
+class QuadraticModel(QuadraticMixIn, EqcModel):
+    """
+    Provides a quadratic operator and device sum constraint support.
+
+    Parameters
+    -----------
+
+    J: Quadratic hamiltonian array.
+    C: Linear hamiltonian array.
+
+    Examples
+    ---------
+
+    >>> C = np.array([1, 2])
+    >>> J = np.array([[2, 1], [1, 2]])
+    >>> from eqc_models.base.quadratic import QuadraticModel    
+    >>> model = QuadraticModel(C, J) 
+    >>> model.upper_bound = np.array([1, 1])
+    >>> qubo = model.qubo
+    >>> qubo.Q # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    array([[3., 1.],
+           [1., 4.]])
+
+    """
+
+    def __init__(self, C: np.ndarray, J: np.ndarray):
+        self._H = C, J
+    
+class ConstrainedQuadraticModel(ConstraintsMixIn, QuadraticModel):
+    """
+    Provides a constrained quadratic operator and device sum constraint support.
+
+    Parameters
+    -----------
+
+    J: Quadratic hamiltonian array.
+    C: Linear hamiltonian array.
+    lhs: Left hand side of the linear constraints.
+    rhs: Right hand side of the linear constraints.
+    
+    Examples
+    -------------------
+
+    >>> C = np.array([1, 2])
+    >>> J = np.array([[2, 1], [1, 2]])
+    >>> lhs = np.array([[1, 1], [1, 1]])
+    >>> rhs = np.array([1, 1])    
+    >>> from eqc_models.base.quadratic import ConstrainedQuadraticModel    
+    >>> model = ConstrainedQuadraticModel(C, J, lhs, rhs)
+    >>> model.penalty_multiplier = 1
+    >>> model.upper_bound = np.array([1, 1])
+    >>> qubo = model.qubo
+    >>> qubo.Q # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    array([[1., 3.],
+           [3., 2.]])
+
+    """
+
+    def __init__(self, C_obj: np.array, J_obj: np.array, lhs: np.array, rhs: np.array):
+        self.quad_objective = J_obj
+        self.linear_objective = C_obj
+        self.lhs = lhs
+        self.rhs = rhs
+        self._penalty_multiplier = None
+
+    @property
+    def H(self) -> Tuple[np.ndarray, np.ndarray]:
+        """ 
+        Return a pair of arrays, the linear and quadratic portions of a quadratic 
+        operator that has the objective plus penalty functions multiplied by the 
+        penalty multiplier. The linear terms are the first array and the quadratic
+        are the second.
+        
+        Returns
+        -----------
+        
+        `np.ndarray, np.nedarray` 
+        
+        """
+
+        C = self.linear_objective
+        J = self.quad_objective
+        pC, pJ = self.penalties
+        alpha = self.penalty_multiplier
+        return C + alpha * pC, J + alpha * pJ
+    
+    @ConstraintsMixIn.penalty_multiplier.setter
+    def penalty_multiplier(self, value):
+        ConstraintsMixIn.penalty_multiplier.fset(self, value)
+
+    @property
+    def constraints(self):
+        return self.lhs, self.rhs
+    
+    def evaluateObjective(self, solution: np.ndarray) -> float:
+        J = self.quad_objective
+        C = self.linear_objective
+        return np.squeeze(C.T @ solution + solution.T@J@solution)

eqc_models-0.9.8.data/platlib/eqc_models/decoding.py

@@ -0,0 +1,20 @@
+# (C) Quantum Computing Inc., 2024.
+import numpy as np
+
+# setting EPSILON to the most precise value Dirac devices can currently achieve 
+EPSILON = 0.0001
+
+class BisectionMixin:
+
+    def decode(self, solution):
+        """ Use a bisection method to determine the a binary solution from fractional values """
+        model = self.model
+
+        lower = np.min(solution)
+        upper = np.max(solution)
+
+        while upper - lower > EPSILON:
+            middle = (upper + lower) / 2
+            test_solution = (np.where(solution>=middle).astype(np.int32))
+            # test feasibility
+            # if model.is_feasible(test_solution):

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

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

eqc_models-0.9.8.data/platlib/eqc_models/graph/base.py

@@ -0,0 +1,63 @@
+# (C) Quantum Computing Inc., 2024.
+from typing import List, Set
+import networkx as nx
+from ..base import QuadraticModel
+
+class GraphModel(QuadraticModel):
+    """ """
+    def __init__(self, G : nx.Graph):
+        self.G = G
+        self.linear_objective, self.quad_objective = self.costFunction()
+
+class NodeModel(GraphModel):
+    """ 
+    Base class for a model where the decision variables correspond to
+    the graph nodes. 
+    
+    """
+
+    @property
+    def variables(self) -> List[str]:
+        """ Provide a variable name to index lookup; order enforced by sorting the list before returning """
+        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) """
+        
+        return nx.community.modularity(self.G, partition)
+
+class TwoPartitionModel(NodeModel):
+    """ 
+    Base class for a generic graph paritioning model. Override the
+    cost function and evaluation methods to implement a two-partition
+    algorithm.
+    
+    """
+
+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