luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/schemas/solver_parameters/fujitsu/partial_config.py

@@ -0,0 +1,177 @@
+from typing import Any, List, Literal, Optional, Tuple, Union
+
+from numpy.typing import NDArray
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+from typing_extensions import Annotated
+
+OneHot = Literal["no_way", "one_way", "two_way"]
+
+
+class VarShapeBase(BaseModel):
+    name: str
+    one_hot: OneHot = "no_way"
+
+
+class WithConstantBits(VarShapeBase):
+    shape: Optional[List[int]] = None
+    constant_bits: Optional[NDArray] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @field_serializer("constant_bits")
+    def serialize_constant_bits(self, constant_bits: Optional[NDArray], _):
+        if constant_bits is None:
+            return None
+        return constant_bits.tolist()
+
+
+class BitArrayShape(WithConstantBits):
+    """An object of the class :class:`BitArrayShape` represents an array structure as part of a bit vector. It allows
+    multidimensional indexed access to the bit variables of a :class:`BinPol` polynomial. :class:`BitArrayShape`
+    objects are used inside :class:`VarShapeSet` objects, which organize index data of a complete bit vector for
+    a polynomial. Bit variables of such polynomials can then be accessed by name and indices according
+    to the shape specified in the :class:`BitArrayShape` object.
+
+    Parameters
+    ----------
+    shape: List[int]
+        shape of the index; specify the length of each dimension
+    constant_bits: Optional[NDArray]
+        numpy array of type int8 with same shape as the previous parameter containing 0 and 1 for constant bits and -1 variable bits
+    one_hot: OneHot
+        define variable as one_hot section
+    axis_names: Optional[List[str]]
+        Names for the axis.
+    index_offsets: Optional[List[int]]
+        index_offsets of the index, specify the index_offsets of each dimension
+    """
+
+    type: Literal["BitArrayShape"] = "BitArrayShape"
+    axis_names: Optional[List[str]] = None
+    index_offsets: Optional[List[int]] = None
+
+
+class Variable(WithConstantBits):
+    """A ``Variable`` is a binary polynomial, that represents a numerical value according to values of the underlying bits.
+    The variable is defined by a value range and a specific representation scheme that is realized in respective
+    inherited classes.
+
+    Parameters
+    ----------
+    name: str
+        name of the variable
+    start: float
+        first number in the list of values to be represented by the variable
+    stop: float
+        stop value for the list of numbers to be represented by the variable; stop is omitted
+    step: float
+        increment for the list of numbers to be represented by the variable
+    shape: List[int]
+        shape of the index; specify the length of each dimension
+    constant_bits: Optional[NDArray]
+        numpy array of type int8 with same shape as the previous parameter containing 0 and 1 for constant bits and -1 variable bits
+    one_hot: OneHot
+        define variable as one_hot section
+    """
+
+    type: Literal["Variable"] = "Variable"
+    start: float
+    stop: float
+    step: float
+
+
+class Category(VarShapeBase):
+    """An object of the class :class:`Category` represents an array structure as part of a bit vector. It allows
+    indexed access to the bit variables of a :class:`BinPol` polynomial. :class:`Category`
+    objects are used inside :class:`VarShapeSet` objects, which organize index data of a complete bit vector for
+    a polynomial. Bit variables of such polynomials can then be accessed by ``name`` and categorical indices according
+    to the ``values`` specified in the :class:`BitArrayShape` object. A categorical index can be any sequence of
+    unique values.
+
+    Parameters
+    ----------
+    name: str
+        name of the new index
+    values: List[Any]
+        list of unique values for this category
+    one_hot: OneHot
+        define variable as one_hot section
+    axis_names: List[str]
+        Names for the axis.
+    """
+
+    type: Literal["Category"] = "Category"
+    values: List[Any] = []
+    axis_names: Optional[List[str]] = None
+
+
+VarDef = Annotated[
+    Union[BitArrayShape, Variable, Category], Field(discriminator="type")
+]
+
+
+class OneHotGroup(BaseModel):
+    """O:class:`dadk.BinPol.OneHotGroup` is used to define a one-way-one-hot group within a set of bit variables.
+    In particular, the entries of the one-way-one-hot group are specified as tuples including the name of the variable
+    specified in a BitArrayShape and (optionally) the indices of the variable in every dimension. Here, a single number
+    for a particular dimension means the index of the variable with the specified numbers in the dimensions is
+    included in the one-way-one-hot group. Another possibility is to specify a list or a range of indices for each dimension in
+    order to include all indices of the variables with these specified numbers in the dimensions in the one-way-one-hot group.
+    Finally, one can specify the value None for a dimension. In this case, the whole range of that dimension is considered for the
+    one-way-one-hot group.
+
+    Parameters
+    ----------
+    entries: Union[List, Tuple]
+        one or more Lists or Tuples specifying the members of a one-way-one-hot group.
+    """
+
+    entries: List[Union[List, Tuple]] = []
+
+
+class VarShapeSet(BaseModel):
+    """:class:`dadk.BinPol.VarShapeSet` defines an indexing structure for the bits of a BinPol polynomial. Plain BinPol
+    polynomials are defined on a set of bits indexed by a ``range(N)`` for some integer ``N``. The ``VarShapeSet`` lays
+    a sequence of disjoint named sections over this linear structure. Bits within a section can be addressed by the
+    defined name. With a ``BitArrayShape`` a section can be defined as multidimensional array and single bits in the
+    section can be addressed by an appropriate tuple of indices. With a ``Variable`` definition the section represents
+    a number encoded in certain bit schemes; in this case it is possible to retrieve the represented value instead of
+    reading single bits.
+
+    Parameters
+    ----------
+    var_defs: Union[BitArrayShape, Variable, Category]
+        one or more section definitions of type :class:`BitArrayShape`, :class:`Variable` or :class:`Category`
+    one_hot_groups: Optional[List[OneHotGroup]]
+        optional list of special one_hot group definitions
+    """
+
+    var_defs: List[VarDef] = []
+    one_hot_groups: Optional[List[OneHotGroup]] = None
+
+
+class PartialConfig(BaseModel):
+    """:class:`PartialConfig` produces a dictionary that can be used to initialize bits for the annealing algorithm.
+
+    The start state for an annealing or parallel tempering optimization can be specified.
+    The used dictionary addresses bits with their flattened index. With the class
+    :class:`PartialConfig` those bits can be specified on the symbolic level of
+    :class:`BitArrayShape` or :class:`Variable` and the offsets in a :class:`VarShapeSet` are calculated automatically.
+    Flat indices can be used directly, if they are known. For variables, indices are used directly and do not need
+    to be adjusted by a global index consideration from the :class:`VarShapeSet`. After setting the start state accordingly,
+    a string can be created with the method ``as_json``. If one_hot or two_hot specifications are given in :class:`VarShapeSet`, the dictionary
+    generated in the methods ``get_dict`` or ``as_json`` is build up with respect to the set bit variables and one-way or two-way rules.
+
+    The object is initialized by a :class:`VarShapeSet` object or None. An initialization with None can be used for :class:`BinPol`.
+
+    Parameters
+    ----------
+
+    var_shape_set: Optional[VarShapeSet]
+        This parameter should be an object of :class:`VarShapeSet` or ``None``
+    auto_fill_cold_bits: bool
+        In case ``var_shape_set`` is defined and contains a 1-hot group, and a hot bit is set to ``True`` and this parameter is also set to ``True``, then all related cold bits are set to ``False``. Default is ``True``
+    """
+
+    var_shape_set: Optional[VarShapeSet] = None
+    auto_fill_cold_bits: bool = True

