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

classiq/interface/generator/types/compilation_metadata.py

@@ -5,6 +5,7 @@ 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)
     disable_perm_check: bool = Field(default=False)
     disable_const_checks: list[str] | bool = Field(default=False)
 
@@ -16,6 +17,14 @@ class CompilationMetadata(BaseModel):
     def occupation_number(self, value: NonNegativeInt) -> None:
         self._occupation_number = value
 
+    @property
+    def required_clean_qubit(self) -> NonNegativeInt:
+        return self._required_clean_qubit
+
+    @required_clean_qubit.setter
+    def required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._required_clean_qubit = value
+
     @property
     def has_user_directives(self) -> bool:
         return bool(self.disable_perm_check or self.disable_const_checks)

classiq/interface/hardware.py

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

classiq/interface/helpers/model_normalizer.py

@@ -6,16 +6,31 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.port_declaration import (
+    PortDeclaration,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 
 class ModelNormalizer(Visitor):
-    def __init__(self, normalize_names: bool = False) -> None:
-        self._normalize_names = normalize_names
+    def __init__(
+        self,
+        normalize_func_names: bool = False,
+        normalize_quantum_var_names: bool = False,
+    ) -> None:
+        self._normalize_func_names = normalize_func_names
+        self._normalize_quantum_var_names = normalize_quantum_var_names
         self._funcs_renames: dict[str, str] = {}
+        self._count_name = CountedNameAllocator()
+        self.original_names: dict[str, str] = {}
 
     def visit(self, node: Any) -> None:
         if isinstance(node, ASTNode):
@@ -35,12 +50,12 @@ class ModelNormalizer(Visitor):
         self.generic_visit(model)
 
     def visit_NativeFunctionDefinition(self, func: NativeFunctionDefinition) -> None:
-        if self._normalize_names:
+        if self._normalize_func_names:
             func.name = self._funcs_renames[func.name]
         self.generic_visit(func)
 
     def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
-        if self._normalize_names:
+        if self._normalize_func_names:
             if isinstance(call.function, str):
                 if call.function in self._funcs_renames:
                     call.function = self._funcs_renames[call.function]
@@ -49,8 +64,29 @@ class ModelNormalizer(Visitor):
                     call.function.name = self._funcs_renames[call.function.name]
         self.generic_visit(call)
 
-    def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
+    def visit_PortDeclaration(self, decl: PortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
+        self._rename_quantum_var(decl, "_port")
+
+    def visit_VariableDeclarationStatement(
+        self, var: VariableDeclarationStatement
+    ) -> None:
+        self._rename_quantum_var(var, "_var")
+
+    def _rename_quantum_var(
+        self, var: VariableDeclarationStatement | PortDeclaration, new_name_prefix: str
+    ) -> None:
+        if self._normalize_quantum_var_names:
+            old_name = var.name
+            var.name = self._count_name.allocate(new_name_prefix)
+            self.original_names[old_name] = var.name
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> None:
+        if self._normalize_quantum_var_names:
+            # this is a hack use just for testing, do not use in production
+            object.__setattr__(
+                handle, "name", self.original_names.get(handle.name, handle.name)
+            )
 
 
 class ClearModelInternals(Transformer):

classiq/interface/interface_version.py

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

classiq/interface/model/invert.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -25,3 +27,9 @@ class Invert(QuantumOperation):
     @property
     def blocks(self) -> dict[str, "StatementBlock"]:
         return {"body": self.body}
+
+    def validate_node(self) -> None:
+        if self.block_kind == BlockKind.SingleCall and (
+            len(self.body) != 1 or not isinstance(self.body[0], QuantumFunctionCall)
+        ):
+            raise ClassiqInternalExpansionError("Malformed single-call invert")

classiq/interface/model/model_visitor.py

@@ -10,8 +10,10 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 
 class ModelVisitor(Visitor):
-    def visit_DebugInfoCollection(self, debug_info: DebugInfoCollection) -> None:
-        return
+    def visit_DebugInfoCollection(
+        self, debug_info: DebugInfoCollection
+    ) -> RetType | None:
+        return None
 
 
 class ModelStatementsVisitor(ModelVisitor):

classiq/interface/model/quantum_type.py

@@ -78,6 +78,9 @@ class QuantumType(HashableASTNode):
     def without_symbolic_attributes(self) -> Self:
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        return {}
+
 
 class QuantumScalar(QuantumType):
     @property
@@ -262,6 +265,14 @@ class QuantumBitvector(QuantumType):
             length = 1
         return length * self.element_type.minimal_size_in_bits
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_constant_length:
+            attrs[f"{path_expr_prefix}.len"] = self.length_value
+        return attrs | self.element_type.get_compile_time_attributes(
+            f"{path_expr_prefix}[0]"
+        )
+
     def without_symbolic_attributes(self) -> "QuantumBitvector":
         length = (
             None
@@ -301,6 +312,16 @@ class QuantumNumeric(QuantumScalar):
             )
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_size_in_bits:
+            attrs[f"{path_expr_prefix}.size"] = self.size_in_bits
+        if self.has_constant_sign:
+            attrs[f"{path_expr_prefix}.is_signed"] = self.sign_value
+        if self.has_constant_fraction_digits:
+            attrs[f"{path_expr_prefix}.fraction_digits"] = self.fraction_digits_value
+        return attrs
+
     def set_size_in_bits(self, val: int) -> None:
         super().set_size_in_bits(val)
         if self.size is not None:

classiq/interface/model/statement_block.py

@@ -13,9 +13,6 @@ from classiq.interface.model.invert import Invert
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -38,7 +35,6 @@ ConcreteQuantumStatement = Annotated[
         QuantumFunctionCall,
         Allocate,
         ArithmeticOperation,
-        AmplitudeLoadingOperation,
         VariableDeclarationStatement,
         BindOperation,
         InplaceBinaryOperation,

classiq/model_expansions/capturing/captured_vars.py

@@ -56,8 +56,8 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
-INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
-UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
+_INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
+_UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 
 def _get_symbol_expr(symbol: str, classical_type: ClassicalType) -> Expression:
@@ -311,7 +311,7 @@ class CapturedVars:
                 return PortDirection.Inout
             if target_direction == PortDirection.Outin:
                 return PortDirection.Input
-            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_UNINITIALIZED_VAR_MESSAGE.format(var_name))
 
         if source_direction == PortDirection.Output:
             if target_direction == PortDirection.Input:
@@ -320,18 +320,18 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+                raise ClassiqExpansionError(_INITIALIZED_VAR_MESSAGE.format(var_name))
             return PortDirection.Output
 
         if source_direction == PortDirection.Inout:
             if target_direction in (PortDirection.Input, PortDirection.Inout):
                 return target_direction
-            raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_INITIALIZED_VAR_MESSAGE.format(var_name))
 
         if source_direction == PortDirection.Outin:
             if target_direction in (PortDirection.Output, PortDirection.Outin):
                 return target_direction
-            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+            raise ClassiqExpansionError(_UNINITIALIZED_VAR_MESSAGE.format(var_name))
 
         raise ClassiqInternalExpansionError(f"Unexpected direction {source_direction}")
 
@@ -346,7 +346,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
+                    _UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return existing_captured_handle
 
@@ -356,7 +356,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
+                    _INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 
@@ -705,7 +705,9 @@ class CapturedVars:
     def set_parent(self, parent: "CapturedVars") -> None:
         self._handle_states += parent._get_handle_states()
 
-    def get_state(self, var_name: str, defining_function: "FunctionClosure") -> bool:
+    def get_state(
+        self, var_name: str, defining_function: "FunctionClosure"
+    ) -> bool | None:
         for name, func, state in self._handle_states:
             if name == var_name and _same_closure(func, defining_function):
                 return state
@@ -717,9 +719,7 @@ class CapturedVars:
                     PortDirection.Output,
                     PortDirection.Inout,
                 )
