eqc-models 0.9.8__py3-none-any.whl

eqc_models-0.9.8.data/platlib/compile_extensions.py

@@ -0,0 +1,23 @@
+from setuptools import Extension
+from setuptools.command.build_py import build_py as _build_py
+import numpy
+
+# Modules to be compiled and include_dirs when necessary
+extensions = [
+    Extension(
+        "eqc_models.base.polyeval",
+        ["eqc_models/base/polyeval.pyx"], include_dirs=[numpy.get_include()],
+    ),
+]
+
+class build_py(_build_py):
+    def run(self):
+        self.run_command("build_ext")
+        return super().run()
+
+    def initialize_options(self):
+        super().initialize_options()
+        if self.distribution.ext_modules == None:
+            self.distribution.ext_modules = []
+
+        self.distribution.ext_modules.extend(extensions)

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

@@ -0,0 +1,15 @@
+# (C) Quantum Computing Inc., 2024.
+"""
+eqc-models package for high-level optimization modeling for EQC and other devices
+
+"""
+
+from .base import QuadraticModel, PolynomialModel
+from .solvers import (Dirac1CloudSolver, Dirac3CloudSolver, Dirac3DirectSolver)
+from .allocation import AllocationModel, AllocationModelX, ResourceRuleEnum
+from .assignment import QAPModel
+
+__all__ = ["QuadraticModel", "PolynomialModel", "Dirac1CloudSolver", 
+           "Dirac3CloudSolver", "AllocationModel", "AllocationModelX",
+           "Dirac3DirectSolver", "ResourceRuleEnum",
+           "QAPModel"]

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

@@ -0,0 +1,4 @@
+# (C) Quantum Computing Inc., 2024.
+from .penaltymultiplier import PenaltyMultiplierAlgorithm
+
+__all__ = ["PenaltyMultiplierAlgorithm"]

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

@@ -0,0 +1,10 @@
+# (C) Quantum Computing Inc., 2024.
+
+class Algorithm:
+
+    def __init__(self, model, solver):
+        self.model = model
+        self.solver = solver
+
+    def run(self, *args, **kwargs):
+        return {}

eqc_models-0.9.8.data/platlib/eqc_models/algorithms/penaltymultiplier.py

