classiq 0.79.1__py3-none-any.whl → 0.80.1__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -1,12 +1,14 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
@@ -123,7 +125,7 @@ class ClassicalList(ClassicalType):
         return super().is_purely_generative and self.element_type.is_purely_generative
 
     def get_raw_type(self) -> "ConcreteClassicalType":
-        raw_type = ClassicalList(element_type=self.element_type.get_raw_type())
+        raw_type = ClassicalArray(element_type=self.element_type.get_raw_type())
         if self._is_generative:
             raw_type.set_generative()
         return raw_type
@@ -144,15 +146,69 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: int
+    size: Optional[int] = None
+    length: Optional[Expression] = pydantic.Field(exclude=True, default=None)
 
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_length(cls, values: Any) -> Any:
+        if isinstance(values, dict):
+            size = values.get("size")
+            length = values.get("length")
+        else:
+            size = values.size
+            length = values.length
+        if size is not None:
+            if isinstance(values, dict):
+                values["length"] = Expression(expr=str(size))
+            else:
+                values.length = Expression(expr=str(size))
+        elif length is not None:
+            if isinstance(length, dict):
+                expr = length["expr"]
+            else:
+                expr = length.expr
+            expr_size: Optional[int] = None
+            try:  # noqa: SIM105
+                expr_size = int(expr)
+            except ValueError:
+                pass
+            if expr_size is not None:
+                if isinstance(values, dict):
+                    values["size"] = expr_size
+                else:
+                    values.size = expr_size
+        return values
+
+    @property
+    def has_length(self) -> bool:
+        return self.length is not None and self.length.is_evaluated()
+
+    @property
+    def length_value(self) -> int:
+        if not self.has_length:
+            raise ClassiqInternalExpansionError(
+                "Tried to access unevaluated length of classical array"
+            )
+        assert self.length is not None
+        return self.length.to_int_value()
+
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        return ClassicalArrayProxy(handle, self.element_type, self.size)
+        length: ExpressionValue
+        if self.length is None:
+            length = AnyClassicalValue(f"get_field({handle}, 'len')")
+        elif not self.length.is_evaluated():
+            raise ClassiqInternalExpansionError(
+                "Classical list length is not evaluated"
+            )
+        else:
+            length = self.length.value.value
+        return ClassicalArrayProxy(handle, self.element_type, length)
 
     @property
     def expressions(self) -> list[Expression]:
@@ -167,7 +223,7 @@ class ClassicalArray(ClassicalType):
         return super().is_purely_generative and self.element_type.is_purely_generative
 
     def get_raw_type(self) -> "ConcreteClassicalType":
-        raw_type = ClassicalList(element_type=self.element_type.get_raw_type())
+        raw_type = ClassicalArray(element_type=self.element_type.get_raw_type())
         if self._is_generative:
             raw_type.set_generative()
         return raw_type
@@ -208,13 +264,13 @@ class ClassicalTuple(ClassicalType):
     def get_raw_type(self) -> "ConcreteClassicalType":
         if len(self.element_types) == 0:
             return self
-        raw_type = ClassicalList(element_type=self.element_types[0].get_raw_type())
+        raw_type = ClassicalArray(element_type=self.element_types[0].get_raw_type())
         if self._is_generative:
             raw_type.set_generative()
         return raw_type
 
     @property
-    def size(self) -> int:
+    def length(self) -> int:
         return len(self.element_types)
 
 

classiq/interface/generator/generated_circuit_data.py

@@ -54,6 +54,8 @@ VISUALIZATION_HIDE_LIST = [
     "stmt_block",
 ]
 
+CONTROLLED_PREFIX = "c-"
+
 
 def last_name_in_call_hierarchy(name: str) -> str:
     return name.split(CLASSIQ_HIERARCHY_SEPARATOR)[-1]
@@ -213,7 +215,9 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             name = generate_original_function_name(back_ref.func_name).removeprefix(
                 ARITH_ENGINE_PREFIX
             )
-            return self.add_suffix_from_generated_name(generated_name, name)
+            name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
+            modified_name = self.modify_name_for_controlled_qfunc(name_with_suffix)
+            return modified_name
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -222,6 +226,11 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             generated_name, STATEMENTS_NAME[statement_kind]
         )
 
