classiq 0.90.0__py3-none-any.whl → 0.91.1__py3-none-any.whl

classiq/evaluators/expression_evaluator.py

@@ -1,38 +1,34 @@
-import ast
-from collections.abc import Mapping
-from enum import EnumMeta
+from enum import Enum
 from typing import Any
 
-from sympy import SympifyError, sympify
+import sympy
 
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.expressions.evaluated_expression import (
-    EvaluatedExpression,
-)
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.expression_types import ExpressionValue
-from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.sympy_supported_expressions import (
-    SYMPY_SUPPORTED_EXPRESSIONS,
+from classiq.interface.generator.expressions.expression_types import RuntimeConstant
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
 )
 
 from classiq.evaluators.classical_expression import evaluate_classical_expression
-from classiq.model_expansions.atomic_expression_functions_defs import (
-    ATOMIC_EXPRESSION_FUNCTIONS,
-    qmod_val_to_python,
-)
 from classiq.model_expansions.scope import Evaluated, Scope
-from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
-    translate_to_sympy,
-)
-from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
-from classiq.qmod import symbolic
-from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
-from classiq.qmod.model_state_container import QMODULE
+
+
+def qmod_val_to_python(val: RuntimeConstant) -> Any:
+    if isinstance(val, (int, float, bool, complex, Enum)):
+        return val
+    if isinstance(val, list):
+        return [qmod_val_to_python(item) for item in val]
+    if isinstance(val, QmodStructInstance):
+        return {
+            field_name: qmod_val_to_python(field_val)
+            for field_name, field_val in val.fields.items()
+        }
+    if isinstance(val, sympy.Expr):
+        return val.evalf()
+    raise ClassiqInternalExpansionError(
+        f"Could not convert Qmod value {str(val)!r} of type {type(val).__name__} to Python"
+    )
 
 
 def evaluate_constants(constants: list[Constant]) -> Scope:
@@ -47,102 +43,6 @@ def evaluate_constants(constants: list[Constant]) -> Scope:
 def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     evaluated = evaluate_constants(constants)
     return {
-        constant.name: qmod_val_to_python(
-            evaluated[constant.name].value, constant.const_type
-        )
+        constant.name: qmod_val_to_python(evaluated[constant.name].value)
         for constant in constants
     }
-
-
-def _quick_eval(expr: str) -> Any:
-    try:
-        return int(expr)
-    except ValueError:
-        pass
-    try:
-        return float(expr)
-    except ValueError:
-        pass
-    return None
-
-
-def evaluate(
-    expr: Expression, locals_dict: Mapping[str, EvaluatedExpression]
-) -> EvaluatedExpression:
-    val = _quick_eval(expr.expr)
-    if val is not None:
-        return EvaluatedExpression(value=val)
-
-    model_locals: dict[str, Any] = {}
-    model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
-    model_locals.update(
-        {
-            enum_decl.name: enum_decl.create_enum()
-            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
-        }
-    )
-    # locals override builtin-functions
-    model_locals.update({name: expr.value for name, expr in locals_dict.items()})
-
-    _validate_undefined_vars(expr.expr, model_locals)
-
-    sympy_expr = translate_to_sympy(expr.expr)
-    try:
-        sympify_result = sympify(sympy_expr, locals=model_locals)
-    except (TypeError, IndexError) as e:
-        raise ClassiqExpansionError(str(e)) from e
-    except AttributeError as e:
-        if isinstance(e.obj, EnumMeta):
-            raise ClassiqExpansionError(
-                f"Enum {e.obj.__name__} has no member {e.name!r}. Available members: "
-                f"{', '.join(e.obj.__members__)}"
-            ) from e
-        raise
-    except SympifyError as e:
-        expr = e.expr
-        if isinstance(expr, QmodSizedProxy) and isinstance(expr, NonSymbolicExpr):
-            raise ClassiqExpansionError(
-                f"{expr.type_name} {str(expr)!r} does not support arithmetic operations"
-            ) from e
-        raise
-
-    return EvaluatedExpression(
-        value=sympy_to_python(sympify_result, locals=model_locals)
-    )
-
-
-def _validate_undefined_vars(
-    expr: str, model_locals: dict[str, ExpressionValue]
-) -> None:
-    id_visitor = _VarsCollector()
-    id_visitor.visit(ast.parse(expr))
-    identifiers = id_visitor.vars
-    undefined_vars = (
-        identifiers
-        - model_locals.keys()
-        - set(SYMPY_SUPPORTED_EXPRESSIONS)
-        - set(symbolic.__all__)
-    )
-
-    if len(undefined_vars) == 1:
-        undefined_var = undefined_vars.__iter__().__next__()
-        raise ClassiqExpansionError(f"Variable {undefined_var!r} is undefined")
-    elif len(undefined_vars) > 1:
-        raise ClassiqExpansionError(f"Variables {list(undefined_vars)} are undefined")
-
-
-class _VarsCollector(ast.NodeTransformer):
-    def __init__(self) -> None:
-        self.vars: set[str] = set()
-
-    def visit_Name(self, node: ast.Name) -> None:
-        self.vars.add(node.id)
-
-    def visit_Call(self, node: ast.Call) -> None:
-        func = node.func
-        self.visit(func)
-        if not isinstance(func, ast.Name) or func.id != "struct_literal":
-            for arg in node.args:
-                self.visit(arg)
-        for kw in node.keywords:
-            self.visit(kw)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -23,7 +23,14 @@ from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     LShift,
     RShift,
 )
