luna-quantum 1.0.8rc2__cp314-cp314-win_amd64.whl

luna_quantum/solve/use_cases/minimum_vertex_cover.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class MinimumVertexCover(UseCase):
+    r"""
+    # Minimum Vertex Cover.
+
+    Description
+    -----------
+
+    A vertex cover of an undirected graph is a set of vertices that includes at least
+    one endpoint of every edge of this graph. The Minimum Vertex Cover problem tries to
+    find the smallest vertex cover in a given graph. The smallest vertex cover is the
+    one that contains the least amount of nodes.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Vertex_cover)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the minimum vertex cover problem in form of nested
+        dictionaries.
+        \n (e.g. fully connected graph with 3 nodes:
+        \n _{0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}_
+        \n or _networkx.to_dict_of_dicts(networkx.complete_graph(3))_ )
+
+    ### P: int
+        \n Positive, scalar penalty value to penalize edges that are not covered.
+        \n Default: _8_
+    """
+
+    name: Literal["MVC"] = "MVC"
+    graph: dict[str, dict[str, dict[str, float]]] = Field(name="graph")  # type: ignore[call-overload]
+    P: int = 8

luna_quantum/solve/use_cases/number_partitioning.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class NumberPartitioning(UseCase):
+    r"""
+    # Number Partitioning.
+
+    Description
+    -----------
+
+    The Number Partitioning problem partitions a set of numbers into two subsets such
+    that the difference of the subset sums is minimized.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Partition_problem)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### numbers: List[int]
+        \n The set of numbers which has to be partitioned.
+    """
+
+    name: Literal["NP"] = "NP"
+    numbers: list[int]

luna_quantum/solve/use_cases/portfolio_optimization.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class PortfolioOptimization(UseCase):
+    r"""
+    # Portfolio Optimization.
+
+    Description
+    -----------
+
+    The Portfolio Optimization problem tries to find the optimal portfolio of assets
+    which achieves an equal or higher return than the target return with the lowest
+    risk possible. The optimal portfolio is defined by the binary choices whether to
+    invest in a specific asset or not.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Portfolio_optimization)
+
+    [Transformation](https://arxiv.org/pdf/2012.01121.pdf)
+
+    Attributes
+    ----------
+    ### returns: List[List[float]]
+        \n Returns matrix which contains time-series of returns per asset i.
+
+    ### R: float
+        \n Target for overall return of portfolio.
+
+    ### n: int
+        \n Number of wanted assets in set.
+
+    ### lambda0: int = 1
+        \n Default lagrange multiplier.
+    """
+
+    name: Literal["PO"] = "PO"
+    returns: list[list[float]]
+    R: float
+    n: int
+    lambda0: int = 1

luna_quantum/solve/use_cases/portfolio_optimization_ib_tv.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class PortfolioOptimizationInvestmentBandsTargetVolatility(UseCase):
+    r"""
+    # Portfolio Optimization with Investment Bands and Target Volatility.
+
+    Description
+    -----------
+
+    The Portfolio Optimization problem tries to find the optimal portfolio of assets
+    which achieves an equal or higher return than the target return with the lowest
+    risk possible. The optimal portfolio is defined by the binary choices whether to
+    invest in a specific asset or not.
+
+    This special case of portfolio optimization handles to additional constraints. On
+    the one hand, it tries to find optimal investment portfolios with a fixed
+    volatility. On the other hand, it imposes investment bands in the computed
+    portfolios, i.e. the investment for each asset is between a minimum and a maximum.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Portfolio_optimization)
+
+    [Transformation](https://arxiv.org/pdf/2106.06735.pdf)
+
+    Attributes
+    ----------
+    ### log_returns: List[float]
+        \n Log return of each asset.
+
+    ### sigma: List[List[float]]
+        \n Risk matrix.
+
+    ### investment_bands: List[Tuple[float, float]]
+        \n Investment bands for each asset.
+
+    ### target_volatility: float
+        \n Target volatility of portfolio.
+
+    ### max_budget: int
+        \n Maximum budget.
+
+    ### budget_weight: float
+        \n Budget penalty factor.
+
+    ### volatility_weight: float
+        \n Volatility penalty factor.
+    """
+
+    name: Literal["POIBTV"] = "POIBTV"
+    log_returns: list[float]
+    sigma: list[list[float]]
+    investment_bands: list[tuple[float, float]]
+    target_volatility: float
+    max_budget: int
+    budget_weight: float = 5.0
+    volatility_weight: float = 50.0