+    def modify_name_for_controlled_qfunc(self, generated_name: str) -> str:
+        if self.control_variable is None:
+            return generated_name
+        return f"{CONTROLLED_PREFIX}{generated_name}"
+
     def add_suffix_from_generated_name(self, generated_name: str, name: str) -> str:
         if part_match := PART_SUFFIX_REGEX.match(generated_name):
             suffix = f" [{part_match.group(1)}]"

classiq/interface/helpers/custom_pydantic_types.py

@@ -66,9 +66,8 @@ else:
         StringConstraints(strip_whitespace=True, min_length=1, pattern="^[IXYZ]+$"),
     ]
 
-PydanticPauliList = Annotated[
-    list[tuple[PydanticPauliMonomialStr, ParameterComplexType]], Field(min_length=1)
-]
+PauliTuple = tuple[PydanticPauliMonomialStr, ParameterComplexType]
+PydanticPauliList = Annotated[list[PauliTuple], Field(min_length=1)]
 
 if TYPE_CHECKING:
     PydanticFloatTuple = tuple[float, float]

classiq/interface/model/allocate.py

@@ -9,6 +9,8 @@ from classiq.interface.model.quantum_statement import QuantumOperation
 class Allocate(QuantumOperation):
     kind: Literal["Allocate"]
     size: Optional[Expression] = None
+    is_signed: Optional[Expression] = None
+    fraction_digits: Optional[Expression] = None
     target: ConcreteHandleBinding
 
     @property
@@ -20,4 +22,8 @@ class Allocate(QuantumOperation):
         exprs = []
         if self.size is not None:
             exprs.append(self.size)
+        if self.is_signed is not None:
+            exprs.append(self.is_signed)
+        if self.fraction_digits is not None:
+            exprs.append(self.fraction_digits)
         return exprs

classiq/interface/model/quantum_type.py

@@ -6,6 +6,7 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
@@ -290,8 +291,20 @@ class QuantumNumeric(QuantumScalar):
             exprs.append(self.fraction_digits)
         return exprs
 
-    def get_bounds(self) -> Optional[tuple[float, float]]:
-        return self._bounds
+    def get_bounds(
+        self, machine_precision: Optional[int] = None
+    ) -> Optional[tuple[float, float]]:
+        if (
+            self._bounds is None
+            or machine_precision is None
+            or self.fraction_digits_value <= machine_precision
+        ):
+            return self._bounds
+
+        return (
+            number_utils.limit_fraction_places(self._bounds[0], machine_precision),
+            number_utils.limit_fraction_places(self._bounds[1], machine_precision),
+        )
 
     def set_bounds(self, bounds: Optional[tuple[float, float]]) -> None:
         self._bounds = bounds
@@ -299,11 +312,19 @@ class QuantumNumeric(QuantumScalar):
     def reset_bounds(self) -> None:
         self.set_bounds(None)
 
-    def get_maximal_bounds(self) -> tuple[float, float]:
+    def get_maximal_bounds(
+        self, machine_precision: Optional[int] = None
+    ) -> tuple[float, float]:
+        size = self.size_in_bits
+        fraction_digits = self.fraction_digits_value
+        if machine_precision is not None and fraction_digits > machine_precision:
+            size -= fraction_digits - machine_precision
+            fraction_digits = machine_precision
+
         return RegisterArithmeticInfo.get_maximal_bounds(
-            size=self.size_in_bits,
+            size=size,
             is_signed=self.sign_value,
-            fraction_places=self.fraction_digits_value,
+            fraction_places=fraction_digits,
         )
 
 

classiq/interface/server/routes.py

@@ -57,6 +57,12 @@ TASKS_VISUAL_MODEL_FULL_PATH = ANALYZER_PREFIX + TASKS_VISUAL_MODEL_SUFFIX
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
 
+QUANTUM_PROGRAM_PREFIX = "/quantum_program"
+TRANSPILATION_SUFFIX = "/transpilation"
+TRANSPILATION_FULL_PATH = QUANTUM_PROGRAM_PREFIX + TRANSPILATION_SUFFIX
+ASSIGN_PARAMETERS_SUFFIX = "/assign_parameters"
+ASSIGN_PARAMETERS_FULL_PATH = QUANTUM_PROGRAM_PREFIX + ASSIGN_PARAMETERS_SUFFIX
+
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -147,11 +147,19 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
         }
         return QmodStructInstance(struct_decl.model_copy(), qmod_dict)
 
-    if isinstance(qmod_type, ClassicalList):
+    if isinstance(qmod_type, (ClassicalList, ClassicalArray)):
         if not isinstance(val, list):
             raise ClassiqInternalExpansionError("Bad value for list")
         return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
 
