classiq 0.104.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/interface/generator/arith/binary_ops.py

@@ -338,6 +338,30 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return isinstance(arg, float) and arg == 0
 
 
+class CanonicalAdder(FunctionParams):
+    left_size: pydantic.PositiveInt
+    extend_left: bool
+    right_size: pydantic.PositiveInt
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            DEFAULT_LEFT_ARG_NAME: RegisterArithmeticInfo(size=self.left_size),
+            DEFAULT_RIGHT_ARG_NAME: RegisterArithmeticInfo(size=self.right_size),
+        }
+        self._outputs = {**self._inputs}
+
+
+class CanonicalConstantAdder(FunctionParams):
+    left: int
+    right_size: pydantic.PositiveInt
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "right_arg": RegisterArithmeticInfo(size=self.right_size),
+        }
+        self._outputs = {**self._inputs}
+
+
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 

classiq/interface/generator/arith/number_utils.py

@@ -3,13 +3,22 @@ from typing import Final
 MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
 
-def signed_int_to_unsigned(number: int) -> int:
+def signed_int_to_unsigned(number: int, reg_size: int | None = None) -> int:
     """Return the integer value of a signed int if it would we read as un-signed in binary representation"""
-    if number >= 0:
-        return number
-
-    not_power2 = abs(number) & (abs(number) - 1) != 0
-    return number + 2 ** (number.bit_length() + 1 * not_power2)
+    signed: bool = False
+    if number < 0:
+        signed = True
+        not_power2 = abs(number) & (abs(number) - 1) != 0
+        number = number + 2 ** (number.bit_length() + 1 * not_power2)
+
+    if reg_size is not None:
+        bits = bin(number)[2:][::-1]
+        bits = bits[:reg_size]
+        if signed and len(bits) < reg_size:
+            bits += "1" * (reg_size - len(bits))
+        number = int(bits[::-1], 2)
+
+    return number
 
 
 def binary_to_int(bin_rep: str, is_signed: bool = False) -> int:

classiq/interface/generator/compiler_keywords.py

@@ -2,6 +2,7 @@ EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
 INPLACE_ARITH_AUX_VAR_PREFIX = "_tmp"
+INPLACE_CONTROL_AUX_VAR_PREFIX = "_ctmp"
 THEN_KEYWORD = "then"
 ELSE_KEYWORD = "else"
 

classiq/interface/generator/function_param_list.py

@@ -6,6 +6,8 @@ from classiq.interface.generator.arith.binary_ops import (
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
+    CanonicalAdder,
+    CanonicalConstantAdder,
     CanonicalConstantMultiplier,
     CanonicalMultiplier,
     Equal,
@@ -59,6 +61,8 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             BitwiseXor,
             BitwiseInvert,
             Adder,
+            CanonicalAdder,
+            CanonicalConstantAdder,
             Arithmetic,
             Sign,
             Equal,

classiq/interface/generator/function_params.py

@@ -46,7 +46,7 @@ END_BAD_REGISTER_ERROR_MSG = (
 )
 
 ALPHANUM_AND_UNDERSCORE = r"[0-9a-zA-Z_]*"
-NAME_REGEX = rf"_?[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
+NAME_REGEX = rf"_{{0,2}}[a-zA-Z]{ALPHANUM_AND_UNDERSCORE}"
 
 _UNVALIDATED_FUNCTIONS = ["Arithmetic", "CustomFunction"]
 

classiq/interface/generator/functions/classical_type.py

@@ -83,6 +83,9 @@ class ClassicalType(HashableASTNode):
     def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
         return {}
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {}
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -244,6 +247,11 @@ class ClassicalArray(ClassicalType):
             f"{path_expr_prefix}[0]"
         )
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.len": int
+        } | self.element_type.get_compile_time_attribute_types(f"{prefix}[0]")
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -336,6 +344,13 @@ class ClassicalTuple(ClassicalType):
             return attrs
         return attrs | raw_type.get_compile_time_attributes(path_expr_prefix)
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        raw_type = self.get_raw_type(preserve_length=True)
+        attrs: dict[str, type] = {f"{prefix}.len": int}
+        if isinstance(raw_type, ClassicalTuple):
+            return attrs
+        return attrs | raw_type.get_compile_time_attribute_types(prefix)
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -211,16 +211,29 @@ class TypeName(ClassicalType, QuantumType):
         if self.has_fields:
             for field_name, field_type in self.fields.items():
                 field_prefix = f"{path_expr_prefix}.{field_name}"