luna_sdk/schemas/solver_parameters/ibm/__init__.py

@@ -0,0 +1,4 @@
+"""Solver Parameters"""
+
+from luna_sdk.schemas.solver_parameters.ibm.qaoa import QaoaParameters
+from luna_sdk.schemas.solver_parameters.ibm.vqe import VqeParameters

luna_sdk/schemas/solver_parameters/ibm/qaoa.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel, ConfigDict
+
+from luna_sdk.schemas.solver_parameters.ibm.standard_parameters import (
+    StandardParameters,
+)
+
+
+class QaoaConfig(BaseModel):
+    """
+    Parameters
+    ----------
+    reps : int
+        Depth of the circuit. Default: 1.
+    name : str
+        Name of the circuit. Default: "QAOA".
+    """
+
+    reps: int = 1
+    name: str = "QAOA"
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class QaoaParameters(StandardParameters):
+    """
+    The Quantum Approximate Optimization Algorithm ([QAOA](https://arxiv.org/abs/1411.4028))
+    solves combinatorial optimization problems by approximating the solution:
+
+    For a given problem represented as a cost Hamiltonian we formulate two unitary
+    operators.
+    The QAOA solves the problem by iteratively applying the two unitary operators on
+    the cost Hamiltonian for a number of steps p.
+    The angles for the unitary operators are iteratively updated by measuring the state
+    after applying these (like in VQE).
+
+    For further information see qiskit's [QAOA tutorial](https://learning.quantum.ibm.com/tutorial/quantum-approximate-optimization-algorithm).
+
+    Parameters
+    ----------
+    backend : str | dict[str, Any] | None
+        Which backend to use. Default: "AerSimulator"
+        - If None, will use no backend and StatevectorSampler and StatevectorEstimator.
+        - If dict, will call `runtime_service.least_busy` with the params given in the dict.
+        - If str:
+            - If "AerSimulator": use AerSimulator
+            - If string starts with "Fake, will use the corresponding fake backend from `qiskit_ibm_runtime.fake_provider`.
+            - Otherwise, will try to use a real backend with this name.
+    shots : int = 1024
+        Shots for the optimizer. Default: 1024
+    dynamical_decoupling : dict[str, Any] = {}
+        Dynamical decoupling options for the optimizer. Default: {}
+    optimizer : str
+        Name of the optimizer to use in scipy minimize. Default: "COBYLA"
+    maxiter : int
+        Maximum number of iterations for the algorithm. Default: 10
+    optimization_level : int
+        Optmimization level for the pass manager. Default: 2
+    service_config : ServiceConfig
+        Parameters to be passed to the `QiskitRuntimeService` object.
+    qaoa_config : QaoaConfig
+        Configuration for the QAOAAnsatz; see `qiskit.circuit.library.QAOAAnsatz`.
+    """
+
+    qaoa_config: QaoaConfig = QaoaConfig()

