luna-quantum 0.0.16__py3-none-any.whl

luna_sdk/schemas/use_cases/linear_regression.py

@@ -0,0 +1,59 @@
+from typing import List, Literal
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class LinearRegression(UseCase):
+    """
+    # Linear Regression
+
+    Description
+    -----------
+
+    In statistics, linear regression is a linear approach to modelling the relationship
+    between a real-valued dependent variable and one or more real-valued independent
+    variables.
+
+    Q-Bit Interpretation
+    --------------------
+
+    For interpretation, the qubit vector has to be cut into (n_features + 1) sublists of
+    length K (specified below). The sum of each of the product of each of these sublists
+    and the precision vector gives an estimated feature weight.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Linear_regression)
+
+    [Transformation](https://doi.org/10.1038/s41598-021-89461-4)
+
+    Attributes
+    ----------
+
+    ### X: List[List[float]]
+        \n Training data set in form of a nested list.
+        \n All inner lists have to be of the same length.
+        \n (e.g. 3 data points with 2 features:
+        \n _[[1.1, 4.23], [0.1, -2.4], [-2.3, 1.11]]_ )
+
+    ### Y: List[int]
+        \n Regression labels of the training data set.
+        \n (e.g. for 3 data points:
+        \n _[1.2, -3.4, 2.41]_ )
+
+    ### K: int
+        \n Length of the precision vector.
+        \n As the problem outputs are supposed to be real values but the qubo only gives
+        a binary vector, we need a precision vector, consisting of powers of 2, to
+        simulate real values. This parameter determines the length of this vector.
+        \n (e.g. for K = 6, the precision vector is _[-2, -1, -0.5, 0.5, 1, 2]_)
+        \n This parameter also determines the size of the qubo matrix together with the
+        number of features _d_:
+        \n _size = (d + 1) * K_
+    """
+
+    name: Literal["LR"] = "LR"
+    X: List[List[float]]
+    Y: List[float]
+    K: int = 24

luna_sdk/schemas/use_cases/lmwcs.py

@@ -0,0 +1,80 @@
+from typing import List, Literal, Optional, Tuple
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+from luna_sdk.schemas.use_cases.type_aliases import NestedDictGraph
+
+
+class LabeledMaxWeightedCommonSubgraph(UseCase):
+    """
+    # Labeled Maximum Weighted Common Subgraph
+
+    Description
+    -----------
+
+    The Labeled Maximum Weighted Common Subgraph (LMWCS) problem finds, given two graphs
+    _G1_ and _G2_, the largest subgraph of _G1_ that is isomorphic to a subgraph of
+    _G2_. A weight is associated with each possible mapping between a node in _G1_ and a
+    node in _G2_ to model a difference in importance for different mappings between
+    nodes in the first graph and the second graph. The vertex pairs with assigned value
+    _1_ form the common subgraph. Besides the constraint on the mappings which follow
+    from requiring bijectivity, one can also define user-defined constraints.
+
+    Notes:
+    There is an error in definition of _C_ (bijectivity constraint): condition one
+    should be: _((i == m)_ or _(j == n))_ and not _((i == j)_ and _(j == n))_.
+
+    We need to map the binary vector elements _b_{i, j}_, where _i_ and _j_ describe a
+    node in the graphs 1 and 2 respectively, to an entry in a
+    _(graph1.order() * graph2.order())_ dimensional vector. Here, we say that the
+    element _b_{i, j}_ is mapped to the _(i * graph2.order() + j)_th entry of the
+    vector.
+
+    Generally, we have to fulfill _a_{(i, j), (m, n)} > min(w_{i, j}, w_{m, n})_ with
+    _w_ being the weights for the pairs _(i, j)_. Here, we choose _a > max(weights)_ as
+    if _a_ fulfills this condition for all _a_{(i, j), (m, n)}_.
+
+    Q-Bit Interpretation
+    --------------------
+
+    The tuple _(i, j)_ is part of the mapping iff. qubit _i * graph2.order() + j_ is 1.
+
+    Links
+    -----
+
+    [Transformation](https://arxiv.org/pdf/1601.06693.pdf)
+
+    Attributes
+    ----------
+
+    ### graph1: Dict[int, Dict[int, Dict[str, float]]]
+        \n First problem graph for the lmwcs 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))_ )
+
+    ### graph2: Dict[int, Dict[int, Dict[str, float]]]
+        \n Second problem graph for the lmwcs 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))_ )
+
+    ### weigths: List[float]
+        \n Weights for all pairs _(i, j)_ in _graph1.nodes x graph2.nodes_.
+
+    ### a: float
+        \n Penalty for mapping violating bijectivity or user constraints.
+
+    ### user_constraints: List[Tuple[Tuple[int, int], Tuple[int, int]]]
+        \n User given constraints on the vertex mapping.
+        \n _((i, j), (m, n))_ being part of the user constraints means that _(i, j)_ and
+        _(m, n)_ must not be part of the mapping at the same time.
+    """
+
+    name: Literal["LMWCS"] = "LMWCS"
+    graph1: NestedDictGraph = Field(name="graph")  # type: ignore
+    graph2: NestedDictGraph = Field(name="graph")  # type: ignore
+    weights: List[float]
+    a: float
+    user_constraints: Optional[List[Tuple[Tuple[int, int], Tuple[int, int]]]] = None