-                attrs[field_prefix] = field_type.get_compile_time_attributes(
-                    field_prefix
-                )
+                attrs |= field_type.get_compile_time_attributes(field_prefix)
         elif self.has_classical_struct_decl:
             for (
                 field_name,
                 classical_field_type,
             ) in self.classical_struct_decl.variables.items():
                 field_prefix = f"{path_expr_prefix}.{field_name}"
-                attrs[field_prefix] = classical_field_type.get_compile_time_attributes(
+                attrs |= classical_field_type.get_compile_time_attributes(field_prefix)
+        return attrs
+
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        attrs: dict[str, type] = {}
+        if self.has_fields:
+            for field_name, field_type in self.fields.items():
+                field_prefix = f"{prefix}.{field_name}"
+                attrs |= field_type.get_compile_time_attribute_types(field_prefix)
+        elif self.has_classical_struct_decl:
+            for (
+                field_name,
+                classical_field_type,
+            ) in self.classical_struct_decl.variables.items():
+                field_prefix = f"{prefix}.{field_name}"
+                attrs |= classical_field_type.get_compile_time_attribute_types(
                     field_prefix
                 )
         return attrs

classiq/interface/generator/transpiler_basis_gates.py

@@ -59,6 +59,7 @@ EXTRA_TWO_QUBIT_GATES: BasisGates = frozenset(
         "cu",
         "ch",
         "cp",
+        "iswap",
     )
 )
 

classiq/interface/generator/types/compilation_metadata.py

@@ -5,7 +5,8 @@ class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=0)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
-    _required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
+    _min_required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
+    _max_required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
     disable_perm_check: bool = Field(default=False)
     disable_const_checks: list[str] | bool = Field(default=False)
 
@@ -18,12 +19,20 @@ class CompilationMetadata(BaseModel):
         self._occupation_number = value
 
     @property
-    def required_clean_qubit(self) -> NonNegativeInt:
-        return self._required_clean_qubit
+    def min_required_clean_qubit(self) -> NonNegativeInt:
+        return self._min_required_clean_qubit
 
-    @required_clean_qubit.setter
-    def required_clean_qubit(self, value: NonNegativeInt) -> None:
-        self._required_clean_qubit = value
+    @min_required_clean_qubit.setter
+    def min_required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._min_required_clean_qubit = value
+
+    @property
+    def max_required_clean_qubit(self) -> NonNegativeInt:
+        return self._max_required_clean_qubit
+
+    @max_required_clean_qubit.setter
+    def max_required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._max_required_clean_qubit = value
 
     @property
     def has_user_directives(self) -> bool:

classiq/interface/hardware.py

@@ -34,6 +34,7 @@ class Provider(StrEnum):
     AQT = "AQT"
     CINECA = "CINECA"
     SOFTBANK = "Softbank"
+    C12 = "C12"
 
     @property
     def id(self) -> "ProviderIDEnum":

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "16"
+INTERFACE_VERSION = "17"

classiq/interface/model/model.py

