luna-quantum 1.1.0__cp312-cp312-win_amd64.whl

luna_quantum/solve/use_cases/__init__.py

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

luna_quantum/solve/use_cases/arbitrage_edge_based.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class ArbitrageEdgeBased(UseCase):
+    r"""
+    # 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[call-overload]
+    penalty: float | None = None

luna_quantum/solve/use_cases/arbitrage_node_based.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class ArbitrageNodeBased(UseCase):
+    r"""
+    # 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[call-overload]
+    penalty: float | None = None
+    K: int | None = None

luna_quantum/solve/use_cases/base.py

@@ -0,0 +1,7 @@
+from luna_quantum.util.pretty_base import PrettyBase
+
+
+class UseCase(PrettyBase):
+    """Base class for all UseCases."""
+
+    name: str

luna_quantum/solve/use_cases/binary_integer_linear_programming.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class BinaryIntegerLinearProgramming(UseCase):
+    r"""
+    # 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

luna_quantum/solve/use_cases/binary_paint_shop_problem.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class BinaryPaintShopProblem(UseCase):
+    r"""
+    # Binary Paint Shop.
+
+    Description
+    -----------
+
+    The Binary Paint Shop Problem tries to minimize the color change of a paint job with
+    two colors of a sequence of cars. The sequence consists of a fixed number of cars,
+    in which each car type occurs exactly twice and these are to be colored in different
+    colors. Therefore, the car sequence consists of exactly twice as many cars as there
+    are car types.
+
+    Links
+    -----
+
+    [Transformation](https://arxiv.org/pdf/2011.03403.pdf)
+
+    Attributes
+    ----------
+    ### n_cars: int
+        \n Amount of different car types.
+
+    ### sequence: List[int]
+        \n Sequence of the cars.
+    """
+
+    name: Literal["BPSP"] = "BPSP"
+    n_cars: int
+    sequence: list[int]

luna_quantum/solve/use_cases/credit_scoring_feature_selection.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class CreditScoringFeatureSelection(UseCase):
+    r"""
+    # Feature Selection for Credit Scoring.
+
+    Description
+    -----------
+
+    Find the optimal feature subset with regard to independence and influence of
+    features for credit scoring of credit applicants.
+
+    Links
+    -----
+
+    [Transformation](https://1qbit.com/files/white-papers/1QBit-White-Paper-%E2%80%93-Optimal-Feature-Selection-in-Credit-Scoring-and-Classification-Using-a-Quantum-Annealer_-_2017.04.13.pdf)
+
+    Attributes
+    ----------
+    ### U: List[List[float]]
+        \n The matrix U is the design matrix, where each column represents a feature
+        and each row represents the specific values for a feature set.
+
+    ### V: List[int]
+        \n The binary label vector for the respective row in matrix U.
+
+    ### alpha: float
+        \n The balance between feature influence and feature independence in the range
+        _[0, 1]_.
+    """
+
+    name: Literal["CSFS"] = "CSFS"
+    U: list[list[float]]
+    V: list[int]
+    alpha: float

luna_quantum/solve/use_cases/dynamic_portfolio_optimization.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class DynamicPortfolioOptimization(UseCase):
+    r"""
+    # Dynamic Portfolio Optimization.
+
+    Description
+    -----------
+
+    The Dynamic Portfolio Optimization problem tries to find the optimal portfolio for a
+    given set of assets and a fixed investment amount. It aims to find the portfolio
+    with optimal returns for a given risk tolerance. It considers transaction costs when
+    rebalancing across multiple time steps. The optimal portfolio is defined by the
+    binary choices whether to invest in a specific asset and how much to invest in it.
+    The investment amount is split into several so called packages defined as
+    2^(package number). The total number of packages determines the granularity of the
+    result. It defines the amount of possible investment sums in one asset as well as
+    the maximum possible investment in any one asset, which is
+    2^(Number of packages) - 1.
+
+    Links
+    -----
+
+    [Transformation](https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.013006)
+
+    Attributes
+    ----------
+    ### tickers: List
+        \n Tickers of assets being tested.
+    ### mu: List[List[float]]
+        \n Expected Returns of the assets.
+        \n Shape: [time_steps][number_of_assets]
+    ### sigma: List[List[List[float]]]
+        \n Coviariance Matrix of the assets.
+        \n Shape: [time_steps][number_of_assets][number_of_assets]
+    ### packages: int
+        \n Number of packages per asset, determines granularity of investment.
+        \n _Package value = 2^(package number)_
+    ### K: int
+        \n Total investment amount, which is fixed.
+    ### gamma: float
+        \n Risk Aversion Coefficient.
+        \n Range: Risk Seeking 0-100 Very Risk Averse.
+        \n Divided by factor 2 as a convention, as stated in paper.
+    ### nu: float
+        \n Transaction Cost percentage, e.g., 0.01 = 1% of transaction size.
+    ### rho: float
+        \n Total investment size constraint factor, Lagrange Multiplier.
+    """
+
+    name: Literal["DPO"] = "DPO"
+    tickers: list[str | int]
+    mu: list[list[float]]
+    sigma: list[list[list[float]]]
+    packages: int
+    K: int
+    gamma: float
+    nu: float
+    rho: float

luna_quantum/solve/use_cases/exact_cover.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class ExactCover(UseCase):
+    r"""
+    # Exact Cover.
+
+    Description
+    -----------
+
+    Given a set _S_ and a list of subsets of _S_, an exact cover is a family _C_ of
+    these subsets so that all elements of _S_ are contained in exactly one subset of
+    _C_. For a set _S_ and a list of subsets of _S_, the Exact Cover problem tries to
+    find the smallest exact cover, i.e. the one that uses the least subsets.
+
+    Q-Bit Interpretation
+    --------------------
+
+    Subset _i_ is part of the exact cover iff. qubit _i_ is 1.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Exact_cover)
+
+    [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 _ExactCover.gen_subsets_matrix([1, 2, 3], [[1, 2], [2, 3], [3]])_
+
+    ### A: int
+        \n A constant enforcing the exact cover of the solution.
+
+    ### B: int
+        \n A constant (_A > nB_) helping find the smallest exact cover.
+    """
+
+    name: Literal["EC"] = "EC"
+    subset_matrix: list[list[int]]
+    A: int = 2
+    B: int = 2

luna_quantum/solve/use_cases/flight_gate_assignment.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class FlightGateAssignment(UseCase):
+    r"""
+    # Flight Gate Assignment.
+
+    Description
+    -----------
+
+    Flight Gate Assignment is a highly relevant optimization problem in airport
+    management. It tries to minimize the total transit time of passengers, considering
+    three typical parts of passenger flow in an airport:
+    \n 1) After a flight, passengers claim their baggage and leave the airport.
+    \n 2) Other passengers switch from one plane to another to get a connecting flight.
+    \n 3) A third group of passengers pass the security check and leave with a flight.
+
+    Links
+    -----
+
+    [Description and Transformation](https://arxiv.org/pdf/1811.09465.pdf)
+
+    Attributes
+    ----------
+    ### n_flights: int
+        \n Number of flights.
+
+    ### n_gates: int
+        \n Number of gates.
+
+    ### n_passengers: List[Tuple[int, int]]
+        \n Number of passengers arriving and departing with each flight.
+        \n Example: _n_passengers[3][departure_index]_, gives us the number of
+        passengers departing with flight _3_.
+
+    ### time_gates: List[Tuple[float, float]]
+        \n The time it takes between every gate and check-in (when leaving) or the gate
+        and baggage claim (when arriving).
+        \n Example: _time_gates[0][arriving_index]_, gives us the time it takes to go
+        from gate _0_ to baggage claim.
+
+    ### time_flights: List[Tuple[float, float]]
+        \n The time at which a flight arrives/leaves.
+        \n Example: _time_flights[2][departure_index]_, gives us the time at which
+        flight 2 departs.
+
+    ### transfer_passengers: List[List[int]]
+        \n Matrix with the information of the passengers transferring from one flight to
+        another.
+        \n Example: _transfer_passengers[2][5]_, gives the number of passengers
+        transferring from flight 2 to flight 5.
+
+    ### time_between_gates: List[List[float]]
+        \n Gives the time it takes to go from one gate to another.
+
+    ### t_buf: float
+        \n Time needed for a gate to be free after a flight has departed.
+
+    ### arrival_index, departure_index: int
+        \n Index to subscribe the variables _time_gates_, _n_passengers_,
+        _time_gates_, _time_flights_.
+        \n One of these variables needs to be _0_, the other _1_.
+    """
+
+    name: Literal["FGO"] = "FGO"
+    n_flights: int
+    n_gates: int
+    n_passengers: list[tuple[int, int]]
+    time_gates: list[tuple[float, float]]
+    time_flights: list[tuple[float, float]]
+    transfer_passengers: list[list[int]]
+    time_between_gates: list[list[float]]
+    t_buf: float
+    arrival_index: int = 0
+    departure_index: int = 1

luna_quantum/solve/use_cases/graph_coloring.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import Field
+
+from luna_quantum.solve.use_cases.base import UseCase
+
+
+class GraphColoring(UseCase):
+    r"""
+    # Graph Coloring.
+
+    Description
+    -----------
+
+    The Graph Coloring problem tries to color the nodes of a graph with a given number
+    of different colors so that no adjacent nodes have the same color.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Graph_coloring)
+
+    [Transformation](https://arxiv.org/pdf/1811.11538.pdf)
+
+    Attributes
+    ----------
+    ### graph: Dict[int, Dict[int, Dict[str, float]]]
+        \n Problem graph for the graph coloring 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))_ )
+
+    ### n_colors: int
+        \n Number of different colors.
+    """
+
+    name: Literal["GC"] = "GC"
+    graph: dict[str, dict[str, dict[str, float]]] = Field(name="graph")  # type: ignore[call-overload]
+    n_colors: int
+    P: int = 4

luna_quantum/solve/use_cases/graph_isomorphism.py

@@ -0,0 +1,52 @@
+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 GraphIsomorphism(UseCase):
+    r"""
+    # Graph Isomorphism.
+
+    Description
+    -----------
+
+    The Graph Isomorphism problem tries to find out whether two graphs _G1_ and _G2_are
+    isomorphic, i.e. there exists a bijective, edge-invariant vertex mapping from _G1_
+    to _G2_.
+
+    Links
+    -----
+
+    [Wikipedia](https://en.wikipedia.org/wiki/Graph_isomorphism)
+
+    [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 first graph (in form of nested dictionaries) to check for isomorphism.
+        \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 second graph (in form of nested dictionaries) to check for isomorphism.
+        \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
+        \n A penalty value enforcing the bijectivity of the isomorphism.
+
+    ### b: float
+        \n A penalty value (b > a) enforcing the edge-invariance of the isomorphism.
+    """
+
+    name: Literal["GI"] = "GI"
+    graph1: NestedDictIntGraph = Field(name="graph")  # type: ignore[call-overload]
+    graph2: NestedDictIntGraph = Field(name="graph")  # type: ignore[call-overload]
+    a: float = 1
+    b: float = 2