luna_sdk/schemas/use_cases/longest_path.py

@@ -0,0 +1,49 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class LongestPath(UseCase):
+    """
+    # Longest Path
+
+    Description
+    -----------
+
+    The longest path problem is the problem of finding a simple path of maximum length
+    from a given start node to a given terminal node in a given graph. A path is called
+    simple if it does not have any repeated vertices.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Longest_path_problem)
+
+    [Transformation](https://www.sciencedirect.com/science/article/abs/pii/S030439752100092X#!)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the longest path 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))_ )
+
+    ### start_node:
+        \n At which node to start.
+
+    ### terminal_node:
+        \n At which node to stop.
+
+    ### steps:
+        \n How many nodes to include in the path.
+    """
+
+    name: Literal["LP"] = "LP"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore
+    start_node: str
+    terminal_node: str
+    steps: int

luna_sdk/schemas/use_cases/market_graph_clustering.py

@@ -0,0 +1,60 @@
+from typing import List, Literal
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MarketGraphClustering(UseCase):
+    """
+    # Market Graph Clustering
+
+    Description
+    -----------
+
+    The authors formulate the index-tracking problem as a QUBO graph-clustering problem.
+    Their formulation restricts the number of assets while identifying the most
+    representative exemplars of an index. Their thesis is that a portfolio consisting of
+    the most representative set of exemplars will minimize tracking-error.
+    Initial results are very encouraging. Their tests show they accurately replicate the
+    returns of broad market indices, using only a small subset of their constituent
+    assets. Moreover, their QUBO formulation allows us to take advantage of recent
+    hardware advances to overcome the NP-hard nature of the clustering problem.
+    Using these novel architectures they obtain better solutions within small fractions
+    of the time required to solve equivalent problems formulated in traditional
+    constrained form and solved on traditional hardware. Their initial results certainly
+    offer hope and set the stage for larger-scale problems, in finance and beyond.
+
+    Their implementation is based on the work of *Bauckhage et al.*.
+
+    Q-Bit Interpretation
+    --------------------
+
+    "The qubit vector at index _k_ is 1 iff. stock _k_ from matrix _G_ (see below) is
+    chosen as medoid of a cluster. The step of assigning the remaining stocks to
+    clusters is not covered in this problem but can be easily done in linear time with
+    respect to the number of data points."
+
+    Links
+    -----
+
+    [Transformation (Market Graph Clustering via QUBO and Digital Annealing)](https://www.mdpi.com/1911-8074/14/1/34)
+
+    [Bauckhage et al. (A QUBO Formulation of the k-Medoids Problem)](http://ceur-ws.org/Vol-2454/paper_39.pdf)
+
+    Attributes
+    ----------
+
+    ### G: List[List[float]]
+        \n An *n x m* matrix, where *n* is the number of stocks and *m* is the number of
+        time units with returns for the respective stock at this time.
+
+    ### k: int
+        \n The number of representatives desired.
+
+    ### gamma: float
+        \n Penalty coefficient to enforce feasibility of the solution.
+    """
+
+    name: Literal["MGC"] = "MGC"
+    G: List[List[float]]
+    k: int
+    gamma: float

