amplify-quantum 1.0.0__py3-none-any.whl

amplify_quantum/__init__.py

@@ -0,0 +1,92 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+try:
+    # ruff: disable[F401]
+    import qiskit
+    import qiskit_aer
+    import qiskit_ibm_runtime
+    import qulacs
+    import scipy
+    import typing_extensions
+    # ruff: enable[F401]
+except ImportError:
+    pass
+else:
+    from .algo.base import QuantumAlgoProtocol
+    from .algo.qaoa import (
+        QAOA,
+        QAOADurations,
+        QAOAHistoryItem,
+        QAOAResult,
+        QAOAType,
+    )
+    from .algo.rqaoa import (
+        RQAOA,
+        NormalElimination,
+        RQAOADurations,
+        RQAOAHistoryItem,
+        RQAOAResult,
+        RQAOAType,
+        UnintentionalElimination,
+    )
+    from .circuit.qiskit import QiskitCircuit
+    from .circuit.qulacs import QulacsCircuit
+    from .client.aer import AerClient
+    from .client.aqt import AQTClient
+    from .client.base import QuantumBaseClient
+    from .client.braketsimulator import BraketSimulatorClient
+    from .client.ibm import IBMClient
+    from .client.ionq import IonQClient
+    from .client.iqm import IQMClient
+    from .client.qulacs import QulacsClient
+    from .client.rigetti import RigettiClient
+    from .minimize.base import MinimizeProtocol, MinimizeResult
+    from .minimize.no_op import NoOpMinimize, NoOpMinimizeResult
+    from .minimize.scipy import ScipyMinimize, ScipyMinimizeOptions, ScipyMinimizeResult
+    from .sampler.base import IsingSeqFreqList, SamplerProtocol, SamplingDurations
+    from .sampler.braket import BraketJobMeta
+    from .sampler.qiskit import AerDeviceType, QiskitJobMeta
+    from .sampler.qulacs import QulacsJobMeta
+
+__all__ = [
+    "QAOA",
+    "RQAOA",
+    "AQTClient",
+    "AerClient",
+    "AerDeviceType",
+    "BraketJobMeta",
+    "BraketSimulatorClient",
+    "IBMClient",
+    "IQMClient",
+    "IonQClient",
+    "IsingSeqFreqList",
+    "MinimizeProtocol",
+    "MinimizeResult",
+    "NoOpMinimize",
+    "NoOpMinimizeResult",
+    "NormalElimination",
+    "QAOADurations",
+    "QAOAHistoryItem",
+    "QAOAResult",
+    "QAOAType",
+    "QiskitCircuit",
+    "QiskitJobMeta",
+    "QuantumAlgoProtocol",
+    "QuantumBaseClient",
+    "QulacsCircuit",
+    "QulacsClient",
+    "QulacsJobMeta",
+    "RQAOADurations",
+    "RQAOAHistoryItem",
+    "RQAOAResult",
+    "RQAOAType",
+    "RigettiClient",
+    "SamplerProtocol",
+    "SamplingDurations",
+    "ScipyMinimize",
+    "ScipyMinimizeOptions",
+    "ScipyMinimizeResult",
+    "UnintentionalElimination",
+]

amplify_quantum/__version__.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = None

amplify_quantum/algo/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.

amplify_quantum/algo/base.py

