classiq 0.71.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

classiq/model_expansions/transformers/model_renamer.py

@@ -36,72 +36,78 @@ class HandleRenaming:
 SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 
 
-class ModelRenamer:
-    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
-        if len(symbol_mapping) == 0:
-            return subject
-        handle_replacements = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
+def _rewrite_expression(
+    symbol_mapping: SymbolRenaming, expression: Expression
+) -> Expression:
+    vrc = VarRefCollector(
+        ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+    )
+    vrc.visit(ast.parse(expression.expr))
+
+    handle_names = {
+        part.source_handle: part.target_var_handle
+        for parts in symbol_mapping.values()
+        for part in parts
+    }
+    new_expr_str = expression.expr
+    for handle in vrc.var_handles:
+        new_handle = handle.collapse()
+        for handle_to_replace, replacement in handle_names.items():
+            new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+        new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
+        if handle.qmod_expr != str(handle):
+            new_expr_str = _replace_full_word(
+                str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
+            )
+
+    new_expr = Expression(expr=new_expr_str)
+    new_expr._evaluated_expr = expression._evaluated_expr
+    return new_expr
 
-        class ReplaceSplitVars(ModelTransformer):
-            @staticmethod
-            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
-                handle = handle.collapse()
-                for handle_to_replace, replacement in handle_replacements.items():
-                    handle = handle.replace_prefix(handle_to_replace, replacement)
-                return handle
-
-            @staticmethod
-            def visit_Expression(expr: Expression) -> Expression:
-                return self._rewrite_expression(symbol_mapping, expr)
-
-            def visit_QuantumExpressionOperation(
-                self, op: QuantumExpressionOperation
-            ) -> QuantumExpressionOperation:
-                op = cast(QuantumExpressionOperation, self.generic_visit(op))
-                previous_var_handles = list(op._var_handles)
-                op._var_handles = self.visit(op._var_handles)
-                op._var_types = {
-                    new_handle.name: op._var_types.get(
-                        new_handle.name, op._var_types[previous_handle.name]
-                    )
-                    for previous_handle, new_handle in zip(
-                        previous_var_handles, op._var_handles
-                    )
-                }
-                return op
-
-        return ReplaceSplitVars().visit(subject)
-
-    def _rewrite_expression(
-        self,
-        symbol_mapping: SymbolRenaming,
-        expression: Expression,
-    ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
-        vrc.visit(ast.parse(expression.expr))
-
-        handle_names = {
+
+class _ReplaceSplitVarsHandles(ModelTransformer):
+    def __init__(self, symbol_mapping: SymbolRenaming) -> None:
+        self._handle_replacements = {
             part.source_handle: part.target_var_handle
             for parts in symbol_mapping.values()
             for part in parts
         }
-        new_expr_str = expression.expr
-        for handle in vrc.var_handles:
-            new_handle = handle.collapse()
-            for handle_to_replace, replacement in handle_names.items():
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = _replace_full_word(
-                str(handle), str(new_handle), new_expr_str
+
+    def visit_HandleBinding(self, handle: HandleBinding) -> HandleBinding:
+        handle = handle.collapse()
+        for handle_to_replace, replacement in self._handle_replacements.items():
+            handle = handle.replace_prefix(handle_to_replace, replacement)
+        return handle
+
+
+class _ReplaceSplitVarsExpressions(ModelTransformer):
+    def __init__(self, symbol_mapping: SymbolRenaming) -> None:
+        self._symbol_mapping = symbol_mapping
+
+    def visit_Expression(self, expr: Expression) -> Expression:
+        return _rewrite_expression(self._symbol_mapping, expr)
+
+    def visit_QuantumExpressionOperation(
+        self, op: QuantumExpressionOperation
+    ) -> QuantumExpressionOperation:
+        op = cast(QuantumExpressionOperation, self.generic_visit(op))
+        previous_var_handles = list(op._var_handles)
+        op._var_handles = self.visit(op._var_handles)
+        op._var_types = {
+            new_handle.name: op._var_types.get(
+                new_handle.name, op._var_types[previous_handle.name]
             )
-            if handle.qmod_expr != str(handle):
-                new_expr_str = _replace_full_word(
-                    str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
-                )
-
-        new_expr = Expression(expr=new_expr_str)
-        new_expr._evaluated_expr = expression._evaluated_expr
-        return new_expr
+            for previous_handle, new_handle in zip(
+                previous_var_handles, op._var_handles
+            )
+        }
+        return op
+
+
+class ModelRenamer:
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
+        subject = _ReplaceSplitVarsHandles(symbol_mapping).visit(subject)
+        subject = _ReplaceSplitVarsExpressions(symbol_mapping).visit(subject)
+        return subject

classiq/model_expansions/utils/sympy_utils.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from sympy import Number
+
+
+def unwrap_sympy_numeric(n: Any) -> Any:
+    if not isinstance(n, Number) or not n.is_constant():
+        return n
+    if n.is_Integer:
+        return int(n)
+    return float(n)
+
+
+def is_constant_subscript(index: Any) -> bool:
+    if not isinstance(index, slice):
+        return isinstance(unwrap_sympy_numeric(index), int)
+    start = unwrap_sympy_numeric(index.start)
+    stop = unwrap_sympy_numeric(index.stop)
+    step = unwrap_sympy_numeric(index.step)
+    return (
+        (start is None or isinstance(start, int))
+        and (stop is None or isinstance(stop, int))
+        and (step is None or isinstance(step, int))
+    )

classiq/model_expansions/visitors/variable_references.py

@@ -58,6 +58,7 @@ class VarRefCollector(ast.NodeVisitor):
     def visit_Subscript(
         self, node: ast.Subscript
     ) -> Union[SubscriptHandleBinding, SlicedHandleBinding, None]:
+        self.visit(node.slice)
         with self.set_nested():
             base_handle = self.visit(node.value)
         if base_handle is None:

classiq/qmod/builtins/functions/__init__.py

@@ -50,7 +50,9 @@ CORE_LIB_DECLS = [
         SWAP,
         IDENTITY,
         prepare_state,
+        prepare_state_approx,
         prepare_amplitudes,
+        prepare_amplitudes_approx,
         unitary,
         add,
         modular_add,
@@ -62,7 +64,9 @@ CORE_LIB_DECLS = [
         free,
         randomized_benchmarking,
         inplace_prepare_state,
+        inplace_prepare_state_approx,
         inplace_prepare_amplitudes,
+        inplace_prepare_amplitudes_approx,
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
@@ -114,7 +118,9 @@ __all__ = [  # noqa: RUF022
     "free",
     "gaussian_finance",
     "inplace_prepare_amplitudes",
+    "inplace_prepare_amplitudes_approx",
     "inplace_prepare_state",
+    "inplace_prepare_state_approx",
     "integer_xor",
     "log_normal_finance",
     "modular_add",
@@ -125,7 +131,9 @@ __all__ = [  # noqa: RUF022
     "pauli_feature_map",
     "permute",
     "prepare_amplitudes",
+    "prepare_amplitudes_approx",
     "prepare_state",
+    "prepare_state_approx",
     "qdrift",
     "randomized_benchmarking",
     "real_xor_constant",

classiq/qmod/builtins/functions/allocation.py

@@ -123,3 +123,39 @@ def inplace_prepare_amplitudes(
 
     """
     pass
+
+
+@qfunc(external=True)
+def inplace_prepare_amplitudes_approx(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_amplitudes_approx(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_state_approx(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def prepare_state_approx(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+) -> None:
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,7 +1,7 @@
 from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_parameter import CArray, CBool, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 
 
@@ -24,13 +24,18 @@ def unitary(
 
 @qfunc(external=True)
 def add(
-    left: QArray[QBit],
-    right: QArray[QBit],
+    left: QNum,
+    right: QNum,
     result: Output[
-        QArray[
-            QBit, Literal["Max(get_field(left, 'len'), get_field(right, 'len')) + 1"]
+        QNum[
+            Literal["result_size"],
+            Literal["result_is_signed"],
+            Literal["result_fraction_places"],
         ]
     ],
+    result_size: CReal,
+    result_is_signed: CBool,
+    result_fraction_places: CReal,
 ) -> None:
     pass
 

classiq/qmod/builtins/functions/mid_circuit_measurement.py

@@ -11,5 +11,8 @@ def RESET(target: QBit) -> None:
 
     Args:
         target: the qubit to reset
+
+    Notes:
+        We approximate the depth of a single RESET gate to 1000 X gates.
     """
     pass

classiq/qmod/builtins/operations.py

@@ -142,13 +142,13 @@ def if_(
     if_stmt = ClassicalIf(
         condition=Expression(expr=str(condition)),
         then=_operand_to_body(then, "then"),
-        else_=_operand_to_body(else_, "else") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+        else_=_operand_to_body(else_, "else_") if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
         source_ref=source_ref,
     )
     if is_generative_mode():
         if_stmt.set_generative_block("then", then)
         if callable(else_):
-            if_stmt.set_generative_block("else", else_)
+            if_stmt.set_generative_block("else_", else_)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 

classiq/qmod/model_state_container.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import TYPE_CHECKING
 
 from classiq.interface.generator.constant import Constant
@@ -25,3 +26,11 @@ class ModelStateContainer:
 
 
 QMODULE = ModelStateContainer()
+QMODULE.enum_decls = {}
+QMODULE.type_decls = {}
+QMODULE.qstruct_decls = {}
+QMODULE.native_defs = {}
+QMODULE.constants = {}
+QMODULE.functions_compilation_metadata = {}
+QMODULE.generative_functions = {}
+QMODULE.function_dependencies = defaultdict(list)

classiq/qmod/symbolic.py

@@ -20,7 +20,6 @@ from classiq.qmod.qmod_parameter import (
     CReal,
     create_param,
 )
-from classiq.qmod.qmod_variable import QNum
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
@@ -296,11 +295,25 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
+def _subscript_to_str(index: Any) -> str:
+    if not isinstance(index, slice):
+        return str(index)
+    expr = ""
+    if index.start is not None:
+        expr += str(index.start)
+    expr += ":"
+    if index.stop is not None:
+        expr += str(index.stop)
+    if index.step is not None:
+        expr += f":{index.step}"
+    return expr
+
+
 def subscript(
     amplitudes: Union[Sequence[Union[float, CReal, CParamScalar]], CArray[CReal]],
-    index: QNum,
+    index: Any,
 ) -> CParamScalar:
-    return CParamScalar(expr=f"{amplitudes}[{index}]")
+    return CParamScalar(expr=f"{amplitudes}[{_subscript_to_str(index)}]")
 
 
 __all__ = [

{classiq-0.71.0.dist-info → classiq-0.72.0.dist-info}/METADATA

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