luna_sdk/schemas/use_cases/max2sat.py

@@ -0,0 +1,51 @@
+"""Provides the Max2SAT class"""
+
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+from luna_sdk.schemas.use_cases.type_aliases import Clause
+
+
+class Max2SAT(UseCase):
+    """
+    # Maximum 2-SAT
+
+    Description
+    -----------
+
+    For a formula in conjunctive normal form (CNF) with two literals per clause, the
+    Maximum 2-SAT problem determines the maximum number of clauses that can be
+    simultaneously satisfied by an assignment.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Each qubit corresponds to the truth value of one of the variables, to be precise:
+    _sorted(variables)[i] == True_ iff. _qubits[i] == 1_.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/2-satisfiability#Maximum-2-satisfiability)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+
+    ### clauses: List[Tuple[Tuple[int, bool], Tuple[int, bool]]]
+        \n A list containing all clauses of the formula in CNF in form of tuples.
+        \n (e.g. the formula _x0 * x1 + -x1 * x2_:
+        \n _[((0, True), (1, True)), ((1, False), (2, True))]_ )
+        \n It is possible to use arbitrary variable indices.
+
+    ### n_vars: Optional[int]
+        \n The number of different variables. Can be used to check whether the input
+        clauses have the desired number of different variables.
+    """
+
+    name: Literal["M2SAT"] = "M2SAT"
+    clauses: List[Clause] = Field(name="clauses")  # type: ignore
+    n_vars: Optional[int] = None

luna_sdk/schemas/use_cases/max3sat.py

@@ -0,0 +1,52 @@
+from typing import List, Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+from luna_sdk.schemas.use_cases.type_aliases import Clause
+
+
+class Max3SAT(UseCase):
+    """
+    # Maximum 3-SAT
+
+    Description
+    -----------
+
+    For a formula in conjunctive normal form (CNF) with three literals per clause, the
+    Maximum 3-SAT problem determines the maximum number of clauses that can be
+    simultaneously satisfied by an assignment.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Let _n_ be the number of different variables and let _m_ be the number of clauses.
+    Then, each of the first _n_ qubits corresponds to the truth value of one of the
+    variables, to be precise: _sorted(variables)[i] == True_ iff. _qubits[i] == 1_. Each
+    of the last _m_ qubits tells whether the corresponding clause is fulfilled,
+    formally: _clauses[i]_ is fulfilled iff. _qubits[n + i] == 1_.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/MAX-3SAT)
+
+    [Transformation](https://canvas.auckland.ac.nz/courses/14782/files/574983/download?verifier=1xqRikUjTEBwm8PnObD8YVmKdeEhZ9Ui8axW8HwP&wrap=1)
+
+    Attributes
+    ----------
+
+    ### clauses: List[Tuple[Tuple[int, bool], Tuple[int, bool], Tuple[int, bool]]]
+        \n A list containing all clauses of the formula in CNF in form of tuples.
+        \n (e.g. the formula _x0 * x1 * -x2 + -x1 * x2 * x3_:
+        \n _[((0, True), (1, True), (2, False)), ((1, False), (2, True), (3, True))]_ )
+        \n It is possible to use arbitrary variable indices.
+
+    ### n_vars: Optional[int]
+        \n The number of different variables. Can be used to check whether the input
+        clauses have the desired number of different variables.
+    """
+
+    name: Literal["M3SAT"] = "M3SAT"
+    clauses: List[Clause] = Field(name="clauses")  # type: ignore
+    n_vars: Optional[int] = None

luna_sdk/schemas/use_cases/max_clique.py

