classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/interface/generator/expressions/expression_types.py

@@ -1,35 +1,23 @@
-from typing import Union
+from enum import IntEnum
+from typing import TYPE_CHECKING, Union
 
-from sympy import Basic
-from sympy.logic.boolalg import Boolean
+import sympy
 
-from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
-    ClassicalProxy,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.type_proxy import TypeProxy
+
+if TYPE_CHECKING:
+    from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 
 RuntimeConstant = Union[
     int,
     float,
     list,
     bool,
+    complex,
+    IntEnum,
     QmodStructInstance,
-    TypeProxy,
-    HandleIdentifier,
-]
-Proxies = Union[
-    QmodSizedProxy,
-    ClassicalProxy,
+    sympy.Basic,
 ]
-RuntimeExpression = Union[AnyClassicalValue, Basic, Boolean]
-ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]
+ExpressionValue = Union[RuntimeConstant, "QmodAnnotatedExpression"]

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import sympy
 from sympy import Integer
@@ -8,9 +8,6 @@ from typing_extensions import TypeGuard
 from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -28,8 +25,6 @@ if TYPE_CHECKING:
 
 
 def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
-    if isinstance(val, AnyClassicalValue):
-        return False
     if isinstance(val, sympy.Basic):
         return val.is_Number
     return isinstance(val, int)
@@ -99,7 +94,7 @@ class ClassicalArrayProxy(ClassicalSequenceProxy):
         self,
         handle: HandleBinding,
         element_type: "ConcreteClassicalType",
-        length: "ExpressionValue",
+        length: Optional["ExpressionValue"],
     ) -> None:
         super().__init__(handle)
         self._element_type = element_type
@@ -108,7 +103,7 @@ class ClassicalArrayProxy(ClassicalSequenceProxy):
         self._length = length
 
     @property
-    def length(self) -> "ExpressionValue":
+    def length(self) -> Optional["ExpressionValue"]:
         return self._length
 
     def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:

classiq/interface/generator/expressions/proxies/classical/classical_proxy.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue
@@ -18,7 +18,7 @@ class ClassicalProxy:
         return str(self.handle)
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, Union["ExpressionValue", "ClassicalProxy"]]:
         raise NotImplementedError
 
     @property

classiq/interface/generator/expressions/proxies/classical/classical_struct_proxy.py

@@ -8,7 +8,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_proxy i
 from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
 
 if TYPE_CHECKING:
-    from classiq.interface.generator.expressions.expression_types import ExpressionValue
     from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
@@ -22,7 +21,7 @@ class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
         return self._decl
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, ClassicalProxy]:
         return {
             field_name: field_type.get_classical_proxy(
                 FieldHandleBinding(base_handle=self.handle, field=field_name)

classiq/interface/generator/functions/classical_type.py

@@ -9,9 +9,6 @@ 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,
-)
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
     ClassicalTupleProxy,
@@ -163,9 +160,9 @@ class ClassicalArray(ClassicalType):
         return self.length.to_int_value()
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        length: ExpressionValue
+        length: Optional[ExpressionValue]
         if self.length is None:
-            length = AnyClassicalValue(f"get_field({handle}, 'len')")
+            length = None
         elif not self.length.is_evaluated():
             raise ClassiqInternalExpansionError(
                 "Classical list length is not evaluated"

classiq/interface/generator/functions/concrete_types.py

@@ -47,7 +47,7 @@ PythonClassicalPydanticTypes = (Enum,)
 
 ConcreteQuantumType = Annotated[
     Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
-    Field(discriminator="kind", default_factory=QuantumBitvector),
+    Field(discriminator="kind"),
 ]
 QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()

classiq/interface/generator/functions/type_name.py

@@ -15,9 +15,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_scalar_
 from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
     ClassicalStructProxy,
 )
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
-    QmodQStructProxy,
-)
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
 )
@@ -59,15 +56,6 @@ class TypeName(ClassicalType, QuantumType):
                 field_type.size_in_bits for field_type in fields_types
             )
 
-    def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
-        from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
-            QmodQStructProxy,
-        )
-
-        return QmodQStructProxy(
-            handle=handle, struct_name=self.name, fields=self.fields
-        )
-
     @property
     def qmod_type_name(self) -> str:
         return self.name

classiq/interface/generator/generated_circuit_data.py

@@ -17,6 +17,7 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.block import Block
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
@@ -210,10 +211,13 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
             name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
             return name_with_suffix
+        if isinstance(back_ref, Block) and back_ref.label is not None:
+            return back_ref.label
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
             statement_kind = back_ref.operation_kind.value
