classiq 0.82.1__py3-none-any.whl → 0.83.0__py3-none-any.whl

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -21,7 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -475,7 +475,7 @@ def _get_chemistry_quantum_main(
             PortDeclaration(
                 name="qbv",
                 direction=PortDeclarationDirection.Output,
-                type_qualifier=TypeQualifier.Quantum,
+                type_modifier=TypeModifier.Mutable,
             )
         ],
         body=body,

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -12,8 +12,8 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -96,7 +96,7 @@ def construct_combi_opt_py_model(
                             length=Expression(expr=f"{len_hamiltonian}"),
                         ),
                         direction=PortDeclarationDirection.Output,
-                        type_qualifier=TypeQualifier.Quantum,
+                        type_modifier=TypeModifier.Mutable,
                     ),
                 ],
                 body=[

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.82.1'
+SEMVER_VERSION = '0.83.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/generator/application_apis/finance_declarations.py

@@ -9,8 +9,8 @@ from classiq.interface.generator.functions.classical_type import Real
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -56,13 +56,13 @@ def _generate_finance_function(
                     )
                 ),
                 direction=PortDeclarationDirection.Inout,
-                type_qualifier=TypeQualifier.Quantum,
+                type_modifier=TypeModifier.Mutable,
             ),
             PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
-                type_qualifier=TypeQualifier.Quantum,
+                type_modifier=TypeModifier.Mutable,
             ),
         ],
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -11,14 +11,18 @@ CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "molecule_ground_state_solution_post_process",
 }
 
-SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
-    *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
+CLASSIQ_EXPR_FUNCTIONS = {
     "do_div",
     "do_slice",
     "do_subscript",
     "get_type",
     "struct_literal",
     "get_field",
+}
+
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
+    *CLASSIQ_EXPR_FUNCTIONS,
     "mod_inverse",
 }
 

classiq/interface/generator/functions/type_modifier.py

@@ -0,0 +1,41 @@
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+
+
+class TypeQualifier(StrEnum):
+    Const = "const"
+    QFree = "qfree"
+    Quantum = "quantum"
+    Inferred = "inferred"
+
+    def to_modifier(self) -> "TypeModifier":
+        if self is TypeQualifier.Const:
+            return TypeModifier.Const
+        elif self is TypeQualifier.QFree:
+            return TypeModifier.Permutable
+        elif self is TypeQualifier.Quantum:
+            return TypeModifier.Mutable
+        elif self is TypeQualifier.Inferred:
+            return TypeModifier.Inferred
+        else:
+            raise ClassiqInternalExpansionError(f"Unexpected type qualifier: {self}")
+
+
+class TypeModifier(StrEnum):
+    Const = "const"
+    Permutable = "permutable"
+    Mutable = "mutable"
+    Inferred = "inferred"
+
+    @staticmethod
+    def and_(first: "TypeModifier", second: "TypeModifier") -> "TypeModifier":
+        if second is TypeModifier.Inferred:
+            raise ClassiqInternalExpansionError
+        if first is TypeModifier.Mutable or second is TypeModifier.Mutable:
+            return TypeModifier.Mutable
+        elif first is TypeModifier.Permutable or second is TypeModifier.Permutable:
+            return TypeModifier.Permutable
+        else:
+            if first is not TypeModifier.Const and second is not TypeModifier.Const:
+                raise ClassiqInternalExpansionError("Unexpected type modifiers")
+            return TypeModifier.Const

classiq/interface/generator/generated_circuit_data.py

@@ -202,8 +202,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     @property
     def name(self) -> str:
         generated_name = self.generated_function.name if self.generated_function else ""
-        # Temp fix for currently "supported" statements (same as for level_ property)
-        if generated_name in {StatementType.CONTROL, StatementType.POWER}:
+        # Temp fix for remaining old "supported" statements - power
+        if generated_name == StatementType.POWER:
             return generated_name
 
         back_ref = self.first_back_ref
@@ -243,8 +243,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def level(self) -> OperationLevel:
-        # Temp fix for currently "supported" statements
-        if self.name in {StatementType.CONTROL, StatementType.POWER}:
+        # Temp fix for remaining old "supported" statements - power
+        if self.name == StatementType.POWER:
             return OperationLevel.QMOD_STATEMENT
 
         if self.first_back_ref is None:
@@ -275,15 +275,12 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def control_qubits(self) -> tuple[int, ...]:
-        control_states_names = {
-            control_state.name for control_state in self.control_states
-        }
         return tuple(
             qubit
             for register in self.registers
             for qubit in register.qubit_indexes_absolute
             if register.role is RegisterRole.INPUT
-            and register.name in control_states_names
+            and register.name == self.control_variable
         )
 
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":

classiq/interface/generator/model/model.py