@@ -0,0 +1,59 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MaxClique(UseCase):
+    """
+    # Maximum Clique
+
+    Description
+    -----------
+
+    The Maximum Clique problem describes the task of finding the largest sized clique in
+    a given graph. A clique is a set of nodes in a graph, where every node has an edge
+    to every other node in the clique. A k-clique denotes a clique with exactly k nodes.
+    The maximum clique of a graph is the clique with the highest possible k value.
+
+    There is a closely related problem, the decisional clique problem, which describes
+    the challenge of determining whether a clique of at least size k exists in the given
+    graph.
+
+    Math
+    ----
+
+    ![Formula](https://www.matthiasknoll.net/storage/img/max_clique.svg)
+
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Clique_problem#Finding_a_single_maximal_clique)
+
+    [Transformation](https://arxiv.org/pdf/1801.08649.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the maximum clique 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))_ )
+
+    ### hard_constraints: Dict
+        \n Hard constraints that must be fulfilled by any valid instance. They are
+        defined in _aqcore.transformator.specifications.graph_specifications_.
+
+    ### soft_constraints: Optional[Dict]
+        \n Desirable traits that instances should fulfill.
+
+    ### check_soft_constraints: bool
+        \n Defines whether soft constraints should also be fulfilled. Default is
+        _False_.
+    """
+
+    name: Literal["MCQ"] = "MCQ"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore

luna_sdk/schemas/use_cases/max_cut.py

@@ -0,0 +1,47 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MaxCut(UseCase):
+    """
+    # Maximum Cut
+
+    Description
+    -----------
+
+    The Maximum Cut problem tries to find a cut that maximizes the number of
+    intersecting edges in an undirected graph.
+
+    Q-Bit Interpretation
+    --------------------
+    A cut defines two sets of nodes, 0 and 1.
+    The qubits x = (x_0, x_1, ..., x_n) can be interpreted like this:
+    x_i = 0 iff. node i belongs to set 0 and x_i = 1 iff. it belongs to set 1.
+
+    Math
+    ----
+
+    ![Formula](https://drive.google.com/uc?id=1D41KIt4S6gVkdOefWkwGDWLoIiTyexai)
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Maximum_cut)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the maximum cut 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))_ )
+    """
+
+    name: Literal["MC"] = "MC"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore

luna_sdk/schemas/use_cases/max_independent_set.py

@@ -0,0 +1,36 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MaxIndependentSet(UseCase):
+    """
+    # Maximum Independent Set
+
+    Description
+    -----------
+
+    An independent set of a graph _G_ is a set of vertices of _G_, where every two
+    vertices are not connected by an edge in _G_. The Maximum Independent Set problem
+    tries to find the largest independent set of a graph.
+
+    Links
+    -----
+
+    [Description and Transformation](https://arxiv.org/pdf/1801.08653.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the maximum independent set 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))_ )
+    """
+
+    name: Literal["MIS"] = "MIS"
+    graph: Dict[int, Dict[int, Dict[str, float]]] = Field(name="graph")  # type: ignore

luna_sdk/schemas/use_cases/minimal_maximal_matching.py

@@ -0,0 +1,53 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MinimalMaximalMatching(UseCase):
+    """
+    # Minimal Maximal Matching
+
+    Description
+    -----------
+
+    For a graph _G = (V, E)_, the Minimal Maximal Matching problem tries to find a
+    "coloring" _C ⊆ E_ with the following three constraints:
+    \n 1. For each edge in _C_, the incident vertices shall be colored and the union of
+    all these vertices shall be called _D_.
+    \n 2. No two edges in _C_ share a vertex.
+    \n 3. If _u, v ∈ D_, then _(uv) ∉ E_.\n
+
+    Links
+    -----
+
+    [Description and Transformation](https://arxiv.org/pdf/1302.5843.pdf)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the minimal maximal matching 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))_ )
+
+    ### A: int
+        \n A positive constant enforcing that no vertex has two colored edges.
+
+    ### B: int
+        \n A constant to penalize when an edge is uncolored although it would not
+        violate the coloring condition. For _d_ being the maximal degree in the graph,
+        choose _A > (d - 2)B_.
+
+    ### C: int
+        \n A constant (C < B) to minimize the number of colored edges.
+    """
+
+    name: Literal["MMM"] = "MMM"
+    graph: Dict[str, Dict[str, Dict[str, float]]] = Field(name="graph")  # type: ignore
+    A: int = 10
+    B: int = 2
+    C: int = 1