@@ -0,0 +1,76 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Final, Literal, Protocol, overload
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from amplify import AcceptableDegrees, CustomClientResultProtocol, Model
+
+    from amplify_quantum.sampler.base import SamplerProtocol, SamplingMeta_co
+
+
+class QuantumAlgoProtocol(Protocol):
+    """Protocol for quantum optimization algorithms.
+
+    Implement this protocol to define a custom algorithm compatible with any
+    :class:`~amplify.QuantumBaseClient` subclass. A conforming class
+    must declare :attr:`acceptable_degrees`, a :attr:`Parameters` class, and a
+    static :meth:`run` method.
+    """
+
+    Parameters: Final[type]
+    """Configuration class for the algorithm. Instances are passed to :meth:`run`
+    and to :attr:`acceptable_degrees` when it is a callable."""
+
+    acceptable_degrees: Final[
+        AcceptableDegrees
+        | Callable[
+            [
+                Any  # QuantumAlgoProtocol.Parameters
+            ],
+            AcceptableDegrees,
+        ]
+    ]
+    """Polynomial degrees accepted by the algorithm's objective function.
+    Either a static :class:`~amplify.AcceptableDegrees` value, or a callable
+    that takes a :attr:`Parameters` instance and returns one."""
+
+    @overload
+    @staticmethod
+    def run(
+        sampler: SamplerProtocol[SamplingMeta_co, Any],
+        model: Model,
+        parameters: Any,  # noqa: ANN401
+        dry_run: Literal[False],
+    ) -> CustomClientResultProtocol: ...
+    @overload
+    @staticmethod
+    def run(
+        sampler: SamplerProtocol[SamplingMeta_co, Any],
+        model: Model,
+        parameters: Any,  # noqa: ANN401
+        dry_run: Literal[True],
+    ) -> None: ...
+
+    @staticmethod
+    def run(
+        sampler: SamplerProtocol[SamplingMeta_co, Any], model: Model, parameters: Any, dry_run: bool = False
+    ) -> CustomClientResultProtocol | None:
+        """Run the algorithm on the given model.
+
+        Args:
+            sampler (SamplerProtocol[SamplingMeta_co, Any]): Backend sampler that executes quantum circuits.
+            model (Model): The optimization model to solve.
+            parameters (Any): Algorithm-specific configuration (e.g., :class:`QAOA.Parameters`).
+            dry_run (bool): If ``True``, validate inputs without executing circuits and return ``None``.
+
+        Returns:
+            CustomClientResultProtocol | None: The algorithm result, or ``None`` if *dry_run* is ``True``.
+        """
+        ...

amplify_quantum/algo/qaoa/__init__.py

@@ -0,0 +1,42 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+from .components import (
+    CostPhaseSeparator,
+    IdentityPhaseSeparator,
+    UnconstrainedQAOAProblem,
+    UniformSuperpositionInitialState,
+    XMixer,
+)
+from .interface import QAOA, QAOAType
+from .type import (
+    InitialStateProtocol,
+    MixerProtocol,
+    PhaseSeparatorProtocol,
+    QAOADurations,
+    QAOAHistoryItem,
+    QAOAImplProtocol,
+    QAOAProblemProtocol,
+    QAOAResult,
+)
+
+__all__ = [
+    "QAOA",
+    "CostPhaseSeparator",
+    "IdentityPhaseSeparator",
+    "InitialStateProtocol",
+    "MixerProtocol",
+    "PhaseSeparatorProtocol",
+    "QAOADurations",
+    "QAOAHistoryItem",
+    "QAOAImplProtocol",
+    "QAOAProblemProtocol",
+    "QAOAResult",
+    "QAOAType",
+    "UnconstrainedQAOAProblem",
+    "UniformSuperpositionInitialState",
+    "XMixer",
+]

amplify_quantum/algo/qaoa/components.py

