classiq 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/phase.py

@@ -0,0 +1,189 @@
+from typing import TYPE_CHECKING, Dict, List, Tuple
+
+import sympy
+from sympy import sympify
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.applications.combinatorial_helpers.transformations.ising_converter import (
+    _find_sub_list_items,
+    _get_vars,
+    _refine_ising_expr,
+    _to_ising_symbolic_objective_function,
+)
+from classiq.model_expansions.quantum_operations.expression_operation import (
+    ExpressionOperationEmitter,
+)
+from classiq.qmod.builtins.functions.exponentiation import suzuki_trotter
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
+    def _negate_expression(self, expression: Expression, /) -> Expression:
+        return self._evaluate_expression(
+            # TODO: change to model_copy for pydantic V2
+            expression.copy(update=dict(expr=f"-({expression.expr})"))
+        )
+
+    def emit(self, phase_op: PhaseOperation, /) -> None:
+        phase_expression = self._evaluate_op_expression(phase_op)
+        phase_op = phase_op.copy(update=dict(expression=phase_expression))
+        arrays_with_subscript = self._get_symbols_to_split(phase_op.expression)
+        if len(arrays_with_subscript) > 0:
+            self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
+            return
+        # TODO: change to model_copy for pydantic V2
+        phase_op = phase_op.copy(
+            update=dict(expression=self._negate_expression(phase_op.expression))
+        )
+        phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)
+        if len(phase_op.var_handles) == 0:
+            ErrorManager().add_error(
+                "Cannot perform phase operation on an expression with no quantum variables."
+            )
+            return
+
+        aux_name = self._counted_name_allocator.allocate("phase_aux")
+        if len(phase_op.var_handles) > 1:
+            split_join = True
+            evolution_variable = HandleBinding(name=aux_name)
+        else:
+            split_join = False
+            evolution_variable = phase_op.var_handles[0]
+        expression = self._evaluate_op_expression(phase_op)
+        expression_evolution_function = QuantumFunctionCall(
+            function=suzuki_trotter.func_decl.name,
+            positional_args=[
+                _convert_cost_expression_to_hamiltonian(
+                    expression.expr,
+                    {
+                        var.name: self._current_scope[var.name].value.quantum_type
+                        for var in phase_op.var_handles
+                    },
+                ),
+                phase_op.theta,
+                Expression(expr="1"),
+                Expression(expr="1"),
+                evolution_variable,
+            ],
+            source_ref=phase_op.source_ref,
+        )
+        expression_evolution_function.set_func_decl(suzuki_trotter.func_decl)
+
+        if split_join:
+            self._interpreter.emit_statement(
+                VariableDeclarationStatement(
+                    name=aux_name, quantum_type=QuantumBitvector()
+                )
+            )
+            self._interpreter.emit_statement(
+                WithinApply(
+                    compute=[
+                        BindOperation(
+                            in_handles=phase_op.var_handles,
+                            out_handles=[HandleBinding(name=aux_name)],
+                        )
+                    ],
+                    action=[expression_evolution_function],
+                    source_ref=phase_op.source_ref,
+                )
+            )
+        else:
+            self._interpreter.emit_statement(
+                expression_evolution_function,
+            )
+
+
+def _get_single_bit_vars_expression(
+    expr: sympy.Expr, vars_info: Dict[str, QuantumScalar]
+) -> Tuple[sympy.Expr, List[sympy.Symbol]]:
+    bit_vars = []
+    for var_name, var_info in vars_info.items():
+        size = var_info.size_in_bits
+        var = sympy.Symbol(var_name)
+        if size == 1:
+            bits = [var]
+            is_signed = False
+            fraction_places = 0
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_info, QuantumNumeric)
+            bits = [
+                sympy.Symbol(f"{var_name}{HANDLE_ID_SEPARATOR}{i}__split__")
+                for i in range(size)
+            ]
+            is_signed = var_info.sign_value
+            fraction_places = var_info.fraction_digits_value
+        bit_vars.extend(bits)
+        split_var = 0
+        for i, bit in enumerate(bits):
+            if is_signed and i == size - 1:  # sign bit (MSB)
+                split_var -= bit * 2 ** (size - 1 - fraction_places)
+            else:
+                split_var += bit * 2 ** (i - fraction_places)
+        expr = expr.subs(var, split_var)
+    return expr, bit_vars
+
+
+def _convert_ising_sympy_to_pauli_terms(
+    ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
+) -> str:
+    pauli_terms: List[str] = []
+    coefficients = ising_expr.as_coefficients_dict(*ordered_sympy_vars)
+    for expr_term in ising_expr.args:
+        expr_vars = _get_vars(expr_term)
+        z_vec = _find_sub_list_items(ordered_sympy_vars, expr_vars)
+        pauli_elements = ["I"] * len(z_vec)
+        for index, is_z_op in enumerate(z_vec):
+            if is_z_op:
+                pauli_elements[len(z_vec) - index - 1] = (
+                    "Z"  # reminder: Pauli reverses the order!
+                )
+        term_var = sympy.Mul(
+            *(var for i, var in enumerate(ordered_sympy_vars) if z_vec[i])
+        )
+        coeff = float(coefficients[term_var])
+        paulis = [f"Pauli.{pauli}" for pauli in pauli_elements]
+        pauli_terms.append(
+            # fmt: off
+                    "struct_literal("
+                    "PauliTerm,"
+                    f"pauli=[{', '.join(paulis)}],"
+                    f"coefficient={Expression(expr=str(coeff))},"
+                    ")"
+            # fmt: on,
+        )
+    return f"[{', '.join(pauli_terms)}]"
+
+
+def _convert_cost_expression_to_hamiltonian(
+    expr: str,
+    vars: Dict[str, QuantumScalar],
+) -> Expression:
+    sympy_expr = sympify(expr)
+    single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(
+        sympy_expr, vars
+    )
+    if not single_bit_vars_expression.is_polynomial():
+        raise ClassiqExpansionError(f"phased expression {expr!r} is not polynomial")
+
+    ising_expr = _to_ising_symbolic_objective_function(single_bit_vars_expression)
+    ising_expr = _refine_ising_expr(ising_expr)
+
+    return Expression(
+        expr=_convert_ising_sympy_to_pauli_terms(ising_expr, single_bit_vars)
+    )