@@ -0,0 +1,169 @@
+# (C) Quantum Computing Inc., 2024.
+from typing import Union
+import logging
+import numpy as np
+from eqc_models.base.constraints import ConstraintModel
+from eqc_models.base.base import ModelSolver
+from eqc_models.algorithms.base import Algorithm
+
+log = logging.getLogger(name=__name__)
+
+class PenaltyMultiplierAlgorithm(Algorithm):
+    """
+    Parameters
+    ----------
+
+    model : ConstraintModel
+        Instance of a model to search out a penalty multiplier value, must be constrained model.
+    solver : ModelSolver subclass
+        Instance of a solver class to use to run the algorithm.
+
+
+    Properties
+    ----------
+
+    upper_bound : float
+        Upper bound value for the objective function, this need not be a least upper bound, 
+        but the tighter the value, the more efficient the search
+
+    solutions : List
+        The solutions found during the algorithm run
+    alphas : List
+        The values of multiplier found at each algorithm iteration
+    penalties : List
+        The values for penalties found at each algorithm iteration. A penalty of 0
+        indicates algorithm termination.
+    dynamic_range : List
+        The values for the dynamic range of the unconstrained problem formulation,
+        which is useful for identifying difficulty in representation of the problem
+        on the analog device.
+
+    The penalty multiplier search algorithm uses an infeasible solution to select the next 
+    value for the penalty multiplier. The algorithm depends upon good solutions and only
+    guarantees termination when the solution found for a given multiplier is optimal. For
+    this reason, the implementation will terminate when no progress is made, thus making
+    it a heuristic. Providing an exact solver for the solver instance will guarantee that 
+    the algorithm is correct and the penalty mulktiplier found is the minimal multiplier
+    capable of enforcing the condition that an unconstrained objective value for a feasible
+    solution is less than an unconstrained objective value for an infeasible solution.
+
+    This example uses the quadratic assignment problem and the known multiplier to test 
+    the implementation of the algorithm.
+
+    >>> from eqc_models.solvers.qciclient import Dirac3CloudSolver
+    >>> from eqc_models.assignment.qap import QAPModel
+    >>> A = np.array([[0, 5, 8, 0, 1],
+    ...               [0, 0, 0, 10, 15],
+    ...               [0, 0, 0, 13, 18],
+    ...               [0, 0, 0, 0, 0.],
+    ...               [0, 0, 0, 1, 0.]])
+    >>> B = np.array([[0, 8.54, 6.4, 10, 8.94],
+    ...               [8.54, 0, 4.47, 5.39, 6.49],
+    ...               [6.4, 4.47, 0, 3.61, 3.0],
+    ...               [10, 5.39, 3.61, 0, 2.0],
+    ...               [8.94, 6.49, 3.0, 2.0, 0.]])
+    >>> C = np.array([[2, 3, 6, 3, 7],
+    ...               [3, 9, 2, 5, 9],
+    ...               [2, 6, 4, 1, 2],
+    ...               [7, 5, 8, 5, 7],
+    ...               [1, 9, 2, 9, 2.]])
+    >>> model = QAPModel(A, B, C)
+    >>> solver = Dirac3CloudSolver() # must be configured with environment variables
+    >>> algo = PenaltyMultiplierAlgorithm(model, solver)
+    >>> algo.upper_bound = 330.64
+    >>> algo.run(relaxation_schedule=2, mean_photon_number=0.15, normalized_loss_rate=4, num_samples=5) # doctest: +ELLIPSIS
+    2... RUNNING... COMPLETED...
+    >>> algo.alphas[-1] # doctest: +SKIP
+    106.25
+    >>> algo.penalties[-1] # doctest: +SKIP
+    0.0
+ 
+    """
+
+    def __init__(self, model : ConstraintModel, solver : ModelSolver):
+        self.model = model
+        self.solver = solver
+        # ub = np.max(model.quad_objective)
+        # if ub < np.max(model.linear_objective):
+        #     ub = np.max(model.linear_objective)
+        #     ub *= model.sum_constraint
+        # else:
+        #     ub *= model.sum_constraint ** 2
+        self.ub = None # ub
+        self.solutions = None
+        self.penalties = None
+        self.alphas = None
+        self.dynamic_range = None
+        self.responses = None
+
+    @property
+    def upper_bound(self) -> float:
+        return self.ub
+
+    @upper_bound.setter
+    def upper_bound(self, value : float):
+        self.ub = value
+
+    def run(self, initial_alpha : float=None, initial_solution : np.array = None, **kwargs):
+        """ Start with a guess at alpha, iterate until alpha is sufficiently large """
+
+        self.solutions = solutions = []
+        self.penalties = penalties = []
+        self.alphas = alphas = []
+        self.dynamic_range = dynamic_range = []
+        self.responses = responses = []
+        self.energies = energies = []
+
+        model = self.model
+        solver = self.solver
+        offset = model.offset
+        ub = self.ub
+        if initial_alpha is None and offset > 0:
+            alpha = ub / offset
+            log.info("UPPER BOUND %f OFFSET %f  -> ALPHA %f", 
+                     ub, offset, alpha)
+            if alpha < 1:
+                alpha = 1
+        elif initial_alpha is not None:
+            alpha = initial_alpha
+        else:
+            log.info("No tricks for initial alpha, setting to 1")
+            alpha = 1
+
+        if initial_solution is not None:
+            log.debug("INITIAL SOLUTION GIVEN")
+            obj_val = model.evaluate(initial_solution, alpha, True)
+            penalty = model.evaluatePenalties(initial_solution) + offset
+            log.info("INITIAL SOLUTION OBJECTIVE %f PENALTY %f", obj_val, penalty)
+            if obj_val < ub:
+                alpha += (ub - obj_val) / penalty
+            log.info("INITIAL SOLUTION DETERMINED ALPHA %f", alpha)
+        else:
+            penalty = None
+            
+        while penalty is None or penalty > 1e-6:
+            log.info("NEW RUN")
+            log.info("SETTING MULTIPLIER %f", alpha)
+            model.penalty_multiplier = float(alpha)
+            log.info("GOT MULTIPLIER %f NEW OFFSET %f", model.penalty_multiplier, 
+                     model.penalty_multiplier * model.offset)
+            dynamic_range.append(float(model.dynamic_range))
+            log.info("CALLING SOLVE WITH ALPHA %f DYNAMIC RANGE %f", alpha, dynamic_range[-1])
+            alphas.append(float(alpha))
+            response = solver.solve(model, **kwargs)
+            responses.append(response)
+            results = response["results"]
+            solution = np.array(results["solutions"][0])
+            solutions.append(solution)
+            penalty = model.evaluatePenalties(solution) + offset
+            penalties.append(float(penalty))
+            obj_val = model.evaluate(solution, alpha, True)
+            less_offset = model.evaluate(solution, alpha, False)
+            energies.append(results["energies"][0])
+            log.info("NEW SOLUTION OBJECTIVE %f LESS OFFSET %f ENERGY %f PENALTY %f", 
+                     obj_val, less_offset, energies[-1], penalty)
+            if obj_val < ub:
+                alpha += (ub - obj_val) / penalty
+            if abs(sum(penalties[-2:])/2-penalty) < 1e-4:
+                log.warn("SUFFICIENT PROGRESS NOT MADE FOR THREE ITERATIONS, QUITTING")
+                break

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

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .allocation import AllocationModel, AllocationModelX, ResourceRuleEnum
+from .portmomentum import PortMomentum
+
+__all__ = ["AllocationModel", "AllocationModelX", "PortMomentum", "ResourceRuleEnum"]

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

