classiq 0.84.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/qmod/classical_variable.py

@@ -0,0 +1,74 @@
+import sys
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Bool, ClassicalType
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.qmod.cparam import CBool, CParam, CParamScalar
+from classiq.qmod.qmod_variable import QBit, _infer_variable_name
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import symbolic_function
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES
+from classiq.qmod.utilities import get_source_ref
+
+
+def declare_classical_variable(
+    name: str, classical_type: ClassicalType, frame_depth: int
+) -> None:
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        VariableDeclarationStatement(
+            name=name,
+            qmod_type=classical_type,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def assign_classical_variable(target: CParam, value: Any, frame_depth: int) -> None:
+    if not isinstance(value, SYMBOLIC_TYPES):
+        raise TypeError(f"Invalid argument {value!r} for classical variable assignment")
+
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(value)),
+            result_var=HandleBinding(name=str(target)),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def measure(var: QBit) -> CParamScalar:
+    """
+    Measures the given qubit. `measure` is a non-unitary operation.
+
+    Args:
+        var: a qubit variable
+
+    Returns:
+        the measurement result (a symbolic boolean variable)
+    """
+    name = _infer_variable_name(None, 2)
+    if name is None:
+        raise ClassiqInternalError("Could not infer measure var name")
+    declare_classical_variable(name, Bool(), 2)
+    res_var = CParamScalar(name)
+    res_val = symbolic_function(
+        var,
+        return_type=CBool,  # type:ignore[type-abstract]
+    )
+    assign_classical_variable(res_var, res_val, 2)
+    return res_var

classiq/qmod/native/pretty_printer.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -76,9 +77,6 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -189,11 +187,6 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         modifier_str = (
             f"{port_decl.type_modifier} "
@@ -263,9 +256,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return type_.name
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self, var_decl: VariableDeclarationStatement
     ) -> str:
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)};\n"
+        return f"{self._indent}{var_decl.name}: {self.visit(var_decl.qmod_type)};\n"
 
     def visit_AnonQuantumOperandDeclaration(
         self, op_decl: AnonQuantumOperandDeclaration
@@ -361,10 +354,10 @@ class DSLPrettyPrinter(ModelVisitor):
         return invert_code
 
     def visit_Block(self, block: Block) -> str:
-        invert_code = f"{self._indent}block {{\n"
-        invert_code += self._visit_body(block.statements)
-        invert_code += f"{self._indent}}}\n"
-        return invert_code
+        block_code = f"{self._indent}{{\n"
+        block_code += self._visit_body(block.statements)
+        block_code += f"{self._indent}}}\n"
+        return block_code
 
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
@@ -443,6 +436,17 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target});\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound});\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "  " * self._level

classiq/qmod/pretty_print/pretty_printer.py

@@ -30,6 +30,8 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -75,9 +77,6 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -91,6 +90,8 @@ from classiq.qmod.pretty_print.expression_to_python import transform_expression
 
 
 class VariableDeclarationAssignment(Visitor):
+    # FIXME: Support classical variable types
+
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
@@ -251,11 +252,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         var_type = self._extract_port_type(port_decl)
         return f"{port_decl.name}: {var_type}"
@@ -361,14 +357,23 @@ class PythonPrettyPrinter(ModelVisitor):
             self._imports[type_.name] = 1
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self,
+        local_decl: VariableDeclarationStatement,
+        walrus: bool = False,
     ) -> str:
         type_name, params = VariableDeclarationAssignment(self).visit(
-            local_decl.quantum_type
+            local_decl.qmod_type
         )
         params = [f'"{local_decl.name}"'] + params
         param_args = ", ".join(params)
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)} = {type_name}({param_args})\n"
+
+        res = f"{self._indent}{local_decl.name}"
+        if walrus:
+            res += " := "
+        else:
+            res += f": {self.visit(local_decl.qmod_type)} = "
+        res += f"{type_name}({param_args})\n"
+        return res
 
     def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
         if isinstance(arg_decl, AnonPortDeclaration):
@@ -476,6 +481,10 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["invert"] = 1
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
+    def visit_Block(self, block: Block) -> str:
+        self._imports["block"] = 1
+        return f"{self._indent}block({self._visit_body(block.statements)})\n"
+
     def _visit_body(
         self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
@@ -488,10 +497,8 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level += 1
         for i, statement in enumerate(body):
             if isinstance(statement, VariableDeclarationStatement):
-                raise AssertionError(
-                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
-                )
-            if isinstance(statement, AmplitudeLoadingOperation):
+                code += self.visit_VariableDeclarationStatement(statement, walrus=True)
+            elif isinstance(statement, AmplitudeLoadingOperation):
                 code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
             elif isinstance(statement, ArithmeticOperation):
                 code += self.visit_ArithmeticOperation(statement, in_lambda=True)
@@ -574,6 +581,18 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        self._imports["reset_bounds"] = 1
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target})\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound})\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "    " * self._level

classiq/qmod/qfunc.py