@@ -0,0 +1,397 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+from __future__ import annotations
+
+from itertools import islice
+from typing import TYPE_CHECKING
+
+from amplify import Degree, Matrix, Model, VariableType
+
+from amplify_quantum.algo.utility import (
+    gather_disjoint_n_hot_greedy,
+    is_satisfied_group_constraints,
+    raise_subclass_error,
+    raise_type_error,
+    validate_poly,
+)
+from amplify_quantum.circuit.base import SupportsAnsatz, SupportsAnsatzObservable, SupportsCAnsatz, SupportsHam
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Sequence
+
+    from amplify import Poly
+
+    from amplify_quantum.algo.qaoa.type import QAOAProblemProtocol
+    from amplify_quantum.circuit.base import CircuitProtocol
+
+
+def _generate_x_observable(
+    obs_class: type[SupportsAnsatzObservable], num_qubits: int, active_qubits: Iterable[int]
+) -> SupportsAnsatzObservable:
+    observable = obs_class(num_qubits)
+    for qubit in active_qubits:
+        observable.add_pauli_x(num_qubits, qubit, 1.0)
+    return observable
+
+
+def _apply_x_rotation_to_qubits(circuit: SupportsAnsatz, num_qubits: int, qubits: Iterable[int], angle: float) -> None:
+    qubit_list = list(qubits)
+    if not qubit_list:
+        return
+
+    observable_class = type(circuit).get_observable_class()
+    observable = _generate_x_observable(observable_class, num_qubits, qubit_list)
+    circuit.add_observable_rotation_gate(observable, angle, num_qubits)
+
+
+def _generate_hamiltonian(obs_class: type[SupportsHam], ising_poly: Poly, num_qubits: int) -> SupportsHam:
+    hamiltonian = obs_class(num_qubits)
+    for key, value in ising_poly:
+        if key:
+            hamiltonian.add_pauli_z(num_qubits, (i.id for i in key), value)
+    return hamiltonian
+
+
+class UniformSuperpositionInitialState:
+    """Initial state that places all active qubits in an equal superposition.
+
+    Applies a Hadamard gate to each qubit listed in ``active_qubits``.
+    Requires no variational parameters.
+    """
+
+    def num_parameters(self, problem: QAOAProblemProtocol) -> int:
+        """Return 0 — this component takes no variational parameters."""
+        _ = problem
+        return 0
+
+    def apply(self, circuit: CircuitProtocol, problem: QAOAProblemProtocol, parameters: Iterator[float]) -> None:
+        """Apply a Hadamard gate to each active qubit.
+
+        Args:
+            circuit (CircuitProtocol): The circuit to modify in place.
+            problem (QAOAProblemProtocol): Provides ``active_qubits``.
+            parameters (Iterator[float]): Unused; no parameters are consumed.
+        """
+        _ = parameters
+        if not isinstance(circuit, SupportsAnsatz):
+            raise_type_error("'circuit'", "SupportsAnsatz", circuit)
+
+        for qubit in problem.active_qubits:
+            circuit.add_h_gate(qubit)
+
+
+class CostPhaseSeparator:
+    """Phase separator that applies a rotation generated by the cost Hamiltonian.
+
+    Consumes one variational parameter per layer (the phase angle *gamma*).
+    """
+
+    def num_parameters_per_layer(self, problem: QAOAProblemProtocol, layer_index: int) -> int:
+        """Return 1 — one phase angle per layer."""
+        _ = problem
+        _ = layer_index
+        return 1
+
+    def apply_layer(
+        self, circuit: CircuitProtocol, problem: QAOAProblemProtocol, parameters: Iterator[float], layer_index: int
+    ) -> None:
+        """Apply a cost Hamiltonian rotation gate to *circuit*.
+
+        Args:
+            circuit (CircuitProtocol): The circuit to modify in place.
+            problem (QAOAProblemProtocol): Provides the Ising polynomial for the cost Hamiltonian.
+            parameters (Iterator[float]): Supplies the phase angle *gamma*.
+            layer_index (int): Zero-based index of the current QAOA layer (unused).
+        """
+        _ = layer_index
+        p = next(parameters, None)
+        if p is None:
+            raise ValueError("CostPhaseSeparator expects exactly one parameter per layer.")
+
+        if not isinstance(circuit, SupportsAnsatz):
+            raise_type_error("'circuit'", "SupportsAnsatz", circuit)
+
+        observable_class = type(circuit).get_observable_class()
+
+        if not issubclass(observable_class, SupportsHam):  # pyright: ignore[reportUnnecessaryIsInstance]
+            raise_subclass_error("observable class of 'circuit'", "SupportsHam", observable_class)
+        if not issubclass(observable_class, SupportsAnsatzObservable):  # pyright: ignore[reportUnnecessaryIsInstance]
+            raise_subclass_error("observable class of 'circuit'", "SupportsAnsatzObservable", observable_class)
+
+        hamiltonian = _generate_hamiltonian(observable_class, problem.ising_poly, problem.num_qubits)
+
+        if not isinstance(hamiltonian, SupportsAnsatzObservable):
+            raise_type_error("observable class of 'circuit'", "SupportsAnsatzObservable", circuit)
+
+        circuit.add_observable_rotation_gate(hamiltonian, p, problem.num_qubits)
+
+
+class IdentityPhaseSeparator:
+    """Phase separator that applies no gates (identity operation).
+
+    Used when the phase-separation step is handled externally or should be skipped.
+    Requires no variational parameters.
+    """
+
+    def num_parameters_per_layer(self, problem: QAOAProblemProtocol, layer_index: int) -> int:
+        """Return 0 — this component takes no variational parameters."""
+        _ = problem
+        _ = layer_index
+        return 0
+
+    def apply_layer(
+        self, circuit: CircuitProtocol, problem: QAOAProblemProtocol, parameters: Iterator[float], layer_index: int
+    ) -> None:
+        """Do nothing — identity operation.
+
+        Args:
+            circuit (CircuitProtocol): Unused.
+            problem (QAOAProblemProtocol): Unused.
+            parameters (Iterator[float]): Unused; no parameters are consumed.
+            layer_index (int): Unused.
+        """
+        _ = circuit
+        _ = problem
+        _ = layer_index
+        _ = parameters
+
+
+class XMixer:
+    """Mixer that applies a transverse-field (X) rotation to all active qubits.
+
+    Consumes one variational parameter per layer (the mixing angle *beta*).
+    """
+
+    def num_parameters_per_layer(self, problem: QAOAProblemProtocol, layer_index: int) -> int:
+        """Return 1 — one mixing angle per layer."""
+        _ = problem
+        _ = layer_index
+        return 1
+
+    def apply_layer(
+        self, circuit: CircuitProtocol, problem: QAOAProblemProtocol, parameters: Iterator[float], layer_index: int
+    ) -> None:
+        """Apply an X-rotation to each active qubit.
+
+        Args:
+            circuit (CircuitProtocol): The circuit to modify in place.
+            problem (QAOAProblemProtocol): Provides ``active_qubits``.
+            parameters (Iterator[float]): Supplies the mixing angle *beta*.
+            layer_index (int): Zero-based index of the current QAOA layer (unused).
+        """
+        _ = layer_index
+
+        p = next(parameters, None)
+        if p is None:
+            raise ValueError("XMixer expects exactly one parameter per layer.")
+
+        if not isinstance(circuit, SupportsAnsatz):
+            raise_type_error("'circuit'", "SupportsAnsatz", circuit)
+
+        _apply_x_rotation_to_qubits(circuit, problem.num_qubits, problem.active_qubits, p)
+
+
+class UnconstrainedQAOAProblem:
+    """Problem representation for standard (unconstrained) QAOA.
+
+    Converts an :class:`~amplify.Model` into an Ising polynomial and exposes
+    the qubit indices and objective evaluation needed by the QAOA circuit
+    construction. Used internally by the standard QAOA implementation.
+    """
+
+    def __init__(self, model: Model) -> None:
+        """Initialize from an optimization model.
+
+        Args:
+            model (Model): The optimization model to solve. Constraints are
+                dropped; only the objective is converted to an Ising polynomial.
+        """
+        self.ising_poly = model.to_unconstrained_poly()
+        self.active_qubits = frozenset(i.id for i in self.ising_poly.variables)
+        self.num_qubits = max(self.active_qubits) + 1 if len(self.active_qubits) > 0 else 0
+
+        validate_poly(self.ising_poly, {VariableType.Ising: Degree.HighOrder})
+
+    def compute_objective_value(self, sol: Sequence[int]) -> float | None:
+        """Evaluate the Ising cost function at the given spin assignment.
+
+        Args:
+            sol (Sequence[int]): Spin values (``+1`` or ``-1``) indexed by qubit id.
+
+        Returns:
+            float | None: The objective value.
+        """
+        val = self.ising_poly.substitute({i: sol[i.id] for i in self.ising_poly.variables})
+        if not val.is_number():
+            raise RuntimeError(f"Expected the substituted value to be a number, but got {val}.")
+        return float(val)
+
+
+class NHOTQAOAProblem:
+    """Problem representation for equality-constrained QAOA.
+
+    Converts an :class:`~amplify.Model` into an Ising polynomial while
+    separating disjoint n-hot (equality) constraints from the objective.
+    Constraints not recognized as n-hot are added as penalty terms.
+    """
+
+    def __init__(self, model: Model) -> None:
+        """Initialize from an optimization model.
+
+        Args:
+            model (Model): The optimization model to solve. Disjoint n-hot
+                constraints are separated; unrecognized constraints are added
+                as penalty terms.
+        """
+        group_list, unused_constraint = gather_disjoint_n_hot_greedy(model.constraints)
+        # objective function
+        poly = model.objective
+        if isinstance(poly, Matrix):
+            poly = poly.to_poly()
+        # penalty terms for constraints that are not in the shape of n-hot
+        for c in unused_constraint:
+            poly += c.penalty
+
+        self.ising_poly = poly
+        self.n_hot_constraints = group_list
+
+        self.constrained_indices = frozenset(i.id for group, _ in group_list for i in group)
+        self.unconstrained_indices = frozenset(
+            i.id for i in self.ising_poly.variables if i.id not in self.constrained_indices
+        )
+        self.active_qubits = self.unconstrained_indices | self.constrained_indices
+        self.num_qubits = max(
+            max(self.unconstrained_indices) + 1 if len(self.unconstrained_indices) > 0 else 0,
+            max(self.constrained_indices) + 1 if len(self.constrained_indices) > 0 else 0,
+        )
+
+        # TODO: Poly から変数の種類ごと (Ising, Binary など) の degree を取れるようになったら  # noqa: FIX002
+        # ここではなく algo.qaoa._details._generate_hamiltonian で validate するようにする
+        validate_poly(self.ising_poly, {VariableType.Ising: Degree.HighOrder})
+
+    def compute_objective_value(self, sol: Sequence[int]) -> float | None:
+        """Evaluate the Ising cost function at the given spin assignment.
+
+        Returns ``None`` if the assignment violates any n-hot constraint.
+
+        Args:
+            sol (Sequence[int]): Spin values (``+1`` or ``-1``) indexed by qubit id.
+
+        Returns:
+            float | None: The objective value, or ``None`` if the solution is infeasible.
+        """
+        if not is_satisfied_group_constraints(sol, self.n_hot_constraints):
+            return None
+        val = self.ising_poly.substitute({i: sol[i.id] for i in self.ising_poly.variables})
+        if not val.is_number():
+            raise RuntimeError(f"Expected the substituted value to be a number, but got {val}.")
+        return float(val)
+
+
+class FeasibleInitialState:
+    """Initial state that prepares a feasible state satisfying n-hot constraints.
+
+    Applies X gates to place constrained qubits into a feasible configuration
+    and Rx rotations to unconstrained qubits.
+    """
+
+    def num_parameters(self, problem: NHOTQAOAProblem) -> int:
+        """Return the number of variational parameters (one per unconstrained qubit)."""
+        return len(problem.unconstrained_indices)
+
+    def apply(self, circuit: CircuitProtocol, problem: NHOTQAOAProblem, parameters: Iterator[float]) -> None:
+        """Prepare a feasible initial state.
+
+        Args:
+            circuit (CircuitProtocol): The circuit to modify in place.
+            problem (NHOTQAOAProblem): Provides n-hot constraints and unconstrained qubit indices.
+            parameters (Iterator[float]): Supplies Rx rotation angles for unconstrained qubits.
+        """
+        num_parameters = self.num_parameters(problem)
+        ps = list(islice(parameters, num_parameters))
+        if len(ps) != num_parameters:
+            raise ValueError(f"FeasibleInitialState expects exactly {num_parameters} parameters per layer.")
+
+        if not isinstance(circuit, SupportsCAnsatz):
+            raise_type_error("'circuit'", "SupportsCAnsatz", circuit)
+
+        for group, num_flips in problem.n_hot_constraints:
+            for i in range(num_flips):
+                circuit.add_x_gate(group[i].id)
+
+        for param_index, i in enumerate(problem.unconstrained_indices):
+            circuit.add_rx_gate(i, ps[param_index])
+
+
+def _apply_xy_rotation(circuit: SupportsCAnsatz, first: int, second: int, angle: float) -> None:
+    circuit.add_cnot_gate(first, second)
+    circuit.add_ry_gate(first, angle)
+    circuit.add_cnot_gate(second, first)
+    circuit.add_ry_gate(first, -angle)
+    circuit.add_cnot_gate(first, second)
+
+
+class ConstraintPreservingMixer:
+    """Mixer that preserves n-hot constraints using XY-rotation gates.
+
+    Applies pairwise XY rotations within each constraint group so that
+    the quantum state remains in the feasible subspace throughout the circuit.
+    """
+
+    def num_parameters_per_layer(self, problem: NHOTQAOAProblem, layer_index: int) -> int:
+        """Return the number of variational parameters per layer."""
+        _ = layer_index
+        num_parameters = 0
+        for group, _ in problem.n_hot_constraints:
+            m = len(group)
+            num_parameters += m // 2 + (m - 1) // 2
+        return num_parameters
+
+    def apply_layer(
+        self, circuit: CircuitProtocol, problem: NHOTQAOAProblem, parameters: Iterator[float], layer_index: int
+    ) -> None:
+        """Apply pairwise XY rotations within each constraint group.
+
+        Args:
+            circuit (CircuitProtocol): The circuit to modify in place.
+            problem (NHOTQAOAProblem): Provides n-hot constraint groups.
+            parameters (Iterator[float]): Supplies rotation angles for XY gates.
+            layer_index (int): Zero-based index of the current QAOA layer (unused).
+        """
+        _ = layer_index
+        num_parameters = self.num_parameters_per_layer(problem, layer_index)
+        ps = list(islice(parameters, num_parameters))
+        if len(ps) != num_parameters:
+            raise ValueError(f"ConstraintPreservingMixer expects exactly {num_parameters} parameters per layer.")
+
+        if not isinstance(circuit, SupportsCAnsatz):
+            raise_type_error("'circuit'", "SupportsCAnsatz", circuit)
+
+        param_iter = iter(ps)
+
+        for group, _ in problem.n_hot_constraints:
+            m = len(group)
+            for index in range(0, m - 1, 2):
+                _apply_xy_rotation(circuit, group[index].id, group[index + 1].id, next(param_iter))
+            for index in range(1, m - 1, 2):
+                _apply_xy_rotation(circuit, group[index].id, group[index + 1].id, next(param_iter))
+
+
+if TYPE_CHECKING:
+    from amplify_quantum.algo.qaoa.type import (
+        InitialStateProtocol,
+        MixerProtocol,
+        PhaseSeparatorProtocol,
+    )
+
+    _0: type[InitialStateProtocol] = UniformSuperpositionInitialState
+    _0 = FeasibleInitialState  # pyright: ignore[reportConstantRedefinition]
+    _1: type[PhaseSeparatorProtocol] = CostPhaseSeparator
+    _1 = IdentityPhaseSeparator  # pyright: ignore[reportConstantRedefinition]
+    _2: type[MixerProtocol] = XMixer
+    _2 = ConstraintPreservingMixer  # pyright: ignore[reportConstantRedefinition]
+    _3: type[QAOAProblemProtocol] = UnconstrainedQAOAProblem
+    _3 = NHOTQAOAProblem  # pyright: ignore[reportConstantRedefinition]