luna_quantum/solve/use_cases/quadratic_assignment.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class QuadraticAssignment(UseCase):
+    r"""
+    # Quadratic Assignment.
+
+    Description
+    -----------
+
+    There are a set of _n_ facilities and a set of _n_ locations. For each pair of
+    locations, a distance is specified and for each pair of facilities a weight or flow
+    is specified. The Quadratic Assignment problem assigns all facilities to different
+    locations with the goal of minimizing the sum of products of the distances and the
+    corresponding flows.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Quadratic_assignment_problem)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### flow_matrix: List[List]
+        \n A matrix denoting the flow (or weight) between the facilities.
+        \n e.g. for two facilities with a flow of 3, the flow_matrix will be
+        _[[0, 3], [3, 0]]_.
+
+    ### distance_matrix: List[List]
+        \n A matrix denoting the distance between the locations.
+        \n e.g. for two places with a distance of 8, the flow_matrix will be
+        _[[0, 8], [8, 0]]_.
+
+    ### P: int
+        \n Positive, scalar penalty value to penalize when a facility is mapped to two
+        different locations or vice versa.
+        \n Default: _200_
+    """
+
+    name: Literal["QA"] = "QA"
+    flow_matrix: list[list[float]]
+    distance_matrix: list[list[float]]
+    P: int = 200

luna_quantum/solve/use_cases/quadratic_knapsack.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class QuadraticKnapsack(UseCase):
+    r"""
+    # Quadratic Knapsack.
+
+    Description
+    -----------
+
+    Given an upper bound of budget and a set of potential projects, each having a
+    certain cost, a certain value, and value interactions with the other projects, the
+    Quadratic Knapsack problem selects the combination of projects with the highest
+    total value, without exceeding the budget restraint.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Quadratic_knapsack_problem)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### projects: List[List[float]]
+        \n A double nested list with entries _projects[i][j]_ corresponding to the value
+        gain of choosing both projects i and j at the same time.
+
+    ### costs: List[float]
+        \n The individual costs of each project.
+
+    ### budget: float
+        \n Budget restraint (upper bound) on projects.
+
+    ### P: int
+        \n The weight of the penalty term.
+        \n Default: _10_
+    """
+
+    name: Literal["QK"] = "QK"
+    projects: list[list[float]]
+    costs: list[float]
+    budget: float
+    P: float = 10

luna_quantum/solve/use_cases/satellite_scheduling.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SatelliteScheduling(UseCase):
+    r"""
+    # Satellite Scheduling.
+
+    Description
+    -----------
+
+    We assume a satellite can occupy three states: charging (*c*), downlink (*d*) and
+    experiment (*e*). We discretize the time and assume time steps *t ∈ {0,1,...,T}*.
+    The variable *x_st* tells us if the satellite is in the state *s ∈ {c,d,e}* at time
+    *t*. With this, the time sequence of these variables represents the schedule we want
+    to optimize. The optimization goal is to record as much data as possible during the
+    mission. [1]
+
+    There are two satellite variables which may change over time: The charge of the
+    battery *C* and the data stored on the memory *D*. The rate with which these
+    variables are changing depending on state *s* are denoted by *c_s* and *d_s*
+    respectively. [1]
+
+    For example the experiment state will increase the data *dd > 0* and decrease the
+    charge *dc < 0*. Both the battery and the memory define an upper and lower limit
+    for  the charge and the data, respectively. Not every state can be occupied at each
+    instance in time. For example, the charging through solar panels is only possible
+    in sunlight, or the downlink is only possible in the vicinity of a ground station.
+    Therefore for each state s there is a subset of times `τ_s ⊆ {0,1,...,T}* at which
+    the satellite can occupy this state. To enforce this constraint, we remove all
+    variables *x_st ∈ {x_st |t ∈ τ_s}*. [1]
+
+    For the sake of simplicity, we assume that each state has minimum duration of *1*.
+
+    Links
+    -----
+
+    [Transformation (Experiences with Scheduling Problems on Adiabatic Quantum Computers)](https://elib.dlr.de/110044/1/43.pdf)
+
+    Attributes
+    ----------
+    ### T: int
+        \n T is the latest included time step. Note that the earliest included time step
+        is always *0*.
+
+    ### P: Tuple[int, int, int, int, int, int]
+        \n The penalties for each constraint.
+
+    ### Tau: List[List[int]]
+        \n Times to be removed for each state.
+
+    ### d: Dict
+        \n Dict describing downlink state which includes entries *rate*, *initial*,
+        *max*, *min*.
+
+    ### c: Dict
+        \n Dict describing charging state which includes entries *rate*, *initial*,
+        *max*, *min*.
+
+    ### S: int
+        \n *S* is the total number of possible states.
+    """
+
+    name: Literal["SSC"] = "SSC"
+    T: int
+    P: tuple[int, int, int, int, int, int]
+    Tau: list[list[int]]
+    d: dict[str, float]
+    c: dict[str, float]
+    S: int = 3