@@ -10,6 +10,7 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.function_params import ArithmeticIODict
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -28,6 +29,10 @@ from classiq.interface.model.native_function_definition import (
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_type import (
+    RegisterQuantumTypeDict,
+    quantum_type_to_register_quantum_type,
+)
 from classiq.interface.model.statement_block import StatementBlock
 
 USER_MODEL_MARKER = "user"
@@ -237,3 +242,17 @@ class Model(VersionedModel, ASTNode):
             self.compressed_debug_info = None
         else:
             self.compressed_debug_info = compress_pydantic(self._debug_info)
+
+    @property
+    def measured_registers(self) -> ArithmeticIODict:
+        return self.main_func.outputs_dict
+
+    @property
+    def measured_registers_type(self) -> RegisterQuantumTypeDict:
+        return {
+            key: quantum_type_to_register_quantum_type(
+                self.main_func.port_declarations_dict[key].quantum_type,
+                self.main_func.port_declarations_dict[key].quantum_type.size_in_bits,
+            )
+            for key in self.measured_registers.keys()
+        }

classiq/interface/model/quantum_type.py

@@ -81,6 +81,9 @@ class QuantumType(HashableASTNode):
     def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
         return {}
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {}
+
 
 class QuantumScalar(QuantumType):
     @property
@@ -273,6 +276,11 @@ class QuantumBitvector(QuantumType):
             f"{path_expr_prefix}[0]"
         )
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.len": int
+        } | self.element_type.get_compile_time_attribute_types(f"{prefix}[0]")
+
     def without_symbolic_attributes(self) -> "QuantumBitvector":
         length = (
             None
@@ -322,6 +330,13 @@ class QuantumNumeric(QuantumScalar):
             attrs[f"{path_expr_prefix}.fraction_digits"] = self.fraction_digits_value
         return attrs
 
+    def get_compile_time_attribute_types(self, prefix: str) -> dict[str, type]:
+        return {
+            f"{prefix}.size": int,
+            f"{prefix}.is_signed": bool,
+            f"{prefix}.fraction_digits": int,
+        }
+
     def set_size_in_bits(self, val: int) -> None:
         super().set_size_in_bits(val)
         if self.size is not None:

classiq/interface/qubits_mapping/__init__.py

@@ -0,0 +1,4 @@
+from .qubits_mapping import FunctionScope, QubitsMapping
+from .slices import Slices
+
+__all__ = ["FunctionScope", "QubitsMapping", "Slices"]

classiq/interface/qubits_mapping/path_expr_range.py

@@ -0,0 +1,69 @@
+from functools import singledispatch
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_type import QuantumBitvector
+
+
+def get_path_expr_range(
+    var: HandleBinding, quantum_type: ConcreteQuantumType
+) -> tuple[int, int]:
+    start = 0
+    stop = quantum_type.size_in_bits
+    for var_prefix in var.prefixes()[1:]:
+        start, stop, quantum_type = _pop_var_range(var_prefix, quantum_type, start)
+    return start, stop
+
+
+@singledispatch
+def _pop_var_range(
+    var_prefix: HandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    raise ClassiqInternalExpansionError("Unexpected path expression")
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: SubscriptHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, QuantumBitvector):
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    index = var_prefix.index.to_int_value()
+    element_type = quantum_type.element_type
+    start += element_type.size_in_bits * index
+    stop = start + element_type.size_in_bits
+    return start, stop, element_type
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: SlicedHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, QuantumBitvector):
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    slice_start = var_prefix.start.to_int_value()
+    slice_stop = var_prefix.end.to_int_value()
+    stop = start + quantum_type.element_type.size_in_bits * slice_stop
+    start += quantum_type.element_type.size_in_bits * slice_start
+    return start, stop, quantum_type
+
+
+@_pop_var_range.register
+def _(
+    var_prefix: FieldHandleBinding, quantum_type: ConcreteQuantumType, start: int
+) -> tuple[int, int, ConcreteQuantumType]:
+    if not isinstance(quantum_type, TypeName) or not quantum_type.has_fields:
+        raise ClassiqInternalExpansionError("Unexpected path expression")
+    for field, field_type in quantum_type.fields.items():
+        if field == var_prefix.field:
+            stop = start + field_type.size_in_bits
+            return start, stop, field_type
+        start += field_type.size_in_bits
+    raise ClassiqInternalExpansionError("Unexpected path expression")

classiq/interface/qubits_mapping/qubits_mapping.py