+
         return self.add_suffix_from_generated_name(
             generated_name, STATEMENTS_NAME[statement_kind]
         )

classiq/interface/generator/preferences/qasm_to_qmod_params.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.enum_utils import StrEnum
+
+
+class QmodFormat(StrEnum):
+    NATIVE = "native"
+    PYTHON = "python"
+
+
+class QasmToQmodParams(BaseModel):
+    qasm: QasmCode
+    qmod_format: QmodFormat

classiq/interface/helpers/model_normalizer.py

@@ -1,4 +1,3 @@
-import ast
 from typing import Any
 
 from classiq.interface.ast_node import ASTNode
@@ -10,8 +9,6 @@ from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 
-from classiq.model_expansions.transformers.model_renamer import ExprNormalizer
-
 
 class ModelNormalizer(Visitor):
     def visit(self, node: Any) -> None:
@@ -28,9 +25,6 @@ class ModelNormalizer(Visitor):
         model.functions.sort(key=lambda x: x.name)
         self.generic_visit(model)
 
-    def visit_Expression(self, expr: Expression) -> None:
-        expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
-
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
 

classiq/interface/ide/visual_model.py

@@ -171,6 +171,7 @@ class Operation(pydantic.BaseModel):
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
     is_low_level_fallback: bool = pydantic.Field(default=False)
+    is_measurement: bool = pydantic.Field(default=False)
 
     model_config = ConfigDict(frozen=True)
 

classiq/interface/model/handle_binding.py

@@ -349,7 +349,7 @@ class FieldHandleBinding(NestedHandleBinding):
 
     @property
     def qmod_expr(self) -> str:
-        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+        return f"{self.base_handle.qmod_expr}.{self.field}"
 
     @property
     def identifier(self) -> str:

classiq/interface/model/port_declaration.py

@@ -13,10 +13,11 @@ from classiq.interface.generator.functions.type_modifier import (
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 
 class AnonPortDeclaration(Parameter):
-    quantum_type: ConcreteQuantumType
+    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
     direction: PortDeclarationDirection
     kind: Literal["PortDeclaration"]
     type_modifier: TypeModifier

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,12 +1,9 @@
 from collections.abc import Mapping, Sequence
-from typing import Literal
-
-from pydantic import PrivateAttr
+from typing import Literal, cast
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
-    compute_arithmetic_result_type,
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -18,6 +15,9 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.model_expansions.arithmetic import NumericAttributes
+
 
 class ArithmeticOperationKind(StrEnum):
     InplaceAdd = "inplace_add"
@@ -29,7 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
-    _classical_assignment: bool = PrivateAttr(default=False)
+    classical_assignment: bool = False
 
     @property
     def is_inplace(self) -> bool:
@@ -44,16 +44,20 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)
-        self._result_type = compute_arithmetic_result_type(
-            self.expression.expr, var_types, machine_precision
-        )
+        expr_val = self.expression.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            self._result_type = expr_val.get_quantum_type(expr_val.root)
+        else:
+            self._result_type = NumericAttributes.from_constant(
+                cast(float, expr_val), machine_precision
+            ).to_quantum_numeric()
 
     @property
     def wiring_inouts(
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -63,7 +67,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -74,13 +78,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return []
         return [
             HandleMetadata(

classiq/interface/model/quantum_type.py

@@ -15,20 +15,8 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
-    QmodQArrayProxy,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
-    QmodQBitProxy,
-    QmodQNumProxy,
-    QmodQScalarProxy,
-)
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
 from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
-from classiq.interface.model.handle_binding import HandleBinding
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
@@ -59,9 +47,6 @@ class QuantumType(HashableASTNode):
     def minimal_size_in_bits(self) -> int:
         raise NotImplementedError
 
-    def get_proxy(self, handle: "HandleBinding") -> QmodSizedProxy:
-        return QmodSizedProxy(handle=handle, size=self.size_in_bits)
-
     @property
     def qmod_type_name(self) -> str:
         raise NotImplementedError
@@ -95,9 +80,6 @@ class QuantumType(HashableASTNode):
 
 
 class QuantumScalar(QuantumType):
-    def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
-        return QmodQScalarProxy(handle, size=self.size_in_bits)
-
     @property
     def has_sign(self) -> bool:
         raise NotImplementedError
@@ -147,9 +129,6 @@ class QuantumBit(QuantumScalar):
     def qmod_type_name(self) -> str:
         return "QBit"
 
-    def get_proxy(self, handle: "HandleBinding") -> QmodQBitProxy:
-        return QmodQBitProxy(handle)
-
     @property
     def type_name(self) -> str:
         return "Quantum bit"
@@ -233,16 +212,6 @@ class QuantumBitvector(QuantumType):
         assert self.length is not None
         return self.length.to_int_value()
 
-    def get_proxy(self, handle: "HandleBinding") -> QmodQArrayProxy:
-        element_size = self.element_type.size_in_bits
-        assert self.size_in_bits % element_size == 0
-        return QmodQArrayProxy(
-            handle,
-            self.element_type,
-            element_size,
-            self.size_in_bits // element_size,
-        )
-
     @property
     def qmod_type_name(self) -> str:
         element_type = [self.element_type.qmod_type_name]
@@ -382,14 +351,6 @@ class QuantumNumeric(QuantumScalar):
         ):
             self._size_in_bits = self.size.to_int_value()
 
-    def get_proxy(self, handle: "HandleBinding") -> QmodQNumProxy:
-        return QmodQNumProxy(
-            handle,
-            size=self.size_in_bits,
-            fraction_digits=self.fraction_digits_value,
-            is_signed=self.sign_value,
-        )
-
     @property
     def qmod_type_name(self) -> str:
         if (
@@ -532,7 +493,7 @@ class QuantumNumeric(QuantumScalar):
 
 
 class RegisterQuantumType(BaseModel):
-    quantum_types: "ConcreteQuantumType"
+    quantum_types: "ConcreteQuantumType" = Field(default_factory=QuantumBitvector)
     size: int = Field(default=1)
 
     @property

classiq/interface/server/routes.py

@@ -44,9 +44,6 @@ TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 
-CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
-
-
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
@@ -75,6 +72,8 @@ CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
 )
+QASM_TO_QMOD_SUFFIX = "/qasm_to_qmod"
+QASM_TO_QMOD_FULL_PATH = CONVERSION_PREFIX + QASM_TO_QMOD_SUFFIX
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
 

classiq/model_expansions/capturing/captured_vars.py

@@ -1,3 +1,4 @@
+import ast
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
@@ -41,6 +42,7 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
@@ -60,9 +62,11 @@ 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))
-    )
+    expr_val = QmodAnnotatedExpression(ast.Name(id=symbol))
+    expr_val.set_type(expr_val.root, classical_type)
+    expr_val.set_var(expr_val.root, HandleBinding(name=symbol))
+    expr_val.lock()
+    expr._evaluated_expr = EvaluatedExpression(value=expr_val)
     return expr
 
 