luna_quantum/solve/use_cases/sensor_placement.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SensorPlacement(UseCase):
+    r"""
+    # Sensor Placement.
+
+    Description
+    -----------
+
+    The Sensor Placement problem finds the optimal placement of pressure sensors on a
+    water distribution network, which is modelled by a graph where the edges have
+    weights assigned to them. A higher weight corresponds to a higher importance that a
+    sensor is placed on one of the nodes of the edge. Placing a sensor at a given node
+    has a cost attached to it. The total cost of placing the sensors should also be
+    minimized. As a constraint, there is a predetermined number of sensors s, which
+    should be placed on the network.
+
+    Links
+    -----
+
+    [Transformation](https://arxiv.org/pdf/2108.04075.pdf)
+
+    Attributes
+    ----------
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the sensor placement problem in form of nested
+        dictionaries.
+        \n (e.g. network with 3 nodes:
+        \n _{0: {2: {'weight': 1.0}}, 1: {2: {'weight': 6.0}},
+            2: {0: {'weight': 1.0}, 1: {'weight': 6.0}}}_
+        \n or _networkx.to_dict_of_dicts(networkx.Graph(...))_ )
+
+    ### costs: List[float]
+        \n Cost of placing a sensor on specific node.
+
+    ### s: int
+        \n Number of sensors.
+
+    ### A: float
+        \n Lagrange multiplier in front of constraint in eq. (15).
+
+    ### B: float
+        \n Lagrange multiplier in front of constraint in eq. (13).
+    """
+
+    name: Literal["SPL"] = "SPL"
+    graph: dict[str, dict[str, dict[str, float]]] = Field(name="graph")  # type: ignore[call-overload]
+    costs: list[float]
+    s: int
+    A: float = 1
+    B: float = 30

luna_quantum/solve/use_cases/set_cover.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SetCover(UseCase):
+    r"""
+    # Set Cover.
+
+    Description
+    -----------
+
+    Given a set _S_ and a list of subsets of _S_, so that each element of _S_ is
+    contained in at least one of the subsets, the Set Cover problem tries to find the
+    smallest possible  family _C_ of these subsets so that all elements of _S_ are
+    contained in at least one subset of _C_.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Let _n_ be the number of elements of _S_ and let _N_ be the number of subsets of
+    _S_. Then, the qubit vector _x_ will have length _N + N * n_. For _x[:N]_,
+    _x[i] = 1_, iff. subset _i_ is contained in the set cover. For _x[N:]_, _x[i] = 1_,
+    iff. the number of subsets which include element _a_ is _m > 0_ and
+    _i = N + a * N + m_.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Set_cover_problem)
+
+    [Transformation](https://arxiv.org/pdf/1302.5843.pdf)
+
+    Attributes
+    ----------
+    ### subset_matrix: List[List[float]]
+        \n A matrix containing all subsets.
+        \n e.g. for the set _{1, 2, 3}_ and the subsets _{1, 2}_, _{2, 3}_, and _{3}_:
+        \n _[[1, 1, 0], [0, 1, 1], [0, 0, 1]]_
+        \n or:
+        \n _SetCover.gen_subsets_matrix([1, 2, 3], [[1, 2], [2, 3], [3]])_
+
+    ### A: int
+        \n A positive constant enforcing that each element of _S_ is contained in at
+        least one subset.
+
+    ### B: int
+        \n A constant (_0 < B < A) minimizing the number of subsets included.
+    """
+
+    name: Literal["SC"] = "SC"
+    subset_matrix: list[list[int]]
+    A: int = 4
+    B: int = 2

luna_quantum/solve/use_cases/set_packing.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SetPacking(UseCase):
+    r"""
+    # Set Packing.
+
+    Description
+    -----------
+
+    Given a set _S_ and a list of subsets of _S_, a packing is a family _C_ of these
+    subsets so that all sets in _C_ are pairwise disjoint. For a set _S_ and a list of
+    subsets of _S_, the Set Packing problem assigns a weight to each set and tries to
+    find a packing so that the sum of the weights of the used sets is maximized.
+
+    Note that, in contrast to the [transformation](https://arxiv.org/pdf/1811.11538.pdf)
+    mentioned below, our QUBO formulation searches for _min x^t Q x_ instead of
+    _max x^t Q x_ and thus all signs are flipped.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Subset _i_ is part of the packing iff. qubit _i_ is 1.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Set_packing)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### subset_matrix: List[List[int]]
+        \n A matrix containing all subsets.
+        \n e.g. for the set _{1, 2, 3}_ and the subsets _{1, 2}_, _{2, 3}_, and _{3}_:
+        \n _[[1, 1, 0], [0, 1, 1], [0, 0, 1]]_
+
+    ### weights: List[int]
+        \n An array of length n_subsets which assigns a weight to each subset.
+
+    ### P: int
+        \n Positive, scalar penalty value to penalize subsets that are not disjoint.
+        \n Default: _6_
+    """
+
+    name: Literal["SP"] = "SP"
+    subset_matrix: list[list[int]]
+    weights: list[float]
+    P: int = 6