+    if isinstance(qmod_type, ClassicalTuple):
+        if not isinstance(val, list):
+            raise ClassiqInternalExpansionError("Bad value for list")
+        return [
+            python_val_to_qmod(elem, elem_type)
+            for elem, elem_type in zip_strict(val, qmod_type.element_types, strict=True)
+        ]
+
     if isinstance(qmod_type, OpaqueHandle):
         if not isinstance(val, QmodPyObject):
             raise ClassiqInternalExpansionError("Bad value opaque handle")

classiq/model_expansions/capturing/captured_vars.py

@@ -16,6 +16,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.helpers.text_utils import are, readable_list, s, they
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -42,7 +43,6 @@ from classiq.model_expansions.transformers.model_renamer import (
     SymbolRenaming,
 )
 from classiq.model_expansions.transformers.var_splitter import SymbolPart
-from classiq.model_expansions.utils.text_utils import are, readable_list, s, they
 
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Any, Union
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
@@ -67,15 +68,22 @@ def _infer_classical_array_type(
         return classical_type
     else:
         raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
-    if (
-        isinstance(classical_type, (ClassicalArray, ClassicalTuple))
-        and isinstance(val_length, int)
-        and isinstance(classical_type.size, int)
-        and val_length != classical_type.size
+    if isinstance(val_length, int) and (
+        (
+            isinstance(classical_type, ClassicalArray)
+            and classical_type.length is not None
+            and classical_type.length.is_evaluated()
+            and _is_int(classical_type.length.value.value)
+            and val_length != (type_length := int(classical_type.length.value.value))
+        )
+        or (
+            isinstance(classical_type, ClassicalTuple)
+            and val_length != (type_length := classical_type.length)
+        )
     ):
         raise ClassiqExpansionError(
             f"Type mismatch: Argument has {val_length} items but "
-            f"{classical_type.size} expected"
+            f"{type_length} expected"
         )
     new_classical_type = _infer_inner_array_types(classical_type, val, val_length)
     if classical_type.is_generative:
@@ -86,25 +94,29 @@ def _infer_classical_array_type(
 def _infer_inner_array_types(
     classical_type: ClassicalType, val: Any, val_length: Any
 ) -> ClassicalType:
-    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
-        if _is_int(val_length) and val_length != 0:
-            return ClassicalTuple(
-                element_types=(
-                    infer_classical_type(val[i], classical_type.element_type)
-                    for i in range(int(val_length))
-                ),
-            )
-        element_type: ClassicalType
-        if val_length == 0:
-            element_type = classical_type.element_type
-        else:
-            element_type = infer_classical_type(val[0], classical_type.element_type)
-        return ClassicalArray(element_type=element_type, size=val_length)
+    if isinstance(classical_type, ClassicalTuple):
+        return ClassicalTuple(
+            element_types=(
+                infer_classical_type(val[idx], element_type)
+                for idx, element_type in enumerate(classical_type.element_types)
+            ),
+        )
     if TYPE_CHECKING:
-        assert isinstance(classical_type, ClassicalTuple)
-    return ClassicalTuple(
-        element_types=(
-            infer_classical_type(val[idx], element_type)
-            for idx, element_type in enumerate(classical_type.element_types)
-        ),
-    )
+        assert isinstance(classical_type, (ClassicalList, ClassicalArray))
+    if _is_int(val_length) and val_length != 0:
+        return ClassicalTuple(
+            element_types=(
+                infer_classical_type(val[i], classical_type.element_type)
+                for i in range(int(val_length))
+            ),
+        )
+    element_type: ClassicalType
+    if val_length == 0:
+        element_type = classical_type.element_type
+    else:
+        element_type = infer_classical_type(val[0], classical_type.element_type)
+    if _is_int(val_length):
+        length = Expression(expr=str(int(val_length)))
+    else:
+        length = None
+    return ClassicalArray(element_type=element_type, length=length)

classiq/model_expansions/evaluators/parameter_types.py

@@ -10,6 +10,12 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    ClassicalTuple,
+    ClassicalType,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -139,11 +145,12 @@ def _evaluate_type_from_arg(
     parameter: PositionalArg, argument: Evaluated, inner_scope: Scope
 ) -> PositionalArg:
     if isinstance(parameter, ClassicalParameterDeclaration):
+        updated_classical_type = evaluate_type_in_classical_symbol(
+            parameter.classical_type.model_copy(), inner_scope, parameter.name
+        )
         return ClassicalParameterDeclaration(
             name=parameter.name,
-            classical_type=infer_classical_type(
-                argument.value, parameter.classical_type
-            ),
+            classical_type=infer_classical_type(argument.value, updated_classical_type),
         )
 
     if not isinstance(parameter, PortDeclaration):
@@ -297,3 +304,58 @@ def _inject_quantum_arg_info_to_type(
             param_name,
         )
     return parameter_type
+
+
+def evaluate_type_in_classical_symbol(
+    type_to_update: ClassicalType, scope: Scope, param_name: str
+) -> ClassicalType:
+    updated_type: ClassicalType
+    if isinstance(type_to_update, ClassicalList):
+        updated_type = ClassicalArray(
+            element_type=evaluate_type_in_classical_symbol(
+                type_to_update.element_type, scope, param_name
+            )
+        )
+    elif isinstance(type_to_update, ClassicalArray):
+        length = type_to_update.length
+        if length is not None:
+            new_length = _eval_expr(
+                length, scope, int, "classical array", "length", param_name
+            )
+            if new_length is not None:
+                length = Expression(expr=str(new_length))
+        updated_type = ClassicalArray(
+            element_type=evaluate_type_in_classical_symbol(
+                type_to_update.element_type, scope, param_name
+            ),
+            length=length,
+        )
+    elif isinstance(type_to_update, ClassicalTuple):
+        updated_type = ClassicalTuple(
+            element_types=[
+                evaluate_type_in_classical_symbol(element_type, scope, param_name)
+                for element_type in type_to_update.element_types
+            ],
+        )
+    elif (
+        isinstance(type_to_update, TypeName)
+        and type_to_update.has_classical_struct_decl
+    ):
+        updated_type = TypeName(name=type_to_update.name)
+        updated_type.set_classical_struct_decl(
+            type_to_update.classical_struct_decl.model_copy(
+                update=dict(
+                    variables={
+                        field_name: evaluate_type_in_classical_symbol(
+                            field_type, scope, param_name
+                        )
+                        for field_name, field_type in type_to_update.classical_struct_decl.variables.items()
+                    }
+                )
+            )
+        )
+    else:
+        updated_type = type_to_update
+    if type_to_update.is_generative:
+        updated_type.set_generative()
+    return updated_type

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -24,7 +24,7 @@ from classiq.qmod.model_state_container import QMODULE
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
     def emit_allocate(self, allocate: Allocate) -> None:
-        AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
+        AllocateEmitter(self, allow_symbolic_attrs=True).emit(allocate)
 
     def emit_bind(self, bind: BindOperation) -> None:
         BindEmitter(self, allow_symbolic_size=True).emit(bind)

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,16 +1,16 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Union
 
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+)
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -22,10 +22,10 @@ if TYPE_CHECKING:
 
 class AllocateEmitter(Emitter[Allocate]):
     def __init__(
-        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+        self, interpreter: "BaseInterpreter", allow_symbolic_attrs: bool = False
     ) -> None:
         super().__init__(interpreter)
-        self._allow_symbolic_size = allow_symbolic_size
+        self._allow_symbolic_attrs = allow_symbolic_attrs
 
     def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
@@ -37,45 +37,132 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"Cannot allocate partial quantum variable {str(target.handle)!r}"
             )
 
-        size_expr = self._get_var_size(target, allocate.size)
+        op_update_dict: dict[str, Expression] = {}
+
+        if allocate.size is None:
+            if allocate.is_signed is not None or allocate.fraction_digits is not None:
+                raise ClassiqValueError(
+                    "Numeric attributes cannot be specified without size"
+                )
+            self._handle_without_size(target, op_update_dict)
+
+        elif allocate.is_signed is None and allocate.fraction_digits is None:
+            self._handle_with_size(target, allocate.size, op_update_dict)
+
+        elif allocate.is_signed is not None and allocate.fraction_digits is not None:
+            self._handle_with_numeric_attrs(
+                target,
+                allocate.size,
+                allocate.is_signed,
+                allocate.fraction_digits,
+                op_update_dict,
+            )
+
+        else:
+            raise ClassiqValueError(
+                "Sign and fraction digits must be specified together"
+            )
+
         if isinstance(target.quantum_type, QuantumNumeric):
             target.quantum_type.set_bounds((0, 0))
-        allocate = allocate.model_copy(
-            update=dict(
-                size=Expression(expr=size_expr),
-                target=target.handle,
-                back_ref=allocate.uuid,
-            )
-        )
+
+        allocate = allocate.model_copy(update=op_update_dict)
         self._register_debug_info(allocate)
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Optional[Expression]) -> str:
-        if size is None:
-            if not target.quantum_type.is_evaluated:
-                raise ClassiqValueError(
-                    f"Could not infer the size of variable {str(target.handle)!r}"
-                )
-            return str(target.quantum_type.size_in_bits)
+    def _handle_without_size(
+        self,
+        target: QuantumSymbol,
+        op_update_dict: dict[str, Expression],
+    ) -> None:
+        if not target.quantum_type.is_evaluated:
+            raise ClassiqValueError(
+                f"Could not infer the size of variable {str(target.handle)!r}"
+            )
+        op_update_dict["size"] = Expression(expr=str(target.quantum_type.size_in_bits))
 