luna_sdk/schemas/solver_parameters/ibm/standard_parameters.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ServiceConfig(BaseModel):
+    channel: Optional[Literal["ibm_cloud", "ibm_quantum"]] = "ibm_quantum"
+    url: Optional[str] = None
+    name: Optional[str] = None
+    instance: Optional[str] = None
+    proxies: Optional[dict] = None
+    verify: Optional[bool] = None
+    channel_strategy: Optional[str] = None
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class StandardParameters(BaseModel):
+    backend: Optional[Union[str, Dict[str, Any]]] = "AerSimulator"
+    shots: int = 1024
+    dynamical_decoupling: Dict[str, Any] = {}
+    optimizer: str = "COBYLA"
+    maxiter: int = 10
+    optimization_level: int = 2
+    service_config: ServiceConfig = ServiceConfig()
+
+    model_config = ConfigDict(extra="forbid")

luna_sdk/schemas/solver_parameters/ibm/vqe.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict
+
+from luna_sdk.schemas.solver_parameters.ibm.standard_parameters import (
+    StandardParameters,
+)
+
+
+class VqeParameters(StandardParameters):
+    """
+    The Variational Quantum Eigensolver ([VQE](https://arxiv.org/abs/1304.3061)) solves
+    combinatorial optimization problems by approximating the solution:
+    \n For a given problem represented as a cost Hamiltonian we apply
+    a classical/quantum hybrid algorithm to find the solution. The VQE solves
+    the problem by iteratively applying a linear transformation
+    (variational form) on the cost Hamiltonian and optimizing the parameters of
+    the transformation using a classical optimizer.
+
+    For further information see qiskit's [VQE tutorial](https://learning.quantum.ibm.com/tutorial/variational-quantum-eigensolver).
+
+    Parameters
+    ----------
+    backend : str | dict[str, Any] | None
+        Which backend to use. Default: "AerSimulator"
+        - If None, will use no backend and StatevectorSampler and StatevectorEstimator.
+        - If dict, will call `runtime_service.least_busy` with the params given in the dict.
+        - If str:
+            - If "AerSimulator": use AerSimulator
+            - If string starts with "Fake, will use the corresponding fake backend from qiskit_ibm_runtime.fake_provider
+            - Otherwise, will try to use a real backend with this name
+    shots : int
+        Shots for the optimizer. Default: 1024
+    dynamical_decoupling : dict[str, Any]
+        Dynamical decoupling options for the optimizer. Default: {}
+    optimizer : str
+        Name of the optimizer to use in scipy minimize. Default: "COBYLA"
+    maxiter : int
+        Maximum number of iterations for the algorithm. Default: 10
+    optimization_level : int
+        Optmimization level for the pass manager. Default: 2
+    service_config : ServiceConfig
+        Parameters to be passed to the `QiskitRuntimeService` object.
+    ansatz : str
+        Which ansatz to use from `qiskit.circuit.library`. Default: "EfficientSU2"
+    ansatz_config : dict[str, Any]
+        Configuration for the ansatz. Default: {}
+    """
+
+    ansatz: str = "EfficientSU2"
+    ansatz_config: Dict[str, Any] = {}