@@ -0,0 +1,367 @@
+# (C) Quantum Computing Inc., 2024.
+from typing import List, Tuple
+from enum import Enum
+import numpy as np
+from eqc_models.base.constraints import InequalitiesMixin
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
+
+
+class AllocationModel(ConstrainedQuadraticModel):
+    """
+    Parameters
+    ----------
+
+    resources: List 
+        names of available resources.
+    tasks: List
+        names of tasks.
+    resource_usage: List of Lists or 2D np.ndarray 
+        rows represent tasks and columns represent resources,
+        specifying the amount of each resource required per task.
+    resource_limits: 1D array or List
+        specifying the limit on each resource.
+    cost_per_task: 1D array List
+        specifying the cost per task (or benefit with negative of value).
+
+
+    Attributes
+    ----------
+
+    penalty_multiplier: float
+        value for weighting the penalties formed from the equality constraints
+
+    qubo: eqc_models.base.operators.QUBO
+        QUBO operator representation
+
+    polynomial: eqc_models.base.operators.Polynomial
+        Polynomial operator representation
+
+
+    This class represents a resource allocation model for maximizing total benefit. In other words,
+    Given a list of resources and a list of tasks, allocate the resources among the tasks so as to 
+    maximize the economic benefit.
+
+    Here's an example. Five tasks must share 4 resources. Each task can use a different amount of
+    each resource. 
+
+    +--------------------+------+------+---------+---------+---------+
+    |                    | Spam | Eggs | Coconut | Sparrow | Benefit |
+    +--------------------+------+------+---------+---------+---------+
+    | Breakfast          | 1    | 2    | 0       | 0       | 3       | 
+    +--------------------+------+------+---------+---------+---------+
+    | Countryside Stroll | 0    | 0    | 1       | 0       | 1       |
+    +--------------------+------+------+---------+---------+---------+
+    | Storm Castle       | 0    | 12   | 1       | 1       | 10      | 
+    +--------------------+------+------+---------+---------+---------+
+    | Availability       | 1    | 12   | 2       | 1       |         |
+    +--------------------+------+------+---------+---------+---------+
+
+    >>> resources = ["Spam", "Eggs", "Coconut", "Sparrow"]
+    >>> tasks = ["Breakfast", "Countryside Stroll", "Storm Castle"]
+    >>> resource_usage = [[1, 2, 0, 0], [0, 0, 1, 0], [0, 12, 1, 1]]
+    >>> resource_limits = [1, 12, 2, 1]
+    >>> cost_per_task = [-3, -1, -10.] 
+    >>> allocation_model = AllocationModel(resources, tasks, resource_usage, resource_limits, cost_per_task)
+    >>> allocation_model.penalty_multiplier = 1
+    >>> C, J = allocation_model.H 
+    >>> C # -3 -2 * (12 * 2 + 1 * 1), -1 -2 * 2*1, -10 -2 * (12 * 12 + 1 * 2 + 1 * 1) 
+    ...   # doctest: +NORMALIZE_WHITESPACE
+    array([ -53., -5.,     -304.])
+    >>> J # doctest: +NORMALIZE_WHITESPACE
+    array([[ 5., 0., 24.],
+           [ 0., 1.,  1.],
+           [ 24., 1., 146.]])
+
+    """
+
+    def __init__(self, resources: List, tasks: List, resource_usage: List, resource_limits: List,
+                 cost_per_task: List):
+        if not isinstance(resources, list):
+            raise TypeError("Argument 'resources' must be a list")
+        if not isinstance(tasks, list):
+            raise TypeError("Argument 'tasks' must be a list")
+        if not isinstance(resource_usage, list):
+            raise TypeError("Argument 'resource_usage' must be a list")
+        if not isinstance(resource_limits, list):
+            raise TypeError("Argument 'resource_limits' must be a list")
+        if not isinstance(cost_per_task, list):
+            raise TypeError("Argument 'cost_per_task' must be a list")
+        # PARENT CLASS MUST HAVE TYPE CHECK
+        self.resources = resources
+        self.tasks = tasks
+        self.resource_usage = np.array(resource_usage)
+        self.resource_limits = np.array(resource_limits)
+        self.cost_per_task = np.array(cost_per_task)
+        super(AllocationModel, self).__init__(self.cost_per_task, np.zeros((len(self.tasks), len(self.tasks))), self.resource_usage.T, self.resource_limits)
+        # self.domains = np.array([np.floor(max(self.resource_limits[self.resource_limits != 0]) /
+        #                          min(self.resource_usage[self.resource_usage != 0]))] * len(self.tasks), dtype=int)
+        # self.upper_bound = [np.floor(max(self.resource_limits[self.resource_limits != 0]) /
+        #                          min(self.resource_usage[self.resource_usage != 0]))] * len(self.tasks)
+        self._validate_dimensions()
+        ### NEED TO MAKE SURE BASE CLASS VALIDATES self.upper_bound ###
+
+    @property
+    def upper_bound(self) -> np.array:
+        return np.array([np.floor(max(self.resource_limits[self.resource_limits != 0]) /
+                                  min(self.resource_usage[self.resource_usage != 0]))] * len(self.tasks), dtype=int)
+
+    @upper_bound.setter
+    def upper_bound(self, value: List):
+        self._upper_bound = value
+
+    @property
+    def variables(self):
+        return [(i, j) for i in self.tasks for j in self.resources]
+
+    def _validate_dimensions(self):
+        """Raises ValueErrors for inconsistent dimensions."""
+
+        # Check resource_usage dimensions
+        num_tasks = len(self.tasks)
+        num_resources = len(self.resources)
+        # print("RESOURCES", num_resources)
+        # print("TASKS", num_tasks)
+        # print(self.resource_usage.shape)
+        if self.resource_usage.shape != (num_tasks, num_resources):
+            raise ValueError("resource_usage matrix dimensions don't match number of tasks and resources")
+
+        # Check resource_limits length
+        if self.resource_limits.shape[0] != num_resources:
+            raise ValueError("resource_limits length doesn't match number of resources")
+
+        # Check cost_per_task length
+        if self.cost_per_task.shape[0] != num_tasks:
+            raise ValueError("cost_per_task length doesn't match number of tasks")
+
+    def add_task(self, task: str, task_resource_usage: List, task_cost: float):
+        """ 
+        task: str
+            Name of task to add
+        task_resource_usage: List
+            Quantity of resource used for task for all tasks
+        task_cost: float
+            Quantity indicating the cost or benefit (negative) of the task
+        
+        Add a task to the problem, modifying the resource usage and task cost arrays.
+
+        """
+        self.tasks += [task]
+        self.resource_usage = np.vstack([self.resource_usage, task_resource_usage])
+        self.cost_per_task = np.append(self.cost_per_task, task_cost)
+
+    @property
+    def H(self) -> Tuple[np.ndarray,np.ndarray]:
+        """ Return linear, quadratic portions of the (quadratic) Hamiltonian """
+        Pl, Pq = self.penalties
+        alpha = self.penalty_multiplier
+        obj_linear, obj_quad = self.linear_objective, self.quad_objective #self._linear_objective(), self._quadratic_objective()
+        self._C = obj_linear + alpha * Pl
+        self._J = obj_quad + alpha * Pq
+
+        return obj_linear + alpha * Pl, obj_quad + alpha * Pq
+
+
+class ResourceRuleEnum(Enum):
+    """ 
+    Enumeration of the allowed resource rules, mapping to the mathematical expression:
+
+    MAXIMUM -> LE (less than or equal to)
+    MINIMUM -> GE (greater than or equal to)
+    EXACT -> EQ (equal to)
+
+    """
+    MAXIMUM = "LE"
+    MINIMUM = "GE"
+    EXACT = "EQ"
+
+class AllocationModelX(InequalitiesMixin, AllocationModel):
+    """ 
+    Parameters
+    ----------
+
+    resources: List 
+        names of available resources.
+    tasks: List
+        names of tasks.
+    resource_usage: List of Lists or 2D np.ndarray 
+        rows represent tasks and columns represent resources,
+        specifying the amount of each resource required per task.
+    resource_limits: 1D array or List
+        specifying the limit on each resource.
+    resource_rule: List
+        ResourceRuleEnum values for each resource
+    cost_per_task: 1D array List
+        specifying the cost per task (or benefit with negative of value).
+
+
+    Attributes
+    ----------
+
+    penalty_multiplier: float
+        value for weighting the penalties formed from the equality constraints
+
+    qubo: eqc_models.base.operators.QUBO
+        QUBO oeprator representation
+
+    polynomial: eqc_models.base.operators.Polynomial
+        Polynomial operator representation
+
+    variables: List
+        names of variables formed from tasks and assignments
+
+
+    This class represents a resource allocation model for maximizing total benefit. In other words,
+    Given a list of resources and a list of tasks, allocate the resources among the tasks so as to 
+    maximize the economic benefit.
+
+    Adds resource_rule as an argument. This must be a list of strings specifying
+    constraints for each resource (LE, GE, or EQ).
+
+    Here's an example. Five tasks must share 4 resources. Each task can use a different amount of
+    each resource. 
+
+    +--------------------+------+------+---------+---------+---------+
+    |                    | Spam | Eggs | Coconut | Sparrow | Benefit |
+    +--------------------+------+------+---------+---------+---------+
+    | Breakfast          | 1    | 2    | 0       | 0       | 3       | 
+    +--------------------+------+------+---------+---------+---------+
+    | Countryside Stroll | 0    | 0    | 1       | 0       | 1       |
+    +--------------------+------+------+---------+---------+---------+
+    | Storm Castle       | 0    | 12   | 1       | 1       | 10      | 
+    +--------------------+------+------+---------+---------+---------+
+    | Availability       | 1    | 12   | 2       | 1       |         |
+    +--------------------+------+------+---------+---------+---------+
+
+    >>> resources = ["Spam", "Eggs", "Coconut", "Sparrow"]
+    >>> tasks = ["Breakfast", "Countryside Stroll", "Storm Castle"]
+    >>> resource_usage = [[1, 2, 0, 0], [0, 0, 1, 0], [0, 12, 1, 1]]
+    >>> resource_limits = [1, 12, 2, 1]
+    >>> cost_per_task = [-3, -1, -10.] 
+    >>> resource_rules = [ResourceRuleEnum.MAXIMUM for i in range(len(resources))]
+    >>> allocation_model = AllocationModelX(resources, tasks, resource_usage, resource_limits, resource_rules, cost_per_task)
+    >>> allocation_model.penalty_multiplier = 1
+    >>> C, J = allocation_model.H 
+    >>> C # -3 -2 * (12 * 2 + 1 * 1), -1 -2 * 2*1, -10 -2 * (12 * 12 + 1 * 2 + 1 * 1) 
+    ...   # doctest: +NORMALIZE_WHITESPACE
+    array([ -53., -5., -304., -2., -24., -4., -2.])
+    >>> J # doctest: +NORMALIZE_WHITESPACE
+    array([[  5.,  0.,  24., 1.,  2., 0., 0.],
+           [  0.,  1.,   1., 0.,  0., 1., 0.],
+           [ 24.,  1., 146., 0., 12., 1., 1.],
+           [  1.,  0.,   0., 1.,  0., 0., 0.], 
+           [  2.,  0.,  12., 0.,  1., 0., 0.], 
+           [  0.,  1.,   1., 0.,  0., 1., 0.],
+           [  0.,  0.,   1., 0.,  0., 0., 1.]])
+    """
+    def __init__(self, resources: List, tasks: List, resource_usage: List, resource_limits: List,
+                 resource_rule: List[ResourceRuleEnum], cost_per_task: List):
+        super().__init__(resources, tasks, resource_usage, resource_limits, cost_per_task)
+
+        if not isinstance(resource_rule, list):
+            raise TypeError("Argument 'resource_rule' must be a list")
+        elif len(resource_rule) != len(resources):
+            raise ValueError("Argument 'resource_rule' must be the same length as 'resources'")
+
+        try:
+            check_rule = set([rule.value for rule in resource_rule])
+            if not check_rule.issubset({"LE", "GE", "EQ"}):
+                raise ValueError("Argument 'resource_rule' must contain only enums 'ResourceRuleEnum.MAXIMUM', "
+                                 "'ResourceRuleEnum.MINIMUM' or 'ResourceRuleEnum.EXACT'.")
+        except AttributeError as e:
+            # Handle the case where elements in resource_rule don't have a 'value' attribute (likely not enums)
+            raise TypeError("Argument 'resource_rule' must contain only enums. Elements lack a 'value' "
+                            "attribute.") from e
+
+        self.senses = list([rule.value for rule in resource_rule])
+
+    @property
+    def upper_bound(self) -> np.array:
+        return np.array([np.floor(max(self.resource_limits[self.resource_limits != 0]) /
+                                  min(self.resource_usage[self.resource_usage != 0]))] * self.n, dtype=int)
+
+    @upper_bound.setter
+    def upper_bound(self, value: List):
+        self._upper_bound = value
+
+    @property
+    def linear_objective(self) -> np.ndarray:
+        """
+        Returns a 1D numpy array representing the linear part of the objective function (total profit).
+        """
+        return np.hstack([self.cost_per_task, np.zeros(self.num_slacks)])
+
+    @linear_objective.setter
+    def linear_objective(self, value : np.ndarray):
+        
+        assert (value[len(self.cost_per_task):]==0).all(), "additional values beyond cost length must be 0"
+
+        self.cost_per_task[:] = value[:len(self.cost_per_task)]
+
+    @property
+    def quad_objective(self) -> np.ndarray:
+        """
+        Returns a 2D numpy array representing the quadratic part of the objective function (always zero in this case).
+        """
+        # No quadratic term
+        n = self.n
+        return np.zeros((n, n))
+
+    @quad_objective.setter
+    def quad_objective(self, value: np.ndarray):
+        """ Don't let anything be passed in except arrays of all 0 """
+
+        # the setting of this gets ignored, but speak if somebody brings a soul
+        # that hasn't passed yet (all must be 0)
+
+        assert (value==0).all(), "quadratic terms in objective must be 0"
+        
+    @property
+    def H(self):
+        """
+        Overrides the parent build method to incorporate slack variables based on resource_rule.
+        """
+        # Build constraint penalties with slack variables
+        Pl, Pq = self.penalties
+        alpha = self.penalty_multiplier
+        obj_linear, obj_quad = self.linear_objective, self.quad_objective
+
+        self._C = obj_linear + alpha * Pl
+        self._J = obj_quad + alpha * Pq
+
+        return obj_linear + alpha * Pl, obj_quad + alpha * Pq
+
+    def checkResources(self, solution):
+        """
+        Parameters
+        ----------
+        solution: List or np.ndarray
+            solution vector to check for resource violations
+
+        Returns
+        -------
+        List of violations: (name, rule, violation quantity, message)
+
+        """
+        violations = []
+        solution = np.array(solution)
+        for name, usage, rule, limit in zip(self.resources, self.resource_usage.T,
+                                            self.senses, self.resource_limits):
+            decision_vars = self.n - self.num_slacks
+            value = np.squeeze(usage@solution[:decision_vars])
+            if rule == ResourceRuleEnum.MINIMUM:
+                mult = -1
+            else:
+                mult = 1
+            if rule == ResourceRuleEnum.EXACT:
+                if value - limit != 0:
+                    msg = f"{value} of {name} violates {rule} {limit}"
+                    violations.append((name, rule, value - limit, msg))
+            else:
+                if mult * (value - limit) > 0:
+                    msg = f"{value} of {name} violates {rule} {limit}"
+                    violations.append((name, rule, (value - limit), msg))
+        return violations
+    
+    @property
+    def n(self):
+        return len(self.tasks) + self.num_slacks