classiq 0.40.0__py3-none-any.whl → 0.41.1__py3-none-any.whl

classiq/qmod/__init__.py

@@ -5,7 +5,7 @@ from .cfunc import cfunc
 from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
-from .qmod_parameter import Array, CArray, CBool, CInt, CReal, QParam
+from .qmod_parameter import Array, CArray, CBool, CInt, CReal
 from .qmod_struct import struct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
 from .quantum_callable import QCallable, QCallableList
@@ -26,7 +26,6 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
-    "QParam",
     "struct",
     "qfunc",
     "cfunc",

classiq/qmod/builtins/classical_execution_primitives.py

@@ -2,7 +2,12 @@ from typing import Dict, List, Optional, Union
 
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
-from classiq.interface.executor.result import EstimationResult, ExecutionDetails
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.expressions.enums import Optimizer
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
@@ -31,16 +36,29 @@ def sample(  # type: ignore[return]
     _raise_error("sample")
 
 
+def batch_sample(  # type: ignore[return]
+    batch_execution_params: List[ExecutionParams],
+) -> MultipleExecutionDetails:
+    _raise_error("batch_sample")
+
+
 def estimate(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
 
+def batch_estimate(  # type: ignore[return]
+    hamiltonian: List[QmodPyStruct],
+    batch_execution_params: List[ExecutionParams],
+) -> EstimationResults:
+    _raise_error("batch_estimate")
+
+
 def vqe(  # type: ignore[return]
     hamiltonian: List[QmodPyStruct],
     maximize: bool,
-    initial_point: List[int],
+    initial_point: List[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -87,7 +105,9 @@ __all__ = [
     "ExecutionParams",
     "save",
     "sample",
+    "batch_sample",
     "estimate",
+    "batch_estimate",
     "vqe",
     "qae_with_qpe_result_post_processing",
     "qsvm_full_run",

classiq/qmod/builtins/functions.py

@@ -611,7 +611,7 @@ def _check_msb(
 @qfunc(external=True)
 def _ctrl_x(
     ref: CInt,
-    ctrl: QArray[QBit],
+    ctrl: QNum,
     aux: QArray[QBit],
 ) -> None:
     pass
@@ -678,6 +678,52 @@ def modular_exp(
     pass
 
 
+@qfunc(external=True)
+def qsvt_step(
+    phase_seq: CArray[CReal],
+    index: CInt,
+    proj_cnot_1: QCallable[QArray[QBit], QArray[QBit]],
+    proj_cnot_2: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qsvt(
+    phase_seq: CArray[CReal],
+    proj_cnot_1: QCallable[QArray[QBit], QArray[QBit]],
+    proj_cnot_2: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def projector_controlled_phase(
+    phase: CReal,
+    proj_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qsvt_inversion(
+    phase_seq: CArray[CReal],
+    block_encoding_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def allocate_num(
     num_qubits: CInt,
@@ -883,6 +929,10 @@ __all__ = [
     "multiswap",
     "inplace_c_modular_multiply",
     "modular_exp",
+    "qsvt_step",
+    "qsvt",
+    "projector_controlled_phase",
+    "qsvt_inversion",
     "allocate_num",
     "qaoa_mixer_layer",
     "qaoa_cost_layer",

classiq/qmod/builtins/operations.py

@@ -1,12 +1,11 @@
 import inspect
 import sys
-import warnings
 from types import FrameType
 from typing import Any, Callable, Final, List, Mapping, Union, overload
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
-    REPEAT_OPERATOR,
+    REPEAT_OPERATOR_NAME,
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -26,6 +25,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq import Integer
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
@@ -91,27 +91,6 @@ def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
     operand: Union[QCallable, Callable[[], None]],
 ) -> None:
-    if isinstance(operand, (SymbolicExpr, QVar)) and isinstance(
-        control, (QCallable, Callable)
-    ):  # type:ignore[unreachable]
-        warnings.warn(  # type:ignore[unreachable]
-            "The `control` syntax has changed. Switch the `ctrl` and "
-            "`operand` arguments. The old syntax will not be supported in the future.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-        ctrl, operand = operand, ctrl
-    if isinstance(ctrl, QNum):
-        warnings.warn(
-            "The `control` semantics has changed. Applying `control` to "
-            "a `QNum` without comparing it to an integer will not be supported in the "
-            "future.\nTips:\n    1. Use a `bind` statement to cast `ctrl` into a "
-            "QArray.\n    2.`control(n, ...)` is equivalent to "
-            "`ctrl(n == 2 ** n.size - 1, ...)` if n>=0 or to `ctrl(n == -1, ...)` if "
-            "n<0.",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
     _validate_operand(operand)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -124,18 +103,6 @@ def control(
     )
 
 
-def quantum_if(
-    ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]
-) -> None:
-    warnings.warn(
-        "`quantum_if` is no longer supported, use `control` instead (with the "
-        "same arguments). `quantum_if` will be removed in a future release.",
-        category=DeprecationWarning,
-        stacklevel=2,
-    )
-    control(ctrl, operand)
-
-
 def inplace_add(
     value: QNum,
     target: QNum,
@@ -190,7 +157,10 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
     iteration_operand = prepare_arg(
-        REPEAT_OPERATOR.operand_declarations["iteration"], iteration
+        QuantumOperandDeclaration(
+            name=REPEAT_OPERATOR_NAME, param_decls={"index": Integer()}
+        ),
+        iteration,
     )
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Repeat(

classiq/qmod/declaration_inferrer.py

@@ -27,7 +27,7 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq import StructDeclaration
 from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CParam, CReal, QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CParam, CReal
 from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
@@ -87,18 +87,6 @@ def _add_qmod_struct(
     )
 
 
-def _extract_param_decl(
-    name: str, py_type: Any, *, qmodule: ModelStateContainer
-) -> ClassicalParameterDeclaration:
-    if get_origin(py_type) is QParam:
-        if len(get_args(py_type)) != 1:
-            raise ClassiqValueError("QParam takes exactly one generic argument")
-        py_type = get_args(py_type)[0]
-    return ClassicalParameterDeclaration(
-        name=name, classical_type=python_type_to_qmod(py_type, qmodule=qmodule)
-    )
-
-
 def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
     # FIXME: CAD-13409
     qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
@@ -139,9 +127,14 @@ def _extract_positional_args(
             and issubclass(py_type, CParam)
             or inspect.isclass(py_type)
             and issubclass(py_type, CStructBase)
-            or get_origin(py_type) in (QParam, CArray)
+            or get_origin(py_type) == CArray
         ):
-            result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
+            result.append(
+                ClassicalParameterDeclaration(
+                    name=name,
+                    classical_type=python_type_to_qmod(py_type, qmodule=qmodule),
+                )
+            )
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))
         else:

classiq/qmod/native/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from .pretty_printer import DSLPrettyPrinter
+
+__all__ = ["DSLPrettyPrinter"]
+
+
+def __dir__() -> List[str]:
+    return __all__

classiq/qmod/native/expression_to_qmod.py

@@ -1,12 +1,10 @@
 import ast
 import re
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Mapping, Type
+from typing import Callable, Dict, List, Mapping, Optional, Type
 
 import numpy as np
 
-from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
-
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
@@ -44,7 +42,7 @@ LIST_FORMAT_CHAR_LIMIT = 20
 @dataclass
 class ASTToQMODCode:
     level: int
-    decimal_precision: int
+    decimal_precision: Optional[int]
     indent_seq: str = "  "
 
     @property
@@ -59,13 +57,16 @@ class ASTToQMODCode:
             return self.indent.join(self.ast_to_code(child) for child in node.body)
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
-            if not isinstance(node.attr, str):
+            if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
+                raise AssertionError("Error parsing enum attribute access")
+            if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
                 raise AssertionError("Error parsing enum attribute access")
-            access_operator = "." if node.attr in CLASSICAL_ATTRIBUTES else "::"
-            return f"{self.ast_to_code(node.value)!s}{access_operator}{node.attr!s}"
+            return f"{node.value.id!s}::{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
+            if self.decimal_precision is None:
+                return str(node.n)
             return str(np.round(node.n, self.decimal_precision))
         elif isinstance(node, ast.Str):
             return repr(node.s)
@@ -123,7 +124,7 @@ class ASTToQMODCode:
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
-                        f"{keyword.arg} = {self._cleaned_ast_to_code(keyword.value)}"
+                        f"{keyword.arg}={self._cleaned_ast_to_code(keyword.value)}"
                         for keyword in keywords
                         if keyword.arg is not None
                     ]
@@ -183,7 +184,9 @@ def _remove_redundant_parentheses(expr: str) -> str:
 
 
 def transform_expression(
-    expr: str, level: int = 0, decimal_precision: int = DEFAULT_DECIMAL_PRECISION
+    expr: str,
+    level: int = 0,
+    decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
 ) -> str:
     return ASTToQMODCode(level=level, decimal_precision=decimal_precision).visit(
         ast.parse(expr)

classiq/qmod/native/pretty_printer.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
@@ -63,7 +63,9 @@ from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class DSLPrettyPrinter(Visitor):
-    def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
+    def __init__(
+        self, decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION
+    ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
 
@@ -136,8 +138,6 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_QuantumBitvector(self, qtype: QuantumBitvector) -> str:
         if qtype.length is not None:
-            if qtype.length.is_evaluated() and qtype.length.to_int_value() == 1:
-                return "qbit"
             return f"qbit[{self.visit(qtype.length)}]"
         return "qbit[]"
 

classiq/qmod/pretty_print/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from .pretty_printer import PythonPrettyPrinter
+
+__all__ = ["PythonPrettyPrinter"]
+
+
+def __dir__() -> List[str]:
+    return __all__

classiq/qmod/pretty_print/expression_to_python.py

@@ -0,0 +1,221 @@
+import ast
+import re
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Mapping, Type
+
+import numpy as np
+
+import classiq
+from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+
+IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
+BINARY_OPS: Mapping[Type[ast.operator], str] = {
+    ast.Add: "+",
+    ast.Sub: "-",
+    ast.Mult: "*",
+    ast.Div: "/",
+    ast.Mod: "%",
+    ast.Pow: "**",
+    ast.BitAnd: "&",
+    ast.BitOr: "|",
+    ast.BitXor: "^",
+    ast.LShift: "<<",
+    ast.RShift: ">>",
+}
+BOOL_OPS: Mapping[Type[ast.boolop], str] = {ast.And: "and", ast.Or: "or"}
+UNARY_OPS: Mapping[Type[ast.unaryop], str] = {
+    ast.UAdd: "+",
+    ast.USub: "-",
+    ast.Invert: "~",
+    ast.Not: "not",
+}
+COMPARE_OPS: Mapping[Type[ast.cmpop], str] = {
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+}
+LIST_FORMAT_CHAR_LIMIT = 20
+
+
+@dataclass
+class ASTToQMODCode(ast.NodeVisitor):
+    level: int
+    imports: Dict[str, int]
+    symbolic_imports: Dict[str, int]
+    decimal_precision: int
+    indent_seq: str = "    "
+
+    @property
+    def indent(self) -> str:
+        return self.level * self.indent_seq
+
+    def _handle_imports(self, name: str, is_possibly_symbolic: bool = False) -> None:
+        if name in dir(classiq):
+            self.imports[name] = 1
+        if is_possibly_symbolic and name in dir(classiq.qmod.symbolic):
+            self.symbolic_imports[name] = 1
+
+    def visit(self, node: ast.AST) -> str:
+        res = super().visit(node)
+        if not isinstance(res, str):
+            raise AssertionError("Error parsing expression: unsupported AST node.")
+        return res
+
+    def visit_Module(self, node: ast.Module) -> str:
+        return self.indent.join(self.visit(child) for child in node.body)
+
+    def visit_Attribute(self, node: ast.Attribute) -> str:
+        if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
+            raise AssertionError("Error parsing enum attribute access")
+        if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
+            raise AssertionError("Error parsing enum attribute access")
+        self._handle_imports(node.value.id)
+        return f"{node.value.id!s}.{node.attr!s}"
+
+    def visit_Name(self, node: ast.Name) -> str:
+        self._handle_imports(node.id, True)
+        return node.id
+
+    def visit_Num(self, node: ast.Num) -> str:
+        return str(np.round(node.n, self.decimal_precision))
+
+    def visit_Str(self, node: ast.Str) -> str:
+        return repr(node.s)
+
+    def visit_Constant(self, node: ast.Constant) -> str:
+        return repr(node.value)
+
+    def visit_BinOp(self, node: ast.BinOp) -> str:
+        return "({} {} {})".format(
+            self.visit(node.left),
+            BINARY_OPS[type(node.op)],
+            self.visit(node.right),
+        )
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> str:
+        unary_op = UNARY_OPS[type(node.op)]
+        space = " " if unary_op == "not" else ""
+        return f"({unary_op}{space}{self.visit(node.operand)})"
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> str:
+        return "({})".format(
+            (" " + BOOL_OPS[type(node.op)] + " ").join(
+                self.visit(value) for value in node.values
+            )
+        )
+
+    def visit_Compare(self, node: ast.Compare) -> str:
+        if len(node.ops) != 1 or len(node.comparators) != 1:
+            raise AssertionError("Error parsing comparison expression.")
+        return "({} {} {})".format(
+            self.visit(node.left),
+            COMPARE_OPS[type(node.ops[0])],
+            self.visit(node.comparators[0]),
+        )
+
+    def visit_List(self, node: ast.List) -> str:
+        elts = node.elts
+        elements = self.indent_items(lambda: [self.visit(element) for element in elts])
+        return f"[{elements}]"
+
+    def visit_Subscript(self, node: ast.Subscript) -> str:
+        return f"{self.visit(node.value)}[{_remove_redundant_parentheses(self.visit(node.slice))}]"
+
+    def visit_Slice(self, node: ast.Slice) -> str:
+        if node.lower is None or node.upper is None or node.step is not None:
+            raise AssertionError("Error parsing slice expression.")
+        return f"{self.visit(node.lower)}:{self.visit(node.upper)}"
+
+    def visit_Call(self, node: ast.Call) -> str:
+        func = self.visit(node.func)
+        self._handle_imports(func, True)
+        if func == "get_field":
+            if len(node.args) != 2:
+                raise AssertionError("Error parsing struct field access.")
+            field = str(self.visit(node.args[1])).replace("'", "")
+            if not IDENTIFIER.match(field):
+                raise AssertionError("Error parsing struct field access.")
+            return f"{self.visit(node.args[0])}.{field}"
+        elif func == "struct_literal":
+            if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
+                raise AssertionError("Error parsing struct literal.")
+            keywords = node.keywords
+            initializer_list = self.indent_items(
+                lambda: [
+                    f"{keyword.arg} = {self._cleaned_ast_to_code(keyword.value)}"
+                    for keyword in keywords
+                    if keyword.arg is not None
+                ]
+            )
+            return f"{self.visit(node.args[0])}({initializer_list})"
+        else:
+            return "{}({})".format(
+                func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)
+            )
+
+    def visit_Expr(self, node: ast.Expr) -> str:
+        return self._cleaned_ast_to_code(node.value)
+
+    def generic_visit(self, node: ast.AST) -> None:
+        raise AssertionError("Cannot parse node of type: " + type(node).__name__)
+
+    def indent_items(self, items: Callable[[], List[str]]) -> str:
+        should_indent = (
+            len("".join([i.strip() for i in items()])) >= LIST_FORMAT_CHAR_LIMIT
+        )
+        if should_indent:
+            self.level += 1
+            left_ws = "\n" + self.indent
+            inner_ws = ",\n" + self.indent
+        else:
+            left_ws = ""
+            inner_ws = ", "
+        items_ = items()
+        if should_indent:
+            self.level -= 1
+            right_ws = "\n" + self.indent
+        else:
+            right_ws = ""
+        return f"{left_ws}{inner_ws.join(items_)}{right_ws}"
+
+    def _cleaned_ast_to_code(self, node: ast.AST) -> str:
+        return _remove_redundant_parentheses(self.visit(node))
+
+
+def _remove_redundant_parentheses(expr: str) -> str:
+    if not (expr.startswith("(") and expr.endswith(")")):
+        return expr
+    parentheses_map: Dict[int, int] = dict()
+    stack: List[int] = []
+    for index, char in enumerate(expr):
+        if char == "(":
+            stack.append(index)
+        elif char == ")":
+            parentheses_map[stack.pop()] = index
+    index = 0
+    original_length = len(expr)
+    while (
+        index in parentheses_map
+        and parentheses_map[index] == original_length - index - 1
+    ):
+        expr = expr[1:-1]
+        index += 1
+    return expr
+
+
+def transform_expression(
+    expr: str,
+    imports: Dict[str, int],
+    symbolic_imports: Dict[str, int],
+    level: int = 0,
+    decimal_precision: int = DEFAULT_DECIMAL_PRECISION,
+) -> str:
+    return ASTToQMODCode(
+        level=level,
+        decimal_precision=decimal_precision,
+        imports=imports,
+        symbolic_imports=symbolic_imports,
+    ).visit(ast.parse(expr))