@@ -1,7 +1,6 @@
-import warnings
 from typing import Callable, Literal, Optional, Union, overload
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqInternalError
+from classiq.interface.exceptions import ClassiqInternalError
 
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.quantum_callable import QCallable
@@ -57,23 +56,7 @@ def qfunc(
     synthesize_separately: bool = False,
     unchecked: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
-    if generative is True:
-        warnings.warn(
-            "The use of `generative=True` is no longer required. Note that the "
-            "treatment of parameters of Qmod types will change from Python value to "
-            "symbolic in a near release. Change Qmod types to the corresponding Python "
-            "built-in types in order to use the parameters in Python expression "
-            "contexts.\n"
-            "Recommended changes:\n"
-            "@qfunc(generative=True) -> @qfunc\n"
-            "CInt->int\n"
-            "CReal->float\n"
-            "CArray->list\n\n"
-            "For more information see https://docs.classiq.io/latest/qmod-reference/language-reference/generative-descriptions/",
-            ClassiqDeprecationWarning,
-            stacklevel=2,
-        )
-    elif generative is None:
+    if generative is None:
         generative = True
     if get_global_declarative_switch():
         generative = False

classiq/qmod/qmod_variable.py

@@ -74,7 +74,7 @@ from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
-from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES, SymbolicTypes
 from classiq.qmod.utilities import (
     get_source_ref,
     unwrap_forward_ref,
@@ -104,9 +104,6 @@ def _infer_variable_name(name: Any, depth: int) -> Any:
     return name
 
 
-_SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))
-
-
 class QVar(Symbolic):
     CONSTRUCTOR_DEPTH: int = 1
 
@@ -230,7 +227,7 @@ class QScalar(QVar, SymbolicExpr):
         )
 
     def __ior__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
@@ -241,7 +238,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __ixor__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -252,7 +249,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __iadd__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
@@ -263,7 +260,7 @@ class QScalar(QVar, SymbolicExpr):
         return self
 
     def __imul__(self, other: Any) -> Self:
-        if not isinstance(other, _SYMBOLIC_TYPES):
+        if not isinstance(other, SYMBOLIC_TYPES):
             raise TypeError(
                 f"Invalid argument {other!r} for out of ampltiude encoding operation"
             )

classiq/qmod/quantum_expandable.py

@@ -135,7 +135,7 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
     ) -> None:
         self.append_statement_to_body(
             VariableDeclarationStatement(
-                name=name, quantum_type=qtype, source_ref=source_ref
+                name=name, qmod_type=qtype, source_ref=source_ref
             )
         )
 

classiq/qmod/quantum_function.py

@@ -1,12 +1,13 @@
 import ast
 import functools
+import warnings
 from abc import abstractmethod
 from dataclasses import is_dataclass
 from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Optional, get_origin
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -28,7 +29,7 @@ from classiq.qmod.declaration_inferrer import infer_func_decl, is_qvar
 from classiq.qmod.generative import set_frontend_interpreter
 from classiq.qmod.global_declarative_switch import get_global_declarative_switch
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_parameter import CArray, CParamList
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
@@ -218,6 +219,7 @@ class QFunc(BaseQFunc):
 
 
 class ExternalQFunc(QTerminalCallable):
+    FRAME_DEPTH = 2  # FIXME: Remove (CLS-2912)
     _decl: NamedParamsQuantumFunctionDeclaration
 
     def __init__(self, py_callable: Callable) -> None:
@@ -242,6 +244,44 @@ class ExternalQFunc(QTerminalCallable):
     def pure_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self.func_decl
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        if self._py_callable.__name__ == "parametric_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'parametric_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'multi_suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if self._py_callable.__name__ == "sparse_suzuki_trotter":
+            warnings.warn(
+                (
+                    "Function 'sparse_suzuki_trotter' is deprecated and will no "
+                    "longer be supported starting on 21/7/2025 at the earliest. "
+                    "Instead, use 'suzuki_trotter'."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        if (
+            self._py_callable.__name__ == "suzuki_trotter"
+            and len(args) > 0
+            and isinstance(args[0], (list, CParamList))
+        ):
+            warnings.warn(
+                (
+                    "Parameter type CArray[PauliTerm] to function 'suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 21/7/2025 "
+                    "at the earliest. Instead, send a 'SparsePauliOp' (see "
+                    "https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians)."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+        super().__call__(*args, **kwargs)
+
 
 class GenerativeQFunc(BaseQFunc):
     FRAME_DEPTH = 3

classiq/qmod/symbolic_type.py

@@ -1,5 +1,6 @@
-from typing import Union
+from typing import Union, get_args, get_origin
 
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 SymbolicTypes = Union[SymbolicExpr, int, float, bool, tuple["SymbolicTypes", ...]]
+SYMBOLIC_TYPES = tuple(get_origin(t) or t for t in get_args(SymbolicTypes))

{classiq-0.84.0.dist-info → classiq-0.85.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: classiq
-Version: 0.84.0
+Version: 0.85.0
 Summary: Classiq's Python SDK for quantum computing
 License: Proprietary
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL