classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/interface/generator/arith/binary_ops.py

@@ -36,6 +36,14 @@ from classiq.model_expansions.arithmetic import NumericAttributes
 from classiq.model_expansions.arithmetic_compute_result_attrs import (
     compute_result_attrs_add,
     compute_result_attrs_assign,
+    compute_result_attrs_bitwise_and,
+    compute_result_attrs_bitwise_or,
+    compute_result_attrs_bitwise_xor,
+    compute_result_attrs_lshift,
+    compute_result_attrs_modulo,
+    compute_result_attrs_multiply,
+    compute_result_attrs_power,
+    compute_result_attrs_rshift,
     compute_result_attrs_subtract,
 )
 
@@ -225,31 +233,6 @@ class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
             raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
         return self
 
-    @staticmethod
-    def _is_signed(arg: Union[int, RegisterArithmeticInfo]) -> bool:
-        if isinstance(arg, RegisterArithmeticInfo):
-            return arg.is_signed
-        return arg < 0
-
-    def _get_result_register(self) -> RegisterArithmeticInfo:
-        required_size = self._aligned_inputs_max_length()
-        is_signed = self._include_sign and (
-            self._is_signed(self.left_arg) or self._is_signed(self.right_arg)
-        )
-        return RegisterArithmeticInfo(
-            size=self.output_size or required_size, is_signed=is_signed
-        )
-
-    def _aligned_inputs_max_length(self) -> int:
-        left_signed: bool = argument_utils.is_signed(self.left_arg)
-        right_signed: bool = argument_utils.is_signed(self.right_arg)
-        return max(
-            argument_utils.integer_part_size(self.right_arg)
-            + int(left_signed and not right_signed),
-            argument_utils.integer_part_size(self.left_arg)
-            + int(right_signed and not left_signed),
-        )
-
 
 class BinaryOpWithFloatInputs(BinaryOpParams[RegisterOrConst, RegisterOrConst]):
     pass