luna_sdk/schemas/solver_parameters/qctrl/__init__.py

@@ -0,0 +1 @@
+from luna_sdk.schemas.solver_parameters.qctrl.qaoa import QaoaParameters

luna_sdk/schemas/solver_parameters/qctrl/qaoa.py

@@ -0,0 +1,47 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+
+class QaoaParameters(BaseModel):
+    """
+    QAOA is a popular algorithm that can be applied to a wide range of optimization problems that are out of reach today
+    like portfolio optimization, efficient logistics routing, and asset liability management.
+
+    This version of QAOA is from Q-CTRL's software framework “Fire Opal”.
+    When running QAOA via Fire Opal, all aspects of running QAOA on real hardware are
+    fully optimized to reduce errors and improve the quality of solutions. By tailoring all parts of the algorithm to be hardware-optimized,
+    Fire Opal enables larger problems to converge on the correct solution and do so in fewer iterations, reducing the required execution time.
+
+    For further information, see Q-CTRL's documentation(https://docs.q-ctrl.com/fire-opal/topics/fire-opals-qaoa-solver).
+
+    Parameters
+    ----------
+    ### organization_slug: str | None
+        Organization slug from the organization of the user. Required, if the user is part of more than one organization.
+        This information can be retrieved from your Q-CTRL account. Default: None
+
+    ### backend_name: str
+        Defines backend simulator for the algorithm.
+        To see, which backends are available, please check your ibm account.
+        It usually starts with 'ibm_', e.g., 'ibm_osaka'. 'least_busy' is also allowed. In this case, the least busy solver will be used.
+        Default: 'basic_simulator'
+
+    ### hub: str
+        The IBM Quantum hub. Default: 'ibm-q'
+
+    ### group: str
+        The IBM Quantum group. Default: 'open'
+
+    ### project: str
+        The IBM Quantum project. Default: 'main'
+
+    ### min_num_vars: int
+        Default: 1
+    """
+
+    organization_slug: Any = None
+    backend_name: Optional[str] = None
+    hub: str = "ibm-q"
+    group: str = "open"
+    project: str = "main"

luna_sdk/schemas/transformations/__init__.py

@@ -0,0 +1,2 @@
+from .bqm import BQMResultSchema, BQMInverter, BQMSchema
+from .matrix import MatrixSchema

luna_sdk/schemas/transformations/bqm.py

@@ -0,0 +1,33 @@
+from enum import Enum
+from typing import Dict
+
+from pydantic import BaseModel, ConfigDict
+
+
+class VarTypeStrEnum(str, Enum):
+    SPIN = "SPIN"
+    BINARY = "BINARY"
+    INTEGER = "INTEGER"
+    DISCRETE = "DISCRETE"
+    REAL = "REAL"
+
+
+class BQMSchema(BaseModel):
+    linear: Dict[str, float]
+    quadratic: Dict[str, float]
+    offset: float
+    var_type: VarTypeStrEnum
+
+
+class BQMInverter(BaseModel):
+    binary: Dict[str, VarTypeStrEnum]
+    integers: Dict[str, BQMSchema]
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class BQMResultSchema(BaseModel):
+    bqm: BQMSchema
+    inverter: BQMInverter
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