-        size_value = self._interpreter.evaluate(size).value
-        if self._allow_symbolic_size and isinstance(
-            size_value, (sympy.Basic, AnyClassicalValue)
+    def _handle_with_size(
+        self,
+        target: QuantumSymbol,
+        size: Expression,
+        op_update_dict: dict[str, Expression],
+    ) -> None:
+        size_value = self._interpret_size(size)
+        op_update_dict["size"] = Expression(expr=str(size_value))
+
+        if not isinstance(size_value, sympy.Basic):
+            copy_type_information(
+                QuantumBitvector(length=op_update_dict["size"]),
+                target.quantum_type,
+                str(target.handle),
+            )
+
+    def _handle_with_numeric_attrs(
+        self,
+        target: QuantumSymbol,
+        size: Expression,
+        is_signed: Expression,
+        fraction_digits: Expression,
+        op_update_dict: dict[str, Expression],
+    ) -> None:
+        if not isinstance(target.quantum_type, QuantumNumeric):
+            raise ClassiqValueError(
+                f"Non-numeric variable {str(target.handle)!r} cannot be allocated with numeric attributes"
+            )
+
+        size_value = self._interpret_size(size)
+        op_update_dict["size"] = Expression(expr=str(size_value))
+        is_signed_value = self._interpret_is_signed(is_signed)
+        op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
+        fraction_digits_value = self._interpret_fraction_digits(fraction_digits)
+        op_update_dict["fraction_digits"] = Expression(expr=str(fraction_digits_value))
+
+        if not (
+            isinstance(size_value, sympy.Basic)
+            or isinstance(is_signed_value, sympy.Basic)
+            or isinstance(fraction_digits_value, sympy.Basic)
         ):
-            return str(size_value)
-        if not isinstance(size_value, (int, float)):
+            copy_type_information(
+                QuantumNumeric(
+                    size=op_update_dict["size"],
+                    is_signed=op_update_dict["is_signed"],
+                    fraction_digits=op_update_dict["fraction_digits"],
+                ),
+                target.quantum_type,
+                str(target.handle),
+            )
+
+    def _interpret_size(self, size: Expression) -> Union[int, float, sympy.Basic]:
+        size_value = self._interpreter.evaluate(size).value
+        if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
-        size_expr = str(size_value)
-        copy_type_information(
-            QuantumBitvector(length=Expression(expr=size_expr)),
-            target.quantum_type,
-            str(target.handle),
-        )
-        return size_expr
+        return size_value
+
+    def _interpret_is_signed(self, is_signed: Expression) -> Union[bool, sympy.Basic]:
+        is_signed_value = self._interpreter.evaluate(is_signed).value
+        if not self._allow_symbolic_attrs and not isinstance(is_signed_value, bool):
+            raise ClassiqValueError(
+                f"The sign of a variable must be boolean. Got "
+                f"{str(is_signed_value)!r}"
+            )
+        return is_signed_value
+
+    def _interpret_fraction_digits(
+        self, fraction_digits: Expression
+    ) -> Union[int, float, sympy.Basic]:
+        fraction_digits_value = self._interpreter.evaluate(fraction_digits).value
+        if not self._allow_symbolic_attrs and not isinstance(
+            fraction_digits_value, (int, float)
+        ):
+            raise ClassiqValueError(
+                f"The fraction digits of a variable must be an integer. Got "
+                f"{str(fraction_digits_value)!r}"
+            )
+        return fraction_digits_value
 
     def _register_debug_info(self, allocate: Allocate) -> None:
         if (