@@ -550,6 +554,9 @@ class CapturedVars:
             ],
         )
 
+    def get_captured_classical_vars(self) -> list[str]:
+        return [var.name for var in self._captured_classical_vars]
+
     def get_captured_parameters(self) -> list[PositionalArg]:
         decls: list[PositionalArg]
         decls = [

classiq/model_expansions/closure.py

@@ -11,6 +11,7 @@ from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import QuantumCallable
 from classiq.interface.model.quantum_statement import QuantumStatement
@@ -111,6 +112,13 @@ class FunctionClosure(Closure):
     def emit(self) -> QuantumCallable:
         return self.name
 
+    def as_operand_declaration(self, is_list: bool) -> QuantumOperandDeclaration:
+        return QuantumOperandDeclaration(
+            name=self.name,
+            positional_arg_declarations=self.positional_arg_declarations,
+            is_list=is_list,
+        )
+
 
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):

classiq/model_expansions/function_builder.py

@@ -3,7 +3,10 @@ from contextlib import contextmanager
 from dataclasses import dataclass, field
 from typing import Generic, Optional, TypeVar
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.compiler_keywords import (
     EXPANDED_KEYWORD,
     LAMBDA_KEYWORD,
@@ -31,7 +34,7 @@ from classiq.model_expansions.capturing.captured_vars import (
     validate_end_state,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
-from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.scope import ClassicalSymbol, Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
@@ -190,6 +193,8 @@ class OperationBuilder:
                 self.current_function
             ).set_propagated()
             validate_captured_directions(captured_vars)
+        else:
+            self._validate_no_captured_runtime_params(captured_vars)
         if len(self._operations) < 2:
             return
         parent_block = self._operations[-2].blocks[self._blocks[-1]]
@@ -231,3 +236,14 @@ class OperationBuilder:
             raise ClassiqInternalExpansionError("Could not allocate function name")
 
         return name
+
+    def _validate_no_captured_runtime_params(self, captured_vars: CapturedVars) -> None:
+        if any(
+            var in self.current_scope
+            and isinstance(self.current_scope[var].value, ClassicalSymbol)
+            for var in captured_vars.get_captured_classical_vars()
+        ):
+            raise ClassiqExpansionError(
+                "Runtime classical variables can only be declared and used at the "
+                "function's top scope"
+            )