-from classiq.model_expansions.atomic_expression_functions_defs import do_div
+
+
+def _div_wrapper(lhs: Any, rhs: Any) -> Any:
+    res = lhs / rhs
+    if isinstance(res, sympy.Expr):
+        res = res.evalf()
+    return res
+
 
 _SYMPY_WRAPPERS = {
     wrapper.__name__: wrapper
@@ -36,7 +43,7 @@ _SYMPY_WRAPPERS = {
         RShift,
     ]
 } | {
-    do_div.__name__: do_div,
+    _div_wrapper.__name__: _div_wrapper,
 }
 
 _PY_NODE = TypeVar("_PY_NODE", bound=ast.AST)
@@ -172,7 +179,7 @@ class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
             sympy_func = BitwiseAnd.__name__
         elif isinstance(node.op, ast.Div):
             return ast.Call(
-                func=ast.Name(id=do_div.__name__),
+                func=ast.Name(id=_div_wrapper.__name__),
                 args=[node.left, node.right],
                 keywords=[],
             )

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -65,14 +65,6 @@ def get_numeric_properties(
     return size, is_signed, fraction_digits
 
 
-def qnum_is_qint(qmod_type: QuantumType) -> bool:
-    return isinstance(qmod_type, QuantumBit) or (
-        isinstance(qmod_type, QuantumNumeric)
-        and (not qmod_type.has_sign or not qmod_type.sign_value)
-        and (not qmod_type.has_fraction_digits or qmod_type.fraction_digits_value == 0)
-    )
-
-
 def element_types(
     classical_type: Union[ClassicalArray, ClassicalTuple],
 ) -> list[ClassicalType]:

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.90.0'
+SEMVER_VERSION = '0.91.1'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/executor/result.py

@@ -1,4 +1,6 @@
+import cmath
 import functools
+import math
 import operator
 from collections import defaultdict
 from collections.abc import Iterator, Mapping
@@ -46,6 +48,8 @@ BITSTRING = "bitstring"
 PROBABILITY = "probability"
 AMPLITUDE = "amplitude"
 COUNT = "count"
+MAGNITUDE = "magnitude"
+PHASE = "phase"
 
 if TYPE_CHECKING:
     DotAccessParsedState = Mapping[Name, Any]
@@ -191,6 +195,14 @@ def _flatten_columns(df: pd.DataFrame, columns_to_flatten: list[str]) -> pd.Data
     return final_df[valid_final_columns]
 
 
+def _pretty_magnitude_phase_from_amplitude(amplitude: complex) -> tuple[str, str]:
+    magnitude_str = f"{abs(amplitude):.2f}"
+    phase = cmath.phase(amplitude) / math.pi
+    phase_str = f"{phase:.2f}π"
+
+    return magnitude_str, phase_str
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -377,11 +389,14 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         for bitstring, amplitude in self.state_vector.items():
             data[BITSTRING].append(bitstring)
             data[AMPLITUDE].append(amplitude)
+            magnitude, phase = _pretty_magnitude_phase_from_amplitude(amplitude)
+            data[MAGNITUDE].append(magnitude)
+            data[PHASE].append(phase)
             data[PROBABILITY].append(abs(amplitude) ** 2)
             for name, value in self.parsed_state_vector_states[bitstring].items():
                 data[name].append(value)
 
-        final_columns = [AMPLITUDE, PROBABILITY, BITSTRING]
+        final_columns = [AMPLITUDE, MAGNITUDE, PHASE, PROBABILITY, BITSTRING]
         columns = [
             col for col in data.keys() if col not in final_columns
         ] + final_columns
@@ -390,12 +405,16 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @functools.cached_property
     def dataframe(self) -> pd.DataFrame:
-        reserved_words = frozenset([BITSTRING, PROBABILITY, COUNT, AMPLITUDE])
+        reserved_words = frozenset(
+            [BITSTRING, PROBABILITY, COUNT, AMPLITUDE, PHASE, MAGNITUDE]
+        )
         _invalid_output_names = reserved_words.intersection(
             self.output_qubits_map.keys()
         )
         if _invalid_output_names:
-            raise ClassiqValueError(f"Invalid output names: {_invalid_output_names}")
+            raise ClassiqValueError(
+                f"The following names are reserved and cannot be used as outputs when constructing a dataframe: {_invalid_output_names}"
+            )
 
         if self.state_vector:
             df = self._state_vector_df()

classiq/interface/generator/expressions/expression_types.py

@@ -1,3 +1,4 @@
+from enum import IntEnum
 from typing import TYPE_CHECKING, Union
 
 import sympy
@@ -15,6 +16,7 @@ RuntimeConstant = Union[
     list,
     bool,
     complex,
+    IntEnum,
     QmodStructInstance,
     sympy.Basic,
 ]

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/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/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/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 (

classiq/model_expansions/capturing/captured_vars.py

@@ -554,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/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"
+            )

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -4,8 +4,6 @@ import os
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.source_reference import SourceReference
 
@@ -13,8 +11,6 @@ from classiq.model_expansions.closure import FunctionClosure, GenerativeFunction
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
-from classiq.model_expansions.quantum_operations import BindEmitter
-from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
@@ -23,12 +19,6 @@ from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
-    def emit_allocate(self, allocate: Allocate) -> None:
-        AllocateEmitter(self, allow_symbolic_attrs=True).emit(allocate)
-
-    def emit_bind(self, bind: BindOperation) -> None:
-        BindEmitter(self, allow_symbolic_size=True).emit(bind)
-
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)