@@ -258,10 +241,42 @@ class BinaryOpWithFloatInputs(BinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class BitwiseAnd(BinaryOpWithIntInputs):
     output_name = "bitwise_and"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_and(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 class BitwiseOr(BinaryOpWithIntInputs):
     output_name = "bitwise_or"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_or(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 # TODO: fix diamond inheritance
 class BitwiseXor(
@@ -269,6 +284,22 @@ class BitwiseXor(
 ):
     output_name = "bitwise_xor"
 
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
+        )
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_xor(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+        )
+
 
 class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
@@ -467,29 +498,18 @@ class Multiplier(BinaryOpWithFloatInputs):
             argument_utils.limit_fraction_places(self.right_arg, self.machine_precision)
         )
 
-    @staticmethod
-    def _get_bounds(
-        args: tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
-    ) -> tuple[float, float]:
-        extremal_values = [
-            left * right
-            for left in argument_utils.bounds(args[0])
-            for right in argument_utils.bounds(args[1])
-        ]
-        return (
-            number_utils.limit_fraction_places(min(extremal_values), machine_precision),
-            number_utils.limit_fraction_places(max(extremal_values), machine_precision),
-        )
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        fraction_places = min(self.machine_precision, self.expected_fraction_places())
-        left_arg = argument_utils.limit_fraction_places(
+        left_attrs = NumericAttributes.from_type_or_constant(
             self.left_arg, self.machine_precision
         )
-        right_arg = argument_utils.limit_fraction_places(
+        right_attrs = NumericAttributes.from_type_or_constant(
             self.right_arg, self.machine_precision
         )
-        bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, self.machine_precision
+        )
+        fraction_places = result_attrs.fraction_digits
+        bounds = result_attrs.bounds
         if self.output_size:
             if fraction_places:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
@@ -498,10 +518,8 @@ class Multiplier(BinaryOpWithFloatInputs):
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
 
-        size = self.output_size or self._get_output_size(
-            bounds, fraction_places, left_arg, right_arg
-        )
-        is_signed = self._include_sign and min(bounds) < 0
+        size = self.output_size or result_attrs.size
+        is_signed = self._include_sign and result_attrs.is_signed
         return RegisterArithmeticInfo(
             size=size,
             fraction_places=fraction_places,
@@ -514,25 +532,6 @@ class Multiplier(BinaryOpWithFloatInputs):
             ),
         )
 
-    @staticmethod
-    def _get_output_size(
-        bounds: tuple[float, float],
-        fraction_places: int,
-        left_arg: Union[RegisterArithmeticInfo, float],
-        right_arg: Union[RegisterArithmeticInfo, float],
-    ) -> int:
-        if isinstance(left_arg, float) and left_arg == 1.0:
-            assert isinstance(right_arg, RegisterArithmeticInfo)
-            return right_arg.size
-        elif isinstance(right_arg, float) and right_arg == 1.0:
-            assert isinstance(left_arg, RegisterArithmeticInfo)
-            return left_arg.size
-        if bounds[0] == 0 and bounds[1] == 0:
-            return max(1, fraction_places)
-
-        integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
-        return integer_part_size + fraction_places
-
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return max(
             0, self.expected_fraction_places() - self.result_register.fraction_places
@@ -592,43 +591,22 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
             * self.right_arg
         )
 
-    def _get_result_bounds(self) -> tuple[float, float]:
-        bounds = [
-            number_utils.limit_fraction_places(
-                bound, machine_precision=self.machine_precision
-            )
-            for bound in self.left_arg.bounds
-        ]
-        if (self.right_arg % 2) or min(bounds) >= 0 or max(bounds) <= 0:
-            return (
-                number_utils.limit_fraction_places(
-                    bounds[0] ** self.right_arg,
-                    machine_precision=self.machine_precision,
-                ),
-                number_utils.limit_fraction_places(
-                    bounds[1] ** self.right_arg,
-                    machine_precision=self.machine_precision,
-                ),
-            )
-        return 0.0, number_utils.limit_fraction_places(
-            max(abs(bound) for bound in bounds) ** self.right_arg,
-            machine_precision=self.machine_precision,
-        )
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
         if self.output_size:
             return RegisterArithmeticInfo(size=self.output_size)
 
-        fraction_places = min(self.machine_precision, self.expected_fraction_places())
-        bounds = self._get_result_bounds()
-        size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
-        if bounds[0] == 0 and bounds[1] == 0:
-            size = max(1, fraction_places)
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_power(
+            left_attrs, self.right_arg, self.machine_precision
+        )
+
         return RegisterArithmeticInfo(
-            size=size,
-            is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
-            fraction_places=fraction_places,
-            bounds=bounds,
+            size=result_attrs.size,
+            is_signed=result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds,
         )
 
     def _get_inner_action_garbage_size(
@@ -709,13 +687,17 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         return max(self.left_arg.size + extra_result_lsbs - self.output_size, 0)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        new_fraction_places = max(self.left_arg.fraction_places - self.right_arg, 0)
-        new_integer_part_size = self.left_arg.integer_part_size + self.right_arg
-        required_size = new_integer_part_size + new_fraction_places
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_lshift(
+            left_attrs, self.right_arg, self.machine_precision
+        )
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
-            is_signed=self._include_sign and self.left_arg.is_signed,
-            fraction_places=new_fraction_places,
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds if not self.output_size else None,
         )
 
 
@@ -755,15 +737,17 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        min_size: int = max(self.left_arg.size - self.right_arg, 1)
-        new_fraction_places = self._shifted_fraction_places(
-            arg=self.left_arg, shift=self.right_arg
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_rshift(
+            left_attrs, self.right_arg, self.machine_precision
         )
-        required_size = max(min_size, new_fraction_places)
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
-            is_signed=self._include_sign and self.left_arg.is_signed,
-            fraction_places=new_fraction_places,
+            size=self.output_size or result_attrs.size,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds if not self.output_size else None,
         )
 
 
@@ -822,7 +806,15 @@ class Modulo(EffectiveUnaryOpParams[int]):
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        size = round(math.log2(self.right_arg))
-        if size <= 0:
-            raise ClassiqValueError("Cannot use a quantum expression with zero size")
-        return RegisterArithmeticInfo(size=size, is_signed=False, fraction_places=0)
+        left_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.left_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_modulo(
+            left_attrs, self.right_arg, self.machine_precision
+        )
+        return RegisterArithmeticInfo(
+            size=result_attrs.size,
+            is_signed=result_attrs.is_signed,
+            fraction_places=result_attrs.fraction_digits,
+            bounds=result_attrs.bounds,
+        )

classiq/interface/generator/arith/extremum_operations.py

@@ -18,6 +18,12 @@ from classiq.interface.generator.arith.binary_ops import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_max,
+    compute_result_attrs_min,
+)
+
 Numeric = (float, int)
 
 
@@ -55,11 +61,6 @@ class Extremum(ArithmeticOperationParams):
     def get_params_inplace_options(self) -> Iterable["Extremum"]:
         return ()
 
-    @classmethod
-    @abc.abstractmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        pass
-
     @staticmethod
     def _less_qubits_arg(
         arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -78,40 +79,15 @@ class Extremum(ArithmeticOperationParams):
         pass
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_left_arg = argument_utils.limit_fraction_places(
+        left_attrs = NumericAttributes.from_type_or_constant(
             self.left_arg, self.machine_precision
         )
-        eff_right_arg = argument_utils.limit_fraction_places(
+        right_attrs = NumericAttributes.from_type_or_constant(
             self.right_arg, self.machine_precision
         )
-        if argument_utils.arg_bounds_overlap((eff_left_arg, eff_right_arg)):
-            return self._get_general_case_result_register(eff_left_arg, eff_right_arg)
-        return argument_utils.as_arithmetic_info(
-            self.preferred_arg(eff_left_arg, eff_right_arg)
-        )
-
-    def _get_general_case_result_register(
-        self, eff_left_arg: RegisterOrConst, eff_right_arg: RegisterOrConst
-    ) -> RegisterArithmeticInfo:
-        integer_part_size = max(
-            argument_utils.integer_part_size(eff_left_arg),
-            argument_utils.integer_part_size(eff_right_arg),
-        )
-        fraction_places = max(
-            argument_utils.fraction_places(eff_left_arg),
-            argument_utils.fraction_places(eff_right_arg),
-        )
-        required_size = integer_part_size + fraction_places
-        bounds = (
-            self._bound_calculator(
-                argument_utils.lower_bound(eff_left_arg),
-                argument_utils.lower_bound(eff_right_arg),
-            ),
-            self._bound_calculator(
-                argument_utils.upper_bound(eff_left_arg),
-                argument_utils.upper_bound(eff_right_arg),
-            ),
-        )
+        result_attrs = self._compute_result_attrs(left_attrs, right_attrs)
+        bounds = result_attrs.bounds
+        fraction_places = result_attrs.fraction_digits
         if self.output_size:
             if fraction_places:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
@@ -119,8 +95,8 @@ class Extremum(ArithmeticOperationParams):
                 size=self.output_size, is_signed=False, fraction_places=0
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
-        size = self.output_size or required_size
-        is_signed = self._include_sign and min(bounds) < 0
+        size = self.output_size or result_attrs.size
+        is_signed = self._include_sign and result_attrs.is_signed
         return RegisterArithmeticInfo(
             size=size,
             fraction_places=fraction_places,
@@ -133,14 +109,16 @@ class Extremum(ArithmeticOperationParams):
             ),
         )
 
+    @abc.abstractmethod
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        pass
+
 
 class Min(Extremum):
     output_name = "min_value"
 
-    @classmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        return min(arg1, arg2)
-
     @classmethod
     def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -152,14 +130,17 @@ class Min(Extremum):
             return arg2
         return cls._less_qubits_arg(arg1, arg2)
 
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        return compute_result_attrs_min(
+            [left_attrs, right_attrs], self.machine_precision
+        )
+
 
 class Max(Extremum):
     output_name = "max_value"
 
-    @classmethod
-    def _bound_calculator(cls, arg1: float, arg2: float) -> float:
-        return max(arg1, arg2)
-
     @classmethod
     def preferred_arg(
         cls, arg1: RegisterOrConst, arg2: RegisterOrConst
@@ -170,3 +151,10 @@ class Max(Extremum):
         if max2 > max1:
             return arg2
         return cls._less_qubits_arg(arg1, arg2)
+
+    def _compute_result_attrs(
+        self, left_attrs: NumericAttributes, right_attrs: NumericAttributes
+    ) -> NumericAttributes:
+        return compute_result_attrs_max(
+            [left_attrs, right_attrs], self.machine_precision
+        )

classiq/interface/generator/arith/number_utils.py

@@ -105,7 +105,10 @@ def bounds_to_attributes(
     lb: float, ub: float, fraction_places: int, machine_precision: int
 ) -> tuple[int, bool, int]:
     fraction_places = min(fraction_places, machine_precision)
-    integers = bounds_to_integer_part_size(lb, ub)
+    if lb == ub == 0:
+        integers = 0
+    else:
+        integers = bounds_to_integer_part_size(lb, ub)
     return max(1, integers + fraction_places), lb < 0, fraction_places
 
 

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -3,7 +3,6 @@ from typing_extensions import TypeAlias
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
-from classiq.interface.hardware import Provider
 
 Code: TypeAlias = str
 CodeAndSyntax: TypeAlias = tuple[Code, QuantumInstructionSet]
@@ -14,14 +13,6 @@ INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
     QuantumInstructionSet.INTERNAL: QuantumFormat.EXECUTION_SERIALIZATION,
 }
-VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
-    Provider.CLASSIQ: QuantumInstructionSet.QASM,
-    Provider.IONQ: QuantumInstructionSet.IONQ,
-    Provider.AZURE_QUANTUM: QuantumInstructionSet.QSHARP,
-    Provider.IBM_QUANTUM: QuantumInstructionSet.QASM,
-    Provider.AMAZON_BRAKET: QuantumInstructionSet.QASM,
-}
-DEFAULT_INSTRUCTION_SET = QuantumInstructionSet.QASM
 _MAXIMUM_STRING_LENGTH = 250
 
 

classiq/interface/generator/compiler_keywords.py

@@ -2,6 +2,8 @@ EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
 INPLACE_ARITH_AUX_VAR_PREFIX = "_tmp"
+THEN_KEYWORD = "then"
+ELSE_KEYWORD = "else"
 
 
 def generate_original_function_name(name: str) -> str:

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -4,8 +4,6 @@ CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",
-    "log_normal_finance_post_process",
-    "gaussian_finance_post_process",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",

classiq/interface/generator/function_param_list.py

@@ -1,14 +1,138 @@
 import itertools
 
+from classiq.interface.generator.amplitude_loading import AmplitudeLoading
+from classiq.interface.generator.arith.arithmetic import Arithmetic
+from classiq.interface.generator.arith.binary_ops import (
+    Adder,
+    BitwiseAnd,
+    BitwiseOr,
+    BitwiseXor,
+    CyclicShift,
+    Equal,
+    GreaterEqual,
+    GreaterThan,
+    LessEqual,
+    LessThan,
+    LShift,
+    Modulo,
+    Multiplier,
+    NotEqual,
+    Power,
+    RShift,
+    Subtractor,
+)
+from classiq.interface.generator.arith.extremum_operations import Max, Min
+from classiq.interface.generator.arith.logical_ops import LogicalAnd, LogicalOr
+from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation, Sign
+from classiq.interface.generator.commuting_pauli_exponentiation import (
+    CommutingPauliExponentiation,
+)
+from classiq.interface.generator.copy import Copy
+from classiq.interface.generator.entangler_params import (
+    GridEntangler,
+    HypercubeEntangler,
+    TwoDimensionalEntangler,
+)
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
-from classiq.interface.generator.function_param_list_without_self_reference import (
-    function_param_library_without_self_reference,
+from classiq.interface.generator.hadamard_transform import HadamardTransform
+from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
+    Exponentiation,
+)
+from classiq.interface.generator.hamiltonian_evolution.qdrift import QDrift
+from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (
+    SuzukiTrotter,
+)
+from classiq.interface.generator.hardware_efficient_ansatz import (
+    HardwareEfficientAnsatz,
+)
+from classiq.interface.generator.hartree_fock import HartreeFock
+from classiq.interface.generator.hva import HVA
+from classiq.interface.generator.identity import Identity
+from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
+from classiq.interface.generator.mcu import Mcu
+from classiq.interface.generator.mcx import Mcx
+from classiq.interface.generator.qft import QFT
+from classiq.interface.generator.qsvm import QSVMFeatureMap
+from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
+from classiq.interface.generator.reset import Reset
+from classiq.interface.generator.standard_gates.standard_gates_param_list import (
+    standard_gate_function_param_library,
+)
+from classiq.interface.generator.standard_gates.u_gate import UGate
+from classiq.interface.generator.state_preparation import (
+    BellStatePreparation,
+    ComputationalBasisStatePreparation,
+    ExponentialStatePreparation,
+    GHZStatePreparation,
+    StatePreparation,
+    UniformDistributionStatePreparation,
+    WStatePreparation,
 )
-from classiq.interface.generator.qpe import PhaseEstimation
+from classiq.interface.generator.ucc import UCC
+from classiq.interface.generator.unitary_gate import UnitaryGate
+from classiq.interface.generator.user_defined_function_params import CustomFunction
 
 function_param_library: FunctionParamLibrary = FunctionParamLibrary(
     param_list=itertools.chain(
-        function_param_library_without_self_reference.param_list,
-        {PhaseEstimation},
+        {
+            StatePreparation,
+            ComputationalBasisStatePreparation,
+            UniformDistributionStatePreparation,
+            BellStatePreparation,
+            GHZStatePreparation,
+            WStatePreparation,
+            ExponentialStatePreparation,
+            QFT,
+            BitwiseAnd,
+            BitwiseOr,
+            BitwiseXor,
+            BitwiseInvert,
+            Adder,
+            Arithmetic,
+            Sign,
+            Equal,
+            NotEqual,
+            GreaterThan,
+            GreaterEqual,
+            LessThan,
+            LessEqual,
+            Negation,
+            LogicalAnd,
+            LogicalOr,
+            Subtractor,
+            RShift,
+            LShift,
+            CyclicShift,
+            Modulo,
+            TwoDimensionalEntangler,
+            HypercubeEntangler,
+            GridEntangler,
+            Mcx,
+            Mcu,
+            CustomFunction,
+            HardwareEfficientAnsatz,
+            UnitaryGate,
+            LinearPauliRotations,
+            Multiplier,
+            Power,
+            HartreeFock,
+            UCC,
+            Min,
+            Max,
+            Exponentiation,
+            CommutingPauliExponentiation,
+            SuzukiTrotter,
+            QDrift,
+            Identity,
+            RandomizedBenchmarking,
+            HVA,
+            UGate,
+            AmplitudeLoading,
+            QSVMFeatureMap,
+            HadamardTransform,
+            Copy,
+            Reset,
+        },
+        standard_gate_function_param_library.param_list,
     )
 )