luna_quantum/solve/use_cases/set_partitioning.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SetPartitioning(UseCase):
+    r"""
+    # Set Partitioning.
+
+    Description
+    -----------
+
+    The Set Partitioning problem partitions a set of items into a selection of possible
+    subsets so that each item of the set occurs in one and only one subset and the cost
+    of the chosen subsets is minimized.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Subset _i_ is part of the partitioning iff. qubit _i_ is 1.
+
+    Links
+    -----
+
+    [Description and Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### set_: List[int]
+        \n The set of items which has to be partitioned.
+
+    ### subsets: List[List[int]]
+        \n The possible subsets of set_.
+        \n e.g. for _set=[1, 2, 3]_ and the possible subsets _{1, 2}_ and _{3}_ one
+        has to specify _subsets=[[1, 2], [3]]_.
+
+    ### costs: List[int]
+        \n The cost of each possible subset. Has to be of the same length as _subsets_.
+
+    ### P: int
+        \n Positive, scalar penalty value to penalize items that occur in more than one
+        subset.
+        \n Default: _10_
+    """
+
+    name: Literal["SPP"] = "SPP"
+    set_: list[int]
+    subsets: list[list[int]]
+    costs: list[int]
+    P: int = 10

luna_quantum/solve/use_cases/subgraph_isomorphism.py

@@ -0,0 +1,55 @@
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+from luna_quantum.solve.use_cases.type_aliases import NestedDictIntGraph
+
+
+class SubGraphIsomorphism(UseCase):
+    r"""
+    # Subgraph Isomorphism.
+
+    Description
+    -----------
+
+    The Subgraph Isomorphism problem tries to find out whether, for two graphs _G1_ and
+    _G2_, _G2_ contains a subgraph _G3_ that is isomorphic to _G1_, i.e. there exists a
+    bijective, edge-invariant vertex mapping from _G1_ to _G3_. It returns the best such
+    mapping it is able to find.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Subgraph_isomorphism_problem)
+
+    [Transformation](https://researchspace.auckland.ac.nz/bitstream/handle/2292/31756/CDMTCS499.pdf?sequence=1)
+
+    Attributes
+    ----------
+    ### graph1: Dict[int, Dict[int, Dict[str, float]]]
+        \n The graph (in form of nested dictionaries) for which to check whether it is
+        isomorphic to a subgraph of graph2.
+        \n (e.g. fully connected graph with 3 nodes:
+        \n _{0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}_
+        \n or _networkx.to_dict_of_dicts(networkx.complete_graph(3))_ )
+
+    ### graph2: Dict[int, Dict[int, Dict[str, float]]]
+        \n The graph (in form of nested dictionaries) for which to check whether it
+        contains a subgraph that is isomorphic to graph1.
+        \n (e.g. fully connected graph with 3 nodes:
+        \n _{0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}_
+        \n or _networkx.to_dict_of_dicts(networkx.complete_graph(3))_ )
+
+    ### a: float = 1
+        \n A penalty value enforcing the bijectivity of the isomorphism.
+
+    ### b: float = 2
+        \n A penalty value (b > a) enforcing the edge-invariance of the isomorphism.
+    """
+
+    name: Literal["SGI"] = "SGI"
+    graph1: NestedDictIntGraph = Field(name="graph")  # type: ignore[call-overload]
+    graph2: NestedDictIntGraph = Field(name="graph")  # type: ignore[call-overload]
+    a: float = 1
+    b: float = 2

luna_quantum/solve/use_cases/subset_sum.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class SubsetSum(UseCase):
+    r"""
+    # Subset Sum.
+
+    Description
+    -----------
+
+    The Subset Sum problem finds a subset of numbers from a given set of integers where
+    the total sum over the subset is equal or maximally close to a target value t.
+    Example: Set _{5, 8, 4, 6}_ and Target _9_ returns the Subset _{5, 4}_
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Subset_sum_problem)
+
+    [Transformation](https://arxiv.org/pdf/1911.08043.pdf) (section 3.2.3)
+
+    Attributes
+    ----------
+    ### numbers: List[int]
+        \n Set of integers from which the subset is chosen.
+
+    ### t: int
+        \n Target value for sum over all numbers in subset.
+    """
+
+    name: Literal["SS"] = "SS"
+    numbers: list[int]
+    t: int