@@ -0,0 +1,231 @@
+import dataclasses
+import itertools
+from collections.abc import Iterable, Iterator
+from contextlib import contextmanager
+from typing import Any, Generic, TypeGuard, TypeVar, cast
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.visitor import RetType
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelStatementsVisitor
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from .path_expr_range import get_path_expr_range
+from .slices import Slices
+
+
+@dataclasses.dataclass
+class FunctionScope:
+    variables: dict[str, ConcreteQuantumType] = dataclasses.field(default_factory=dict)
+    allocated_variables: dict[str, Slices] = dataclasses.field(default_factory=dict)
+    total_resources: int = dataclasses.field(default=0)
+
+    def add_new_var(self, var_name: str, quantum_type: ConcreteQuantumType) -> None:
+        self.variables[var_name] = quantum_type
+
+    def allocate_new_var(self, var_name: str, var_size: int) -> None:
+        new_total_resources = self.total_resources + var_size
+        self.allocated_variables[var_name] = Slices(
+            [(self.total_resources, new_total_resources)]
+        )
+        self.total_resources = new_total_resources
+
+    def bind_slices_to_var(self, var_name: str, slices: Slices) -> None:
+        self.allocated_variables[var_name] = slices
+
+
+T = TypeVar("T", bound=FunctionScope)
+
+FREE_NAME = "free"
+
+
+class QubitsMapping(Generic[T], ModelStatementsVisitor):
+    """
+    Visitor that maps quantum variables to virtual qubit slices in a quantum model.
+
+    This visitor traverses the model's quantum functions and tracks the mapping of
+    quantum variables to their virtual qubit allocations. It maintains scopes for each
+    function, tracks the call stack, and maps variables to slices representing ranges
+    of qubits. This class assumes that the visited model is a compiled qmod, which mainly
+    means that all allocations are in the main function, and the model does not contain within_apply.
+    """
+
+    def __init__(self, scope_type: type[FunctionScope] = FunctionScope) -> None:
+        super().__init__()
+        self._scope_type: type[T] = cast(type[T], scope_type)
+        self.scopes: dict[str, T] = {}
+        self._main_func_name: str
+        self._current_function: str
+
+    @property
+    def _current_scope(self) -> T:
+        return self.scopes[self._current_function]
+
+    @contextmanager
+    def _function_scoping(
+        self, func_def: NamedParamsQuantumFunctionDeclaration
+    ) -> Iterator[T]:
+        func_name = func_def.name
+        _previous_function = self._current_function
+        self._current_function = func_name
+        self.scopes[func_name] = self._initialize_function_scope(func_def)
+        yield self.scopes[func_name]
+        self._current_function = _previous_function
+
+    def _is_entry_point(self, func_name: str) -> bool:
+        return func_name == self._main_func_name
+
+    def _is_free_function_call(self, call: QuantumFunctionCall) -> bool:
+        return call.func_decl.name == FREE_NAME
+
+    def _is_function_with_definition(
+        self, func_decl: QuantumFunctionDeclaration
+    ) -> TypeGuard[NativeFunctionDefinition]:
+        return isinstance(func_decl, NativeFunctionDefinition)
+
+    def visit_Model(self, model: Model) -> RetType | None:
+        self._main_func_name = model.main_func.name
+        self._current_function = self._main_func_name
+        self.visit_BaseModel(model)
+        return None
+
+    def visit_NativeFunctionDefinition(
+        self, func: NativeFunctionDefinition
+    ) -> RetType | None:
+        if func.name in self.scopes:
+            return None
+        with self._function_scoping(func):
+            self.visit(func.body)
+        return None
+
+    def visit_Allocate(self, stat: Allocate) -> RetType | None:
+        if not self._is_entry_point(self._current_function):
+            raise ClassiqInternalError(
+                "compiled qmod can't have allocation outside of main function"
+            )
+        var_name = stat.target.name
+        var_type = self._current_scope.variables[var_name]
+        self._current_scope.allocate_new_var(stat.target.name, var_type.size_in_bits)
+        return None
+
+    def visit_VariableDeclarationStatement(
+        self, stat: VariableDeclarationStatement
+    ) -> RetType | None:
+        if isinstance(stat.qmod_type, QuantumType):
+            self._current_scope.add_new_var(stat.name, stat.qmod_type)
+        return None
+
+    def _visit_free_function_call(self, stat: QuantumFunctionCall) -> None | Any:
+        if not self._is_entry_point(self._current_function):
+            raise ClassiqInternalError(
+                "compiled qmod can't have free outside of main function"
+            )
+        input_name = stat.inputs[0].name
+        self._current_scope.allocated_variables.pop(input_name)
+        return None
+
+    def _visit_quantum_function_call(self, stat: QuantumFunctionCall) -> None | Any:
+        if self._is_free_function_call(stat):
+            self._visit_free_function_call(stat)
+            return None
+        func_decl = stat.func_decl
+        if not self._is_function_with_definition(func_decl):
+            return None
+        input_slices = self.get_call_input_slices(stat)
+        end_call_scope = self.scopes[stat.func_decl.name]
+        for port, handle in zip(func_decl.port_declarations, stat.ports):
+            if port.direction == PortDeclarationDirection.Input:
+                new_slices = Slices()
+            else:
+                relative_output = end_call_scope.allocated_variables[port.name]
+                new_slices = input_slices.mapping_virtual_slices(relative_output)
+            self._update_by_handle(handle, new_slices, port.direction)
+        return None
+
+    def visit_QuantumFunctionCall(self, stat: QuantumFunctionCall) -> RetType | None:
+        if self._is_free_function_call(stat):
+            self._visit_free_function_call(stat)
+            return None
+        self._visit_quantum_function_call(stat)
+        return None
+
+    def visit_BindOperation(self, stat: BindOperation) -> RetType | None:
+        input_slices = self._handles_to_slices(stat.in_handles)
+        for in_handle in stat.in_handles:
+            self._current_scope.allocated_variables.pop(in_handle.name)
+        start_index, end_index = 0, 0
+        for out in stat.out_handles:
+            out_var = self._current_scope.variables[out.name]
+            end_index += out_var.size_in_bits
+            new_slices = input_slices.get_virtual_slice(start_index, end_index)
+            self._update_by_handle(out, new_slices, PortDeclarationDirection.Output)
+            start_index = end_index
+        return None
+
+    def get_call_input_slices(self, stat: QuantumFunctionCall) -> Slices:
+        input_handles = (
+            handle
+            for inp, handle in zip(stat.func_decl.port_declarations, stat.ports)
+            if inp.direction.is_input
+        )
+        return self._handles_to_slices(input_handles)
+
+    def _handles_to_slices(self, handles: Iterable[ConcreteHandleBinding]) -> Slices:
+        return Slices(
+            itertools.chain.from_iterable(
+                self._handle_to_slices(handle) for handle in handles
+            )
+        )
+
+    def _handle_to_slices(self, handle: HandleBinding) -> Slices:
+        quantum_type = self._current_scope.variables[handle.name]
+        var_mapping = self._current_scope.allocated_variables[handle.name]
+        start, stop = get_path_expr_range(handle, quantum_type)
+        return var_mapping.get_virtual_slice(start, stop)
+
+    def _update_by_handle(
+        self,
+        handle: HandleBinding,
+        new_slices: Slices,
+        direction: PortDeclarationDirection,
+    ) -> None:
+        if direction == PortDeclarationDirection.Input:
+            self._current_scope.allocated_variables.pop(handle.name)
+        elif direction == PortDeclarationDirection.Output:
+            pass
+        else:
+            quantum_type = self._current_scope.variables[handle.name]
+            start, stop = get_path_expr_range(handle, quantum_type)
+            var_mapping = self._current_scope.allocated_variables[handle.name].copy()
+            var_mapping.update_virtual_slice(start, stop, new_slices)
+            new_slices = var_mapping
+        self._current_scope.bind_slices_to_var(handle.name, new_slices)
+
+    def _initialize_function_scope(
+        self, func_def: NamedParamsQuantumFunctionDeclaration
+    ) -> T:
+        function_variables = self._scope_type()
+        ports = func_def.port_declarations
+        for port in ports:
+            function_variables.add_new_var(port.name, port.quantum_type)
+            if port.direction != PortDeclarationDirection.Output:
+                function_variables.allocate_new_var(
+                    port.name, port.quantum_type.size_in_bits
+                )
+        return function_variables