classiq/model_expansions/quantum_operations/power.py

@@ -2,7 +2,6 @@ from typing import Union
 
 import sympy
 
-from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -22,6 +21,14 @@ class PowerEmitter(Emitter[Power]):
     _power_expr: Expression
 
     def emit(self, power: Power, /) -> None:
+        with self._propagated_var_stack.capture_variables(power):
+            self._emit_propagated(power)
+
+    def _emit_propagated(self, power: Power) -> None:
+        if power.is_generative():
+            context = self._register_generative_context(power, POWER_OPERATOR_NAME)
+            power = power.copy(update={"body": context.statements("body")})
+
         self._power = power
         self._power_value = self._get_power_value()
         self._power_expr = Expression(
@@ -41,8 +48,7 @@ class PowerEmitter(Emitter[Power]):
             blocks=dict(body=self._power.body),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(self._power):
-            context = self._expand_operation(power_operation)
+        context = self._expand_operation(power_operation)
         self._builder.emit_statement(
             Power(
                 body=context.statements("body"),
@@ -66,9 +72,4 @@ class PowerEmitter(Emitter[Power]):
 
     def _get_power_value(self) -> Union[int, sympy.Basic]:
         power_value = self._interpreter.evaluate(self._power.power).value
-        if not (isinstance(power_value, int) or power_value.is_symbol):
-            raise ClassiqExpansionError(
-                f"`power`'s argument should be an integer or identifier. Complex "
-                f"expressions are not supported. Got {str(power_value)!r}"
-            )
         return power_value

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -11,6 +11,7 @@ from classiq.interface.model.inplace_binary_operation import (
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
@@ -62,7 +63,7 @@ class QuantumAssignmentOperationEmitter(
         self, op: ArithmeticOperation, expression: Expression
     ) -> None:
         op, expression, is_bool_opt = self._optimize_boolean_expression(op, expression)
-        if op.inplace_result:
+        if op.is_inplace:
             self._emit_inplace_arithmetic_op(op, expression, is_bool_opt)
         else:
             self._emit_general_assignment_operation(op)
@@ -70,7 +71,9 @@ class QuantumAssignmentOperationEmitter(
     def _emit_inplace_arithmetic_op(
         self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
     ) -> None:
-        if op.result_type.size_in_bits > 1 or not _is_res_boolean(op):
+        if op.get_operation_kind() != ArithmeticOperationKind.InplaceXor or (
+            op.result_type.size_in_bits > 1 or not _is_res_boolean(op)
+        ):
             _validate_naive_inplace_handles(op)
             self._build_naive_inplace(op, expression)
             return
@@ -100,7 +103,15 @@ class QuantumAssignmentOperationEmitter(
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression
     ) -> Tuple[ArithmeticOperation, Expression, bool]:
-        if not _all_vars_boolean(op):
+        if (
+            self._interpreter._is_frontend
+            or op.get_operation_kind()
+            not in (
+                ArithmeticOperationKind.Assignment,
+                ArithmeticOperationKind.InplaceXor,
+            )
+            or not _all_vars_boolean(op)
+        ):
             return op, expression, False
         optimizer = BooleanExpressionOptimizer()
         optimized_expression = Expression(
@@ -130,10 +141,14 @@ class QuantumAssignmentOperationEmitter(
         arith_expression = ArithmeticOperation(
             result_var=HandleBinding(name=aux_var),
             expression=new_expression,
-            inplace_result=False,
+            operation_kind=ArithmeticOperationKind.Assignment,
         )
+        if qe.get_operation_kind() == ArithmeticOperationKind.InplaceXor:
+            op = BinaryOperation.Xor
+        else:
+            op = BinaryOperation.Addition
         inplace_store = InplaceBinaryOperation(
-            operation=BinaryOperation.Xor,
+            operation=op,
             target=qe.result_var,
             value=HandleBinding(name=aux_var),
         )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -11,5 +11,5 @@ class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
         args = call.positional_args
         with ErrorManager().call(
             function.name
-        ), self._propagated_var_stack.capture_variables(call):
+        ), function.scope.freeze(), self._propagated_var_stack.capture_variables(call):
             self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,3 +1,5 @@
+from typing import Type
+
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -8,9 +10,10 @@ from classiq.interface.model.classical_parameter_declaration import (
 )
 from classiq.interface.model.repeat import Repeat
 
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Scope
+from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class RepeatEmitter(Emitter[Repeat]):
@@ -18,16 +21,32 @@ class RepeatEmitter(Emitter[Repeat]):
         count = self._interpreter.evaluate(repeat.count).as_type(int)
         for i in range(count):
             with self._propagated_var_stack.capture_variables(repeat):
-                iteration_function = FunctionClosure.create(
-                    name=REPEAT_OPERATOR_NAME,
-                    positional_arg_declarations=[
-                        ClassicalParameterDeclaration(
-                            name=repeat.iter_var, classical_type=Integer()
-                        )
-                    ],
-                    body=repeat.body,
-                    scope=Scope(parent=self._current_scope),
-                )
-                self._emit_quantum_function_call(
-                    iteration_function, [Expression(expr=str(i))]
+                self._emit_propagated(repeat, i)
+
+    def _emit_propagated(self, repeat: Repeat, i: int) -> None:
+        closure_constructor: Type[FunctionClosure]
+        extra_args: dict
+        if repeat.is_generative():
+            closure_constructor = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(
+                        repeat.get_generative_block("body"),
+                    ),
+                }
+            }
+        else:
+            closure_constructor = FunctionClosure
+            extra_args = {}
+        iteration_function = closure_constructor.create(
+            name=REPEAT_OPERATOR_NAME,
+            positional_arg_declarations=[
+                ClassicalParameterDeclaration(
+                    name=repeat.iter_var, classical_type=Integer()
                 )
+            ],
+            body=repeat.body,
+            scope=Scope(parent=self._current_scope),
+            **extra_args,
+        )
+        self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])

classiq/model_expansions/quantum_operations/within_apply.py

@@ -11,6 +11,21 @@ from classiq.model_expansions.scope import Scope
 
 class WithinApplyEmitter(Emitter[WithinApply]):
     def emit(self, within_apply: WithinApply, /) -> None:
+        with self._propagated_var_stack.capture_variables(within_apply):
+            self._emit_propagated(within_apply)
+
+    def _emit_propagated(self, within_apply: WithinApply) -> None:
+        if within_apply.is_generative():
+            within_apply_context = self._register_generative_context(
+                within_apply, WITHIN_APPLY_NAME, ["within", "apply"]
+            )
+            within_apply = within_apply.copy(
+                update={
+                    "compute": within_apply_context.statements("within"),
+                    "action": within_apply_context.statements("apply"),
+                }
+            )
+
         if self._should_wrap(within_apply.compute):
             self._emit_wrapped(within_apply)
             return
@@ -23,8 +38,7 @@ class WithinApplyEmitter(Emitter[WithinApply]):
             blocks=dict(within=within_apply.compute, apply=within_apply.action),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(within_apply):
-            context = self._expand_operation(within_apply_operation)
+        context = self._expand_operation(within_apply_operation)
         self._builder.emit_statement(
             WithinApply(
                 compute=context.statements("within"),
@@ -34,10 +48,9 @@ class WithinApplyEmitter(Emitter[WithinApply]):
         )
 
     def _emit_wrapped(self, within_apply: WithinApply) -> None:
-        with self._propagated_var_stack.capture_variables(within_apply):
-            wrapped_compute = self._create_expanded_wrapping_function(
-                COMPUTE_OPERATOR_NAME, within_apply.compute
-            )
+        wrapped_compute = self._create_expanded_wrapping_function(
+            COMPUTE_OPERATOR_NAME, within_apply.compute
+        )
         wrapped_within_apply = WithinApply(
             compute=[wrapped_compute],
             action=within_apply.action,

classiq/model_expansions/scope.py

@@ -1,11 +1,10 @@
 import itertools
 from collections import UserDict
+from contextlib import contextmanager
 from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
 
-from typing_extensions import Self
-
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -180,13 +179,13 @@ class Scope(EvaluatedUserDict):
         data: Optional[Dict[str, Evaluated]] = None,
         /,
         *,
-        parent: Optional[Self] = None,
+        parent: Optional["Scope"] = None,
     ) -> None:
         super().__init__(data or {})
-        self._parent: Optional[Self] = parent
+        self._parent: Optional["Scope"] = parent
 
     @property
-    def parent(self) -> Optional[Self]:
+    def parent(self) -> Optional["Scope"]:
         return self._parent
 
     def __getitem__(self, name: str) -> Evaluated:
@@ -224,3 +223,15 @@ class Scope(EvaluatedUserDict):
             (self.data or {}) | (other.data or {}),
             parent=parent,
         )
+
+    def _copy(self) -> "Scope":
+        return Scope(
+            self.data, parent=None if self._parent is None else self._parent.copy()
+        )
+
+    @contextmanager
+    def freeze(self) -> Iterator[None]:
+        previous = self._copy()
+        yield
+        self.data = previous.data
+        self._parent = previous._parent

classiq/model_expansions/scope_initialization.py

@@ -1,5 +1,6 @@
 from typing import List, Sequence
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX,
@@ -22,6 +23,7 @@ from classiq.model_expansions.evaluators.parameter_types import (
 )
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.functions import (
     CORE_LIB_DECLS,
     OPEN_LIB_DECLS,
@@ -71,7 +73,7 @@ def _add_generative_functions_to_scope(
                 name=function.func_decl.name,
                 positional_arg_declarations=function.func_decl.positional_arg_declarations,
                 scope=Scope(parent=scope),
-                generative_function=function,
+                generative_blocks={"body": function},
             )
         )
 
@@ -104,6 +106,14 @@ def _init_builtins_scope(scope: Scope) -> None:
                     is_atomic=True,
                 )
             )
+    for constant in BUILTIN_CONSTANTS:
+        value = constant.value
+        if not value.is_evaluated():
+            raise ClassiqError(
+                f"Unevaluated built-in constants not supported. Offending constant: "
+                f"{constant.name} = {value}"
+            )
+        scope[constant.name] = Evaluated(value=value.value.value)
 
 
 def add_entry_point_params_to_scope(

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -1,5 +1,5 @@
 import ast
-from typing import TYPE_CHECKING, Dict, Type
+from typing import TYPE_CHECKING, Dict, Type, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 
@@ -116,6 +116,9 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
         return self.generic_visit(node)
 
     def visit_Call(self, node: ast.Call) -> ast.AST:
+        if isinstance(node.func, ast.Name) and node.func.id == "Piecewise":
+            return self._visit_piecewise(node)
+
         if (
             not isinstance(node.func, ast.Name)
             or node.func.id not in self.SPECIAL_FUNCTIONS
@@ -128,6 +131,25 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
             keywords=[self.visit(arg) for arg in node.keywords],
         )
 
+    def _visit_piecewise(self, node: ast.Call) -> ast.AST:
+        # sympy Piecewise expression may include bitwise operations:
+        # Piecewise((0, Eq(x, 0)), (0.5, Eq(x, 1) | Eq(x, 2)), (1, True))
+        #                                         ^
+        # We should avoid converting these to 'BitwiseOr' and such.
+        return ast.Call(
+            func=node.func,
+            args=[
+                ast.Tuple(
+                    elts=(
+                        self.generic_visit(cast(ast.Tuple, arg).elts[0]),
+                        cast(ast.Tuple, arg).elts[1],
+                    )
+                )
+                for arg in node.args
+            ],
+            keywords=node.keywords,
+        )
+
     def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
         if isinstance(node.slice, ast.Slice):
             if node.slice.lower is not None:

classiq/model_expansions/visitors/variable_references.py

@@ -1,6 +1,6 @@
 import ast
 from contextlib import contextmanager
-from typing import Dict, Iterator, Optional, Set, Union
+from typing import Dict, Iterator, List, Optional, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,10 +23,14 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(self, ignore_duplicated_handles: bool = False) -> None:
-        self.var_handles: Set[HandleBinding] = set()
+        self._var_handles: Dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
         self._is_nested = False
 
+    @property
+    def var_handles(self) -> List[HandleBinding]:
+        return list(self._var_handles)
+
     def visit(self, node: ast.AST) -> Union[
         SubscriptHandleBinding,
         SlicedHandleBinding,
@@ -35,8 +39,8 @@ class VarRefCollector(ast.NodeVisitor):
         None,
     ]:
         res = super().visit(node)
-        if not self._ignore_duplicated_handles and len(self.var_handles) != len(
-            {handle.name for handle in self.var_handles}
+        if not self._ignore_duplicated_handles and len(self._var_handles) != len(
+            {handle.name for handle in self._var_handles}
         ):
             raise ClassiqExpansionError(
                 "Multiple non-identical variable references in an expression are not supported."
@@ -71,7 +75,7 @@ class VarRefCollector(ast.NodeVisitor):
             raise ClassiqInternalExpansionError("Unevaluated slice.")
 
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     def visit_Attribute(self, node: ast.Attribute) -> Optional[FieldHandleBinding]:
@@ -84,7 +88,7 @@ class VarRefCollector(ast.NodeVisitor):
             field=node.attr,
         )
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
@@ -94,7 +98,7 @@ class VarRefCollector(ast.NodeVisitor):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:
-            self.var_handles.add(handle)
+            self._var_handles[handle] = True
         return handle
 
     @contextmanager

classiq/qmod/builtins/__init__.py

@@ -6,6 +6,8 @@ from .classical_execution_primitives import (
 )
 from .classical_functions import *  # noqa: F403
 from .classical_functions import __all__ as _builtin_classical_functions
+from .constants import *  # noqa: F403
+from .constants import __all__ as _builtin_constants
 from .enums import *  # noqa: F403
 from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
@@ -18,6 +20,13 @@ from .structs import __all__ as _builtin_structs
 FinanceFunctionInput.update_forward_refs(
     FinanceFunctionType=FinanceFunctionType  # noqa: F405
 )
+BUILTIN_CONSTANTS = [
+    constant._get_constant_node()
+    for constant in [
+        SIGNED,  # noqa: F405
+        UNSIGNED,  # noqa: F405
+    ]
+]
 
 __all__ = (
     _builtin_enums
@@ -26,4 +35,5 @@ __all__ = (
     + _builtin_operations
     + _builtin_classical_execution_primitives
     + _builtin_classical_functions
+    + _builtin_constants
 )

classiq/qmod/builtins/constants.py

@@ -0,0 +1,10 @@
+from classiq.qmod.cparam import CBool
+from classiq.qmod.qmod_constant import QConstant
+
+SIGNED = QConstant("SIGNED", CBool, True)
+UNSIGNED = QConstant("UNSIGNED", CBool, False)
+
+__all__ = [
+    "SIGNED",
+    "UNSIGNED",
+]

classiq/qmod/builtins/functions/state_preparation.py

@@ -340,7 +340,10 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
 
 
 @qfunc(external=True)
-def prepare_int(value: CInt, out: Output[QNum]) -> None:
+def prepare_int(
+    value: CInt,
+    out: Output[QNum[Literal["floor(log(value, 2)) + 1"], Literal[False], Literal[0]]],
+) -> None:
     """
     [Qmod Classiq-library function]