@@ -11,6 +11,9 @@ from classiq.interface.generator.types.qstruct_declaration import QStructDeclara
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 TYPE_LIBRARY_DUPLICATED_TYPE_NAMES = (
@@ -71,3 +74,8 @@ class ExecutionModel(ClassiqBaseModel):
     register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
         default_factory=dict,
     )
+
+    circuit_execution_params: dict[str, ClassicalParameterDeclaration] = pydantic.Field(
+        default_factory=dict,
+        description="Mapping between a execution parameter name and its declaration",
+    )

classiq/interface/generator/quantum_program.py

@@ -166,19 +166,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         with open(filename, "w") as file:
             file.write(self.model_dump_json(indent=4))
 
-    @classmethod
-    def from_qprog(cls, qprog: "QuantumProgram") -> "QuantumProgram":
-        """
-        Creates a `QuantumProgram` instance from a raw quantum program string.
-
-        Args:
-            qprog: The raw quantum program in string format.
-
-        Returns:
-            QuantumProgram: The `QuantumProgram` instance.
-        """
-        return qprog
-
     @property
     def _can_use_transpiled_code(self) -> bool:
         return self.data.execution_data is None

classiq/interface/generator/types/compilation_metadata.py

@@ -8,7 +8,7 @@ class CompilationMetadata(BaseModel):
     unchecked: list[str] = Field(default_factory=list)
     atomic_qualifiers: list[str] = Field(
         default_factory=list, exclude=True
-    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671                                                                                                                                                                                       atomic_qualifiers: list[str] = Field(default_factory=list)
+    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671
 
     @property
     def occupation_number(self) -> NonNegativeInt:

classiq/interface/helpers/model_normalizer.py

@@ -5,7 +5,7 @@ from classiq.interface.ast_node import ASTNode
 from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import ClassicalType
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
 from classiq.interface.model.port_declaration import AnonPortDeclaration
@@ -32,7 +32,7 @@ class ModelNormalizer(Visitor):
         expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
 
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
-        decl.type_qualifier = TypeQualifier.Quantum
+        decl.type_modifier = TypeModifier.Mutable
 
 
 class ClearModelInternals(Transformer):

classiq/interface/model/port_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal
+from typing import Any, Literal, Optional
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -8,7 +8,10 @@ from classiq.interface.generator.functions.concrete_types import ConcreteQuantum
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import (
+    TypeModifier,
+    TypeQualifier,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
 
@@ -16,14 +19,35 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    type_qualifier: TypeQualifier
+    type_qualifier: Optional[TypeQualifier] = pydantic.Field(
+        default=None, exclude=True
+    )  # TODO remove after BWC breaking release https://classiq.atlassian.net/browse/CLS-2777
     kind: Literal["PortDeclaration"]
+    type_modifier: TypeModifier = pydantic.Field(default=None)
 
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "PortDeclaration")
 
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_type_modifier(cls, values: Any) -> dict[str, Any]:
+        if values.get("type_modifier") is None:
+            type_qualifier = values.get("type_qualifier")
+            if type_qualifier is not None:
+                if isinstance(type_qualifier, TypeQualifier):
+                    values["type_modifier"] = type_qualifier.to_modifier()
+                elif isinstance(type_qualifier, str):
+                    values["type_modifier"] = TypeQualifier(
+                        type_qualifier
+                    ).to_modifier()
+                else:
+                    raise pydantic.ValidationError("Missing a type modifier")
+            else:
+                raise pydantic.ValidationError("Missing a type modifier")
+        return values
+
     @pydantic.field_validator("direction", mode="before")
     @classmethod
     def _direction_validator(

classiq/model_expansions/capturing/captured_vars.py

@@ -10,6 +10,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     CLASSICAL_ATTRIBUTES_TYPES,
@@ -18,7 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.helpers.text_utils import are, readable_list, s, they
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -56,6 +59,14 @@ 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:
+    expr = Expression(expr=symbol)
+    expr._evaluated_expr = EvaluatedExpression(
+        value=classical_type.get_classical_proxy(handle=HandleBinding(name=symbol))
+    )
+    return expr
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Inout = "inout"
@@ -138,7 +149,7 @@ class _CapturedHandle(_Captured):
             name=self.mangled_name,
             quantum_type=self.quantum_type,
             direction=self.direction.dump(),
-            type_qualifier=TypeQualifier.Inferred,  # TODO https://classiq.atlassian.net/browse/CLS-1830
+            type_modifier=TypeModifier.Inferred,
         )
 
     def is_same_var(self, other: "_CapturedHandle") -> bool:
@@ -556,24 +567,26 @@ class CapturedVars:
     def get_captured_args(self, current_function: "FunctionClosure") -> list[ArgValue]:
         args: list[ArgValue]
         args = [
-            Expression(
-                expr=(
+            _get_symbol_expr(
+                (
                     captured_classical_var.name
                     if _same_closure(
                         current_function, captured_classical_var.defining_function
                     )
                     else captured_classical_var.mangled_name
-                )
+                ),
+                captured_classical_var.classical_type,
             )
             for captured_classical_var in self._captured_classical_vars
         ]
         args += [
-            Expression(
-                expr=(
+            _get_symbol_expr(
+                (
                     str(captured_qta.handle)
                     if _same_closure(current_function, captured_qta.defining_function)
                     else captured_qta.mangled_name
-                )
+                ),
+                captured_qta.classical_type,
             )
             for captured_qta in self._captured_quantum_type_attributes
         ]

classiq/model_expansions/evaluators/argument_types.py

@@ -3,7 +3,7 @@ from collections.abc import Sequence
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 from classiq.interface.model.quantum_type import QuantumNumeric
@@ -56,7 +56,7 @@ def handle_args_numeric_bounds(
 
         if (
             parameter.direction != PortDeclarationDirection.Output
-            and parameter.type_qualifier != TypeQualifier.Const
+            and parameter.type_modifier != TypeModifier.Const
             and isinstance(argument_as_quantum_symbol.quantum_type, QuantumNumeric)
         ):
             argument_as_quantum_symbol.quantum_type.reset_bounds()

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -28,7 +28,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.text_utils import are, readable_list, s
@@ -80,8 +80,8 @@ from classiq.model_expansions.scope import (
     QuantumVariable,
     Scope,
 )
-from classiq.model_expansions.transformers.type_qualifier_inference import (
-    TypeQualifierValidation,
+from classiq.model_expansions.transformers.type_modifier_inference import (
+    TypeModifierValidation,
 )
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
@@ -291,7 +291,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         context = self._expand_operation(function)
         function_context = cast(FunctionContext, context)
         function_def = self._create_function_definition(function_context, args)
-        self._validate_type_qualifiers(function_context, function_def)
+        self._validate_type_modifiers(function_context, function_def)
         self._expanded_functions[cache_key] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -415,29 +415,29 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             if var_state and param.direction == PortDeclarationDirection.Output:
                 raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
 
-    def _validate_type_qualifiers(
+    def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:
-        if self._should_override_type_qualifiers(func_context):
-            self._override_type_qualifiers(func_def)
+        if self._should_override_type_modifiers(func_context):
+            self._override_type_modifiers(func_def)
 
         unchecked = self._functions_compilation_metadata.get(
             func_context.name, CompilationMetadata()
         ).unchecked
-        TypeQualifierValidation(
+        TypeModifierValidation(
             skip_validation=self._interpreter.skip_type_modifier_validation
         ).run(func_def.port_declarations, func_def.body, unchecked)
 
     @staticmethod
-    def _should_override_type_qualifiers(func_context: FunctionContext) -> bool:
+    def _should_override_type_modifiers(func_context: FunctionContext) -> bool:
         """
-        The type qualifier can be changed according to the operand passed to the
+        The type modifier can be changed according to the operand passed to the
         function. For example,
-        apply_to_all(X, q) --> q will be QFree after expansion
+        apply_to_all(X, q) --> q will be Permutable after expansion
         apply_to_all(H, q) --> q will be Quantum after expansion
         This also holds for the intermediate lambda created during the expansion.
 
-        We don't override the type qualifier if it's explicitly specified (QFree or
+        We don't override the type modifier if it's explicitly specified (Permutable or
         Const), neither in the function declaration nor in the operand declaration.
         """
 
@@ -461,8 +461,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
 
     @staticmethod
-    def _override_type_qualifiers(func_def: NativeFunctionDefinition) -> None:
-        # only override the qualifier if it's unspecified (not QFree or Const)
+    def _override_type_modifiers(func_def: NativeFunctionDefinition) -> None:
+        # only override the modifier if it's unspecified (not Permutable or Const)
         for port in func_def.port_declarations:
-            if port.type_qualifier is TypeQualifier.Quantum:
-                port.type_qualifier = TypeQualifier.Inferred
+            if port.type_modifier is TypeModifier.Mutable:
+                port.type_modifier = TypeModifier.Inferred

classiq/model_expansions/transformers/model_renamer.py

@@ -6,7 +6,13 @@ from functools import cmp_to_key
 from typing import TypeVar, cast
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model_visitor import ModelTransformer
@@ -99,7 +105,10 @@ def _rewrite_expression(
         new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
 
     new_expr = Expression(expr=new_expr_str)
-    new_expr._evaluated_expr = expression._evaluated_expr
+    if not new_expr.is_evaluated():
+        new_expr._evaluated_expr = EvaluatedExpression(
+            value=AnyClassicalValue(new_expr_str)
+        )
     return new_expr