luna_sdk/schemas/transformations/matrix.py

@@ -0,0 +1,12 @@
+from typing import List, Dict
+
+from pydantic import BaseModel
+
+from luna_sdk.schemas.transformations.bqm import BQMInverter
+
+
+class MatrixSchema(BaseModel):
+    matrix: List[List[float]]
+    variable_indices: Dict[str, int]
+
+    inverter: BQMInverter

luna_sdk/schemas/use_cases/__init__.py

@@ -0,0 +1,54 @@
+from .arbitrage_edge_based import ArbitrageEdgeBased
+from .arbitrage_node_based import ArbitrageNodeBased
+from .base import UseCase
+from .binary_integer_linear_programming import BinaryIntegerLinearProgramming
+from .binary_paint_shop_problem import BinaryPaintShopProblem
+from .credit_scoring_feature_selection import CreditScoringFeatureSelection
+from .dynamic_portfolio_optimization import DynamicPortfolioOptimization
+from .exact_cover import ExactCover
+from .flight_gate_assignment import FlightGateAssignment
+from .graph_coloring import GraphColoring
+from .graph_isomorphism import GraphIsomorphism
+from .graph_partitioning import GraphPartitioning
+from .hamiltonian_cycle import HamiltonianCycle
+from .induced_subgraph_isomorphism import InducedSubGraphIsomorphism
+from .job_shop_scheduling import JobShopScheduling
+from .k_medoids_clustering import KMedoidsClustering
+from .knapsack_integer_weights import KnapsackIntegerWeights
+from .linear_regression import LinearRegression
+from .lmwcs import LabeledMaxWeightedCommonSubgraph
+from .longest_path import LongestPath
+from .market_graph_clustering import MarketGraphClustering
+from .max2sat import Max2SAT
+from .max3sat import Max3SAT
+from .max_clique import MaxClique
+from .max_cut import MaxCut
+from .max_independent_set import MaxIndependentSet
+from .minimal_maximal_matching import MinimalMaximalMatching
+from .minimal_spanning_tree import MinimalSpanningTree
+from .minimum_vertex_cover import MinimumVertexCover
+from .number_partitioning import NumberPartitioning
+from .portfolio_optimization import PortfolioOptimization
+from .portfolio_optimization_ib_tv import (
+    PortfolioOptimizationInvestmentBandsTargetVolatility,
+)
+from .quadratic_assignment import QuadraticAssignment
+from .quadratic_knapsack import QuadraticKnapsack
+from .satellite_scheduling import SatelliteScheduling
+from .sensor_placement import SensorPlacement
+from .set_cover import SetCover
+from .set_packing import SetPacking
+from .set_partitioning import SetPartitioning
+from .subgraph_isomorphism import SubGraphIsomorphism
+from .subset_sum import SubsetSum
+from .support_vector_machine import SupportVectorMachine
+from .traffic_flow import TrafficFlow
+from .travelling_salesman_problem import TravellingSalesmanProblem
+from .type_aliases import (
+    CalculusLiteral,
+    Clause,
+    NestedDictGraph,
+    NestedDictIntGraph,
+    Node,
+)
+from .weighted_max_cut import WeightedMaxCut

luna_sdk/schemas/use_cases/arbitrage_edge_based.py

@@ -0,0 +1,49 @@
+from typing import Dict, Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class ArbitrageEdgeBased(UseCase):
+    """
+    # Arbitrage Edge Based
+
+    Description
+    -----------
+
+    In economics and finance, arbitrage is the practice of taking advantage of a
+    difference in prices in two or more markets; striking a combination of matching
+    deals to capitalize on the difference.
+    The edge based Arbitrage problem tries to find the best cycle in a directed and
+    complete graph. In this graph, each node corresponds to an asset and each directed
+    edge is weighted with the corresponding conversion rate. It creates a QUBO with the
+    size _n_edges x n_edges_, which produces a solution vector where each binary
+    position maps to an edge.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Arbitrage)
+
+    [Transformation](http://1qbit.com/files/white-papers/1QBit-White-Paper-%E2%80%93-Finding-Optimal-Arbitrage-Opportunities-Using-a-Quantum-Annealer.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[str, Dict[str, Dict[str, float]]]
+        \n The input graph as described above in the form of nested dictionaries.
+        \n Example for three different currencies:
+        \n _{_
+        \n     _0: {1: {'weight': 1.31904}, 2: {'weight': 6.72585}},_
+        \n     _1: {0: {'weight': 0.75799}, 2: {'weight': 5.10327},_
+        \n     _2: {0: {'weight': 0.14864}, 1: {'weight': 0.19586}}_
+        \n _}_
+
+    ### penalty: Optional[float] = None
+        \n The penalty term for the QUBO matrix. Has to be greater than 0.
+    """
+
+    name: Literal["AEB"] = "AEB"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore
+    penalty: Optional[float] = None