-        raise ClassiqInternalExpansionError(
-            f"Cannot find {var_name!r} from {defining_function.name!r}"
-        )
+        return None
 
     def clone(self) -> "CapturedVars":
         return CapturedVars(
@@ -846,6 +846,10 @@ def validate_end_state(func: "FunctionClosure", captured_vars: CapturedVars) ->
     for param in func.positional_arg_declarations:
         if isinstance(param, PortDeclaration):
             state = captured_vars.get_state(param.name, func)
+            if state is None:
+                raise ClassiqInternalExpansionError(
+                    f"Cannot find {param.name!r} from {func.name!r}"
+                )
             expected_state = param.direction in (
                 PortDeclarationDirection.Output,
                 PortDeclarationDirection.Inout,

classiq/model_expansions/function_builder.py

@@ -13,6 +13,8 @@ from classiq.interface.generator.compiler_keywords import (
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
+    INVERT_OPERATOR_NAMES,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -44,6 +46,7 @@ BLOCKS_ALLOWED_CAPTURING = (
     WITHIN_APPLY_NAME,
     BLOCK_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
 )
 
 
@@ -155,6 +158,8 @@ class OperationBuilder:
         self._operations[-1].blocks[block_name] = block
         yield
         captured_vars = self.current_block.captured_vars
+        if self.current_operation.name in INVERT_OPERATOR_NAMES:
+            captured_vars = captured_vars.negate()
         if (
             not isinstance(self.current_operation, FunctionClosure)
             and self.current_operation.name not in BLOCKS_ALLOWED_CAPTURING
@@ -178,7 +183,10 @@ class OperationBuilder:
             context.closure.captured_vars.init_params(original_operation)
         else:
             context = OperationContext(closure=original_operation)
-            context.closure.captured_vars.set_parent(self.current_block.captured_vars)
+            if context.name != SINGLE_CALL_INVERT_OPERATOR_NAME:
+                context.closure.captured_vars.set_parent(
+                    self.current_block.captured_vars
+                )
         self._operations.append(context)
         yield context
         self._finalize_within_apply()

classiq/model_expansions/interpreters/base_interpreter.py

@@ -32,6 +32,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
@@ -76,6 +77,7 @@ from classiq.model_expansions.scope_initialization import (
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.constants import __all__ as builtin_constants
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
@@ -98,7 +100,7 @@ class BaseInterpreter:
     skip_type_modifier_validation: bool = False
 
     def __init__(self, model: Model) -> None:
-        validate_model(model)
+        validate_model(model, self.get_builtin_functions())
         self._model = model
         self._top_level_scope = Scope()
         self._counted_name_allocator = CountedNameAllocator()
@@ -121,6 +123,9 @@ class BaseInterpreter:
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
+    def get_builtin_functions(self) -> list[NamedParamsQuantumFunctionDeclaration]:
+        return CORE_LIB_DECLS
+
     def _expand_main_func(self) -> None:
         main_closure = self._get_main_closure(
             self._top_level_scope[MAIN_FUNCTION_NAME].value
@@ -207,15 +212,14 @@ class BaseInterpreter:
         expression: Expression,
         *,
         simplify: bool = False,
-        treat_qnum_as_float: bool = False,
     ) -> Evaluated:
         if expression.is_evaluated():
             return Evaluated(value=expression.value.value)
         expr_ast = ast.parse(expression.expr, mode="eval").body
-        expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
+        expr_val = self._eval_expr(ast.unparse(expr_ast))
         if simplify and not expr_val.has_value(expr_val.root):
             simplified_expr = simplify_qmod_expression(expr_val)
-            expr_val = self._eval_expr(simplified_expr, treat_qnum_as_float)
+            expr_val = self._eval_expr(simplified_expr)
         if expr_val.has_value(expr_val.root):
             value = expr_val.get_value(expr_val.root)
         else:
@@ -223,12 +227,9 @@ class BaseInterpreter:
 
         return Evaluated(value=value)
 
-    def _eval_expr(
-        self, expr: str, treat_qnum_as_float: bool
-    ) -> QmodAnnotatedExpression:
+    def _eval_expr(self, expr: str) -> QmodAnnotatedExpression:
         return evaluate_qmod_expression(
             expr,
-            treat_qnum_as_float=treat_qnum_as_float,
             machine_precision=self._model.preferences.machine_precision,
             classical_struct_declarations=list(QMODULE.type_decls.values()),
             enum_declarations=list(QMODULE.enum_decls.values()),

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -9,10 +9,11 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
     CLASSICAL_IF_OPERATOR_NAME,
+    COMPOUND_INVERT_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
-    INVERT_OPERATOR_NAME,
     POWER_OPERATOR_NAME,
     REPEAT_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
     SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -23,14 +24,11 @@ from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
@@ -199,24 +197,6 @@ class GenerativeInterpreter(BaseInterpreter):
             bind
         )
 
-    @emit.register
-    def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
-        CompositeEmitter[AmplitudeLoadingOperation](
-            self,
-            [
-                HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(
-                    self,
-                    "expression",
-                    readable_expression_name="amplitude-encoding expression",
-                    simplify=True,
-                    treat_qnum_as_float=True,
-                    allow_runtime_vars=self._symbolic_parameters_switch,
-                ),
-                AssignmentResultProcessor(self),
-            ],
-        ).emit(op)
-
     @emit.register
     def _emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
         self.emit_arithmetic_operation(op)
@@ -285,7 +265,12 @@ class GenerativeInterpreter(BaseInterpreter):
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                op_name = SINGLE_CALL_INVERT_OPERATOR_NAME
+            case BlockKind.Compound:
+                op_name = COMPOUND_INVERT_OPERATOR_NAME
+        BlockEvaluator(self, op_name, "body").emit(invert)
 
     @emit.register
     def emit_skip_control(self, skip_control: SkipControl) -> None:

classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -50,6 +50,7 @@ def convert_inplace_op_bool_expression(
 def _supported_types() -> tuple[str, ...]:
     return (
         QuantumBit().qmod_type_name,
+        QuantumNumeric().qmod_type_name,
         QuantumNumeric(
             size=Expression(expr="1"),
             is_signed=Expression(expr="False"),