eqc-models 0.10.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

eqc_models-0.10.1.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.1.data/platlib/eqc_models/combinatorics/__init__.py

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

eqc_models-0.10.1.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.1.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.1.data/platlib/eqc_models/graphs.py

@@ -1,28 +0,0 @@
-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

eqc_models-0.10.1.data/platlib/eqc_models/maxcut.py

@@ -1,113 +0,0 @@
-import networkx as nx
-import numpy as np
-from .graphs import TwoPartitionModel
-
-class MaxCutModel(TwoPartitionModel):
-
-    def build(self):
-        variables = self.variables
-        n = len(variables)
-        self.domains = np.ones((n,))
-        
-        J = np.zeros((n+1, n+1), dtype=np.float32)
-        h = np.zeros((n+1,1), dtype=np.float32)
-        for u, v in G.edges:
-            J[u, v] += 1
-            J[v, u] += 1
-            J[u, u] = 1
-            J[v, v] = 1
-            h[u] -= 1
-            h[v] -= 1
-        J *= 1/t**2
-        h *= 1/t
-        H = np.hstack([h, J])
-        return H
-
-    @property
-    def J(self) -> np.ndarray:
-        if getattr(self, "_J", None) is None:
-            self.build()
-        return self._J
-
-    @property
-    def C(self) -> np.ndarray:
-        if getattr(self, "C", None) is None:
-            self.build()
-        return self._C
-    
-def get_graph(n, d):
-    """ Produce a repeatable graph with parameters n and d """
-
-    seed = n * d
-    return nx.random_graphs.random_regular_graph(d, n, seed)
-
-def get_partition_graph(G, solution):
-    """
-    Build the partitioned graph, counting cut size 
-
-    :parameters: G : nx.DiGraph, solution : np.ndarray
-    :returns: nx.DiGraph, int
-    
-    """
-
-    cut_size = 0
-    Gprime = nx.DiGraph()
-    Gprime.add_nodes_from(G.nodes)
-    for i, j in G.edges:
-        if solution[i] != solution[j]:
-            cut_size+=1
-        else:
-            Gprime.add_edge(i, j)
-    return Gprime, cut_size
-
-def determine_solution(G, solution):
-    """
-    Use a simple bisection method to determine the binary solution. Uses
-    the cut size as the metric.
-
-    Returns the partitioned graph and solution.
-
-    :parameters: G : nx.DiGraph, solution : np.ndarray
-    :returns: nx.DiGraph, np.ndarray
-
-    """
-
-    solution = np.array(solution)
-    lower = np.min(solution)
-    upper = np.max(solution)
-    best_cut_size = 0
-    best_graph = G
-    best_solution = None
-    while upper > lower + 0.0001:
-        middle = (lower + upper) / 2
-        test_solution = (solution>=middle).astype(np.int32)
-        Gprime, cut_size = get_partition_graph(G, test_solution)
-        if cut_size > best_cut_size:
-            best_cut_size = cut_size
-            lower = middle
-            best_solution = test_solution
-            best_graph = Gprime
-        else:
-            upper = middle
-    return best_graph, best_solution
-
-def get_maxcut_H(G, t):
-    """ 
-    Return a Hamiltonian representing the Maximum Cut Problem. Scale the problem using `t`.
-    Automatically adds a slack qudit.
-    
-    """
-    n = len(G.nodes)
-    J = np.zeros((n+1, n+1), dtype=np.float32)
-    h = np.zeros((n+1,1), dtype=np.float32)
-    for u, v in G.edges:
-        J[u, v] += 1
-        J[v, u] += 1
-        J[u, u] = 1
-        J[v, v] = 1
-        h[u] -= 1
-        h[v] -= 1
-    J *= 1/t**2
-    h *= 1/t
-    H = np.hstack([h, J])
-    return H

eqc_models-0.10.1.data/platlib/eqc_models/maxkcut.py