luna_sdk/schemas/use_cases/arbitrage_node_based.py

@@ -0,0 +1,54 @@
+from typing import Dict, Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class ArbitrageNodeBased(UseCase):
+    """
+    # Arbitrage Node Based
+
+    Description
+    -----------
+
+    In economics and finance, arbitrage is the practice of taking advantage of a
+    difference in prices in two or more markets; striking a combination of matching
+    deals to capitalize on the difference.
+    The node based Arbitrage problem tries to find the best cycle in a directed and
+    complete graph. In this graph, each node corresponds to an asset and each directed
+    edge is weighted with the corresponding conversion rate.
+    The problem creates a QUBO with the size
+    _(n_nodes * cycle_length) x (n_nodes * cycle_length)_, which produces a solution
+    vector where each binary position maps to to a node and its position in the cycle.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Arbitrage)
+
+    [Transformation](http://1qbit.com/files/white-papers/1QBit-White-Paper-%E2%80%93-Finding-Optimal-Arbitrage-Opportunities-Using-a-Quantum-Annealer.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[str, Dict[str, Dict[str, float]]]
+        \n The input graph as described above in the form of nested dictionaries.
+        \n Example for three different currencies:\n
+        \n _{_
+        \n     _0: {1: {'weight': 1.31904}, 2: {'weight': 6.72585}},_
+        \n     _1: {0: {'weight': 0.75799}, 2: {'weight': 5.10327},_
+        \n     _2: {0: {'weight': 0.14864}, 1: {'weight': 0.19586}}_
+        \n _}_
+
+    ### penalty: Optional[float] = None
+        \n The penalty term for the QUBO matrix. Has to be greater than 0.
+
+    ### K: Optional[int] = None
+        \n The maximum length of the arbitrage cycle.
+    """
+
+    name: Literal["ANB"] = "ANB"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore
+    penalty: Optional[float] = None
+    K: Optional[int] = None

luna_sdk/schemas/use_cases/base.py

@@ -0,0 +1,5 @@
+from luna_sdk.schemas.pretty_base import PrettyBase
+
+
+class UseCase(PrettyBase):
+    name: str

luna_sdk/schemas/use_cases/binary_integer_linear_programming.py

@@ -0,0 +1,53 @@
+from typing import List, Literal
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class BinaryIntegerLinearProgramming(UseCase):
+    """
+    # Binary Integer Linear Programming
+
+    Description
+    -----------
+
+    For a binary decision vector _x_ and some vector _c_ of length _N_, the Binary
+    Integer Linear Programming problem maximizes _c * x_, given the constraint _Sx = b_
+    with _S_ being an _m x N_ matrix and _b_ a vector with _m_ components.
+
+    Q-Bit Interpretation
+    --------------------
+
+    The vector of qubits is simply the decision vector _x_.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Integer_programming)
+
+    [Transformation](https://arxiv.org/pdf/1302.5843.pdf)
+
+    Attributes
+    ----------
+
+    ### S: List[List[int]]
+        \n The _m x N_ matrix.
+
+    ### b: List[int]
+        \n Vector with _m_ components.
+
+    ### c: List[int]
+        \n Custom vector of length _N_.
+
+    ### A: int
+        \n A constant enforcing, if possible, that _Sx = b_.
+
+    ### B: int
+        \n A constant (_B << A_) helping maximize _c * x_.
+    """
+
+    name: Literal["BIP"] = "BIP"
+    S: List[List[int]]
+    b: List[int]
+    c: List[int]
+    A: int = 10
+    B: int = 2