amplify_quantum/algo/qaoa/impls/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .qaoa_auto import AutoQAOAImpl
+from .qaoa_n_hot import NHOTQAOAImpl
+from .qaoa_original import OriginalQAOAImpl
+
+__all__ = ["AutoQAOAImpl", "NHOTQAOAImpl", "OriginalQAOAImpl"]

amplify_quantum/algo/qaoa/impls/qaoa_auto.py

@@ -0,0 +1,40 @@
+# Copyright (c) Fixstars Corporation and Fixstars Amplify Corporation.
+#
+# This source code is licensed under the Apache2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from amplify_quantum.algo.utility import gather_disjoint_n_hot_greedy
+
+from .qaoa_n_hot import NHOTQAOAImpl
+from .qaoa_original import OriginalQAOAImpl
+
+if TYPE_CHECKING:
+    from amplify import Model
+
+
+class AutoQAOAImpl:
+    """QAOA implementation that automatically selects the best strategy.
+
+    Returns :class:`NHOTQAOAImpl` when the model contains
+    disjoint n-hot constraints, otherwise :class:`OriginalQAOAImpl`.
+    """
+
+    def __new__(cls, model: Model, reps: int) -> NHOTQAOAImpl | OriginalQAOAImpl:
+        """Select and instantiate the best QAOA implementation for the given model.
+
+        Args:
+            model (Model): The optimization model to solve.
+            reps (int): Number of QAOA layers (circuit depth *p*).
+
+        Returns:
+            NHOTQAOAImpl | OriginalQAOAImpl: The selected implementation instance.
+        """
+        group_list, _ = gather_disjoint_n_hot_greedy(model.constraints)
+
+        if len(group_list) > 0:
+            return NHOTQAOAImpl(model, reps)
+        return OriginalQAOAImpl(model, reps)