@@ -1,185 +0,0 @@
-import numpy as np
-import networkx as nx
-from .quadraticmodel import QuadraticModel
-
-
-class MaxKCut(QuadraticModel):
-
-    def __init__(self, G : nx.Graph, k : int):
-        self.G = G
-        self.node_map = list(G.nodes)
-        self.k = k
-        self.partitions = []
-        self._lhs = None
-        self._rhs = None
-        self._objective = None
-        self._J = None
-        self._C = None
-
-    def decode(self, solution: np.ndarray) -> np.ndarray:
-        """ Override the default decoding to use a the max cut metric to determine a solution """
-
-        # only one partition per node can be selected
-        # 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.node_map):
-            idx = slice(k*i, k*(i+1))
-            spins = solution[idx]
-            mx = np.max(spins)
-            for j in range(k):
-                if spins[j] == mx:
-                    decoded_solution[k*i+j] = 1
-                    break
-        return decoded_solution
-    
-    def partition(self, solution):
-        """ Return a dictionary with the partition number of each node """
-        k = self.k
-        n = len(self.node_map)
-        partition_num = {}
-        for i, u in enumerate(self.node_map):
-            for j in range(k):
-                if solution[i*k+j] == 1:
-                    partition_num[u] = j+1
-        return partition_num
-    
-    def getCutSize(self, partition):
-        cut_size = 0
-        for u, v in self.G.edges:
-            if partition[u]!=partition[v]:
-                cut_size += 1
-        return cut_size
-
-    def _build_objective(self):
-        
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        # construct the quadratic portion of the objective
-        # the linear portion is 0
-        objective = np.zeros((n, n), dtype=np.float32)
-        # increment the joint variable terms indicating the nodes are in different sets
-        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
-        for u, v in G.edges:
-            i = node_map.index(u)
-            j = node_map.index(v)
-            ibase = i * self.k
-            jbase = j * self.k
-            for incr1, incr2 in pairs:
-                idx1 = ibase + incr1
-                idx2 = jbase + incr2
-                objective[idx1, idx2] += -1
-        self._objective = (np.zeros((n, 1)), objective)
-
-    def _build_constraints(self):
-
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-
-        # build the constraints
-        A = np.zeros((m, n))
-        b = np.ones((m,))
-        for u in G.nodes:
-            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.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        self.domains = 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
-
-    @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 WeightedMaxKCut(MaxKCut):
-
-    def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
-        super().__init__(G, k)
-
-        self.weight_label = weight_label
-    
-    def _build_objective(self):
-        
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        # construct the quadratic portion of the objective
-        # the linear portion is 0
-        objective = np.zeros((n, n), dtype=np.float32)
-        # increment the joint variable terms indicating the nodes are in different sets
-        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
-        for u, v in G.edges:
-            i = node_map.index(u)
-            j = node_map.index(v)
-            ibase = i * self.k
-            jbase = j * self.k
-            for incr1, incr2 in pairs:
-                idx1 = ibase + incr1
-                idx2 = jbase + incr2
-                objective[idx1, idx2] += G[u][v][self.weight_label]
-        self._objective = (np.zeros((n, 1)), objective)
-
-    def getCutSize(self, partition):
-        cut_size = 0
-        for u, v in self.G.edges:
-            if partition[u]!=partition[v]:
-                cut_size += self.G[u][v][self.weight_label]
-        return cut_size

eqc_models-0.10.1.data/platlib/eqc_models/quadraticmodel.py

@@ -1,131 +0,0 @@
-from typing import Tuple
-import numpy as np
-from .base import EqcModel
-
-class QuadraticMixIn:
-    C = None
-    J = None
-
-    def encode(self, levels:int=200, norm_value:float=None, dtype=np.float32) -> np.ndarray:
-        """ 
-        Encode Hamiltonian into the domain of the device 
-
-        The encoding method can be tuned using levels or norm_value. The parameter 
-        levels and the member self.domains are used to generate a vector t such that
-        $$
-        x = ts
-        $$
-        thus,
-        $$
-        h^Tx + x^TJx = h^T(ts) + (ts)^TJ(ts) = (th)^Ts + s^T(t\\cross tJ)s
-        $$
-        
-        """
-
-        n = max(self.domains.shape)
-        J = self.J
-        C = self.C
-        if norm_value is None:
-            max_level = levels - 1
-            multipliers = (self.domains) / max_level
-            J = np.array(np.outer(multipliers, multipliers) * J)
-            # h = np.multiply(h[:,0], multipliers)
-            C *= multipliers
-            C = C.reshape((n, 1))
-        else:
-            # normalize the operator
-            max_val_J = np.max(np.abs(J))
-            max_val_C = np.max(np.abs(C))
-            if max_val_J > max_val_C:
-                max_val = max_val_J
-            else:
-                max_val = max_val_C
-            C /= max_val
-            C *= norm_value
-            J /= max_val
-            J *= norm_value
-        # make J symmetric
-        J += J.T
-        J /= 2
-        # return operator in hJ format
-        H = np.hstack([C, J]).astype(dtype)
-
-        if self.machine_slacks > 0:
-            machine_slacks = self.machine_slacks
-            n = H.shape[0]
-            Hslack = np.zeros((n+machine_slacks, n+machine_slacks+1), dtype=dtype)
-            Hslack[:n, :n+1] = H
-            H = Hslack
-    
-        return np.array(H)
-        
-    @property
-    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
-        """ Put the linear and quadratic terms in a sparse format 
-        
-        :returns: coefficients : List, indices : List
-        """
-        C, J = self.H
-        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] != 0:
-                key = (0, i+1)
-                indices.append(key)
-                coefficients.append(C[i,0])
-        # 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)
-    
-    def evaluate(self, solution: np.ndarray, decode:bool=False, levels:int=200) -> float:
-        """ 
-        Evaluate the solution using the original operator. The decode
-        and levels parameters control the decoding of the solution. Without
-        specifying decode, the evaluation of the operator is done with the
-        solution provided.
-         
-        """
-        H = self.H
-        h, J = H[:, 0], H[:, 1:]
-        if decode:
-            sol = self.decode(solution)
-        else:
-            sol = solution
-        return np.squeeze(sol.T@J@sol + h.T@sol)
-
-class QuadraticModel(QuadraticMixIn, EqcModel):
-    """ Provides a quadratic operator and device sum constraint support """
-
-    def __init__(self, C : np.ndarray, J : np.ndarray, sum_constraint : float):
-        self._C = C
-        self._J = J
-        self._sum_constraint = sum_constraint
-    
-    @property
-    def H(self):
-        return self._C, self._J
-    
-    def check_constraint(self, solution: np.array) -> bool:
-        """ Evaluate the solution against the original sum constraint """
-        return np.sum(solution) == self.sum_constraint
-    
-    @property
-    def sum_constraint(self) -> int:
-        """ Integer value which all qudits must sum to.
-        The value must be less than or equal to  n * base for
-        the model to make sense. """
-
-        return self._sum_constraint
-
-    @sum_constraint.setter
-    def sum_constraint(self, value : int):
-        self._sum_constraint = value