luna_sdk/schemas/use_cases/minimal_spanning_tree.py

@@ -0,0 +1,87 @@
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+from luna_sdk.schemas.use_cases.type_aliases import NestedDictGraph
+
+
+class MinimalSpanningTree(UseCase):
+    """
+    # Minimal Spanning Tree with maximal degree constraint
+
+    Description
+    -----------
+
+    The Minimal Spanning Tree problem tries to find a spanning tree over all nodes in a
+    given input graph such that the cost of the covered edges (the sum of the weights
+    inside the tree) is minimal. The addition maximal degree constraint, i.e. limiting
+    the degree of the tree at each node to a maximum value, makes this problem NP-hard.
+
+    Convention on depth index of vertex and edge:
+    Zero index is vertex root and all the edges leaving from root, etc.
+    That means there are N/2 possible depths for edges and N/2 + 1 possible depths for
+    vertices.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Assume we have a graph with _m_ nodes, _n_ edges, a max degree of _k_, and the qubit
+    vector _q_.
+    Then, for _i = 0, ..., n-1_, _q[i] = 1_ iff. edge _i_ is included in the tree.
+    Variables _n, ..., n + ⌈ m / 2 ⌉_ keep track of the depth of a node in the tree.
+    Now, let _a := n + ⌈ m / 2 ⌉_. Variables _a, ..., a + 2 * n_ tell for each edge in
+    the graph which vertex is closer to the root of the tree.
+    Finally, with _b := a * 2 * n_, the variables
+    _b, ..., b + m * ⌊ log2(maxDegree) + 1 ⌋_ count the degree of a node in the tree.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Degree-constrained_spanning_tree),
+    [Without degree constraint](https://en.wikipedia.org/wiki/Minimum_spanning_tree)
+
+    [Transformation](https://arxiv.org/abs/1302.5843)
+
+    Attributes
+    ----------
+
+    ### graph: Dict[int, Dict[int, Dict[str, float]]
+        \n Problem graph for the minimal spanning tree problem in form of nested
+        dictionaries. Each vertex needs to be weighted.
+        \n (e.g. Wikipedia example
+        \n _{
+            0: {1: {"weight": 1}, 3: {"weight": 4}, 4: {"weight": 3}},
+            1: {3: {"weight": 4}, 4: {"weight": 2}},
+            2: {4: {"weight": 4}, 5: {"weight": 5}},
+            3: {4: {"weight": 4}},
+            4: {5: {"weight": 7}}
+        }_ )
+
+    ### max_degree : int
+        \n The maximum degree at one joint of the tree. (e.g. 2 is a special case of the
+        travelling salesman problem).
+
+    ### A : Optional[float] = None.
+        \n The penalty factor for constraints. Can be left _None_ to be estimated from
+        the problem graph via the papers suggestion.
+        \n Default: _None_
+
+    ### B : Optional[float] = 1.
+        \n The optimization penalty factor.
+        \n Deafult: _1_
+
+    ### ba_ratio : Optional[float] = 0.1
+        \n A factor that increases or decreases the ratio between constraint and
+        optimization penalty factors in the automatic estimation. If constraints are
+        violated, this ratio needs to be decreased as the _A_ penalty needs to be
+        increased. _0.1_ is a good starting point.
+        \n Default: _0.1_
+    """
+
+    name: Literal["MST"] = "MST"
+    graph: NestedDictGraph = Field(name="graph")  # type: ignore
+    max_degree: int
+    A: Optional[float] = None
+    B: Optional[float] = 1.0
+    ba_ratio: Optional[float] = 0.1

luna_sdk/schemas/use_cases/minimum_vertex_cover.py

@@ -0,0 +1,44 @@
+from typing import Dict, Literal
+
+from pydantic import Field
+
+from luna_sdk.schemas.use_cases.base import UseCase
+
+
+class MinimumVertexCover(UseCase):
+    """
+    # 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
+    P: int = 8