classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/qmod/quantum_function.py

@@ -1,5 +1,6 @@
 import ast
 import functools
+import inspect
 import warnings
 from abc import abstractmethod
 from collections.abc import Callable
@@ -8,7 +9,11 @@ from enum import EnumMeta
 from inspect import isclass
 from typing import Any, get_origin
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqError,
+    ClassiqExpansionError,
+)
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -276,10 +281,16 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
-        if (
-            self._py_callable.__name__ == "suzuki_trotter"
-            and len(args) > 0
-            and isinstance(args[0], (list, CParamList))
+        if self._py_callable.__name__ == "suzuki_trotter" and (
+            (
+                "pauli_operator" not in kwargs
+                and len(args) > 0
+                and isinstance(args[0], (list, CParamList))
+            )
+            or (
+                "pauli_operator" in kwargs
+                and isinstance(kwargs["pauli_operator"], (list, CParamList))
+            )
         ):
             warnings.warn(
                 (
@@ -320,6 +331,19 @@ class ExternalQFunc(QTerminalCallable):
                 ClassiqDeprecationWarning,
                 stacklevel=2,
             )
+        if (
+            self._py_callable.__name__ == "unscheduled_suzuki_trotter"
+        ):  # FIXME: remove (CLS-5391)
+            warnings.warn(
+                (
+                    "Function 'unscheduled_suzuki_trotter' was renamed to "
+                    "'sequential_suzuki_trotter'. 'unscheduled_suzuki_trotter' is "
+                    "deprecated and will no longer be supported starting on 2026-02-02 "
+                    "at the earliest."
+                ),
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
         super().__call__(*args, **kwargs)
 
 
@@ -348,14 +372,26 @@ class GenerativeQFunc(BaseQFunc):
         return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
+        from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
+
         if get_global_declarative_switch():
             return QFunc(
                 self._py_callable,
                 self.compilation_metadata,
                 permutation=self.permutation,
             )(*args, **kwargs)
-        if self.func_decl.name not in self._qmodule.generative_functions:
-            self._qmodule.generative_functions[self.func_decl.name] = self
+        frame = inspect.currentframe()
+        caller_frame = frame.f_back if frame is not None else None
+        module = inspect.getmodule(caller_frame)
+        func_name = self.func_decl.name
+        if func_name in BUILTIN_FUNCTION_DECLARATIONS and (
+            module is None or not module.__name__.startswith("model.function_library")
+        ):
+            raise ClassiqExpansionError(
+                f"Cannot redefine built-in function {func_name!r}"
+            )
+        if func_name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[func_name] = self
             if self._func_decl is None:
                 self._inferred_func_decl = infer_func_decl(
                     self._py_callable, self._qmodule, permutation=self.permutation

classiq/qmod/semantics/validation/function_name_collisions_validation.py

@@ -1,13 +1,16 @@
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
-from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 
-
-def check_function_name_collisions(model: Model) -> None:
+def check_function_name_collisions(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     redefined_functions = [
         function.name
-        for function in CORE_LIB_DECLS
+        for function in builtin_functions
         if function.name in model.function_dict
     ]
     if len(redefined_functions) == 1:

classiq/qmod/semantics/validation/model_validation.py

@@ -1,4 +1,7 @@
 from classiq.interface.model.model import Model
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 
 from classiq.qmod.semantics.validation.constants_validation import (
     check_duplicate_constants,
@@ -14,7 +17,9 @@ from classiq.qmod.semantics.validation.types_validation import (
 )
 
 
-def validate_model(model: Model) -> None:
+def validate_model(
+    model: Model, builtin_functions: list[NamedParamsQuantumFunctionDeclaration]
+) -> None:
     check_duplicate_types([*model.enums, *model.types, *model.qstructs])
     check_duplicate_constants(model.constants)
     for qstruct in model.qstructs:
@@ -22,4 +27,4 @@ def validate_model(model: Model) -> None:
     for cstruct in model.types:
         validate_cstruct(cstruct)
     validate_main_function(model.main_func)
-    check_function_name_collisions(model)
+    check_function_name_collisions(model, builtin_functions)

classiq/qmod/symbolic_type.py

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

classiq/qprog_to_cudaq.py

@@ -0,0 +1,347 @@
+import importlib.util
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.helpers.text_utils import readable_list
+
+if TYPE_CHECKING:
+    import cudaq
+    import openqasm3
+
+_CONVERSION_ERROR_PREFIX = "Cannot convert quantum program to cudaq: "
+
+
+def _require_cudaq() -> None:
+    missing = [m for m in ("cudaq", "openqasm3") if importlib.util.find_spec(m) is None]
+    if missing:
+        raise ClassiqError(
+            "This feature needs the 'cudaq' extra. "
+            "Install with: pip install classiq[cudaq] "
+            f"(missing: {', '.join(missing)}).\n"
+            f"Note: cudaq is only supported on Linux operating systems "
+            f"https://nvidia.github.io/cuda-quantum/latest/using/quick_start.html\n"
+            f"If you are using a different operating system, consider running on the "
+            f"Classiq Studio https://docs.classiq.io/latest/user-guide/studio/Studio-Guide/ "
+            f"or a Linux Docker container"
+        )
+
+
+def _get_qasm_ast(quantum_program: QuantumProgram) -> "openqasm3.ast.Program":
+    import openqasm3
+
+    if quantum_program.qasm is None:
+        raise ClassiqError(_CONVERSION_ERROR_PREFIX + "missing QASM output format")
+    try:
+        return openqasm3.parser.parse(quantum_program.qasm)
+    except Exception as e:
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX + "the provided QASM is not supported"
+        ) from e
+
+
+def _get_main_kernel(
+    qasm_ast: "openqasm3.ast.Program",
+) -> tuple["cudaq.PyKernel", dict[str, "cudaq.QuakeValue"]]:
+    import cudaq
+    import openqasm3
+
+    classical_inputs: list[str] = []
+    for statement in qasm_ast.statements:
+        if isinstance(statement, openqasm3.ast.IODeclaration):
+            if statement.io_identifier != openqasm3.ast.IOKeyword.input:
+                raise ClassiqError(
+                    _CONVERSION_ERROR_PREFIX + "classical outputs are not supported"
+                )
+            if not isinstance(statement.type, openqasm3.ast.FloatType):
+                raise ClassiqError(
+                    _CONVERSION_ERROR_PREFIX
+                    + "only float classical inputs are supported"
+                )
+            classical_inputs.append(statement.identifier.name)
+
+    if len(classical_inputs) == 0:
+        return cudaq.make_kernel(), {}
+    kernel_and_params = cudaq.make_kernel(*((float,) * len(classical_inputs)))
+    kernel = kernel_and_params[0]
+    params = dict(zip(classical_inputs, kernel_and_params[1:], strict=True))
+    return kernel, params
+
+
+def qprog_to_cudaq_kernel(quantum_program: QuantumProgram) -> "cudaq.PyKernel":
+    _require_cudaq()
+
+    qasm_ast = _get_qasm_ast(quantum_program)
+    kernel, params = _get_main_kernel(qasm_ast)
+    gates: dict[str, "cudaq.PyKernel"] = {}
+    qubits: dict[str, "cudaq.QuakeValue"] = {}
+
+    for statement in qasm_ast.statements:
+        _process_main_statement(kernel, gates, qubits, params, statement)
+    return kernel
+
+
+def _process_main_statement(
+    kernel: "cudaq.PyKernel",
+    gates: dict[str, "cudaq.PyKernel"],
+    qubits: dict[str, "cudaq.QuakeValue"],
+    params: dict[str, "cudaq.QuakeValue"],
+    statement: "openqasm3.ast.Statement | openqasm3.ast.Pragma",
+) -> None:
+    import cudaq
+    import openqasm3
+
+    if isinstance(statement, (openqasm3.ast.Include, openqasm3.ast.IODeclaration)):
+        pass
+    elif isinstance(
+        statement,
+        (
+            openqasm3.ast.ClassicalDeclaration,
+            openqasm3.ast.BranchingStatement,
+            openqasm3.ast.QuantumMeasurementStatement,
+        ),
+    ):
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX + "mid-circuit measurements are not supported"
+        )
+    elif isinstance(statement, openqasm3.ast.QuantumReset):
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX + "reset instructions are not supported"
+        )
+    elif isinstance(statement, openqasm3.ast.QubitDeclaration):
+        if statement.size is None:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX
+                + f"qubit declaration {statement.qubit.name!r} has no size"
+            )
+        if not isinstance(statement.size, openqasm3.ast.IntegerLiteral):
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX
+                + f"the size of qubit declaration {statement.qubit.name!r} must be an integer literal"
+            )
+        qubits[statement.qubit.name] = kernel.qalloc(statement.size.value)
+    elif isinstance(statement, openqasm3.ast.QuantumGateDefinition):
+        angle_names = [param.name for param in statement.arguments]
+        qubit_names = [param.name for param in statement.qubits]
+        kernel_and_params = cudaq.make_kernel(
+            *((float,) * len(angle_names)), *((cudaq.qubit,) * len(qubit_names))
+        )
+        func_kernel = kernel_and_params[0]
+        func_params = dict(
+            zip(angle_names, kernel_and_params[1 : len(angle_names) + 1], strict=True)
+        )
+        func_qubits = dict(
+            zip(qubit_names, kernel_and_params[len(angle_names) + 1 :], strict=True)
+        )
+        for gate_statement in statement.body:
+            _process_statement(
+                func_kernel, gates, func_qubits, func_params, gate_statement
+            )
+        gates[statement.name.name] = func_kernel
+    else:
+        _process_statement(kernel, gates, qubits, params, statement)
+
+
+def _eval_expr(
+    params: dict[str, "cudaq.QuakeValue"], expr: "openqasm3.ast.Expression"
+) -> Any:
+    import openqasm3
+
+    if isinstance(expr, openqasm3.ast.Identifier):
+        if expr.name not in params:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + f"name {expr.name!r} is not defined"
+            )
+        return params[expr.name]
+    if isinstance(expr, openqasm3.ast.UnaryExpression):
+        target = _eval_expr(params, expr.expression)
+        if expr.op == openqasm3.ast.UnaryOperator["~"]:
+            return ~target
+        if expr.op == openqasm3.ast.UnaryOperator["-"]:
+            return -target
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX + f"operation {str(expr.op)!r} is not supported"
+        )
+    if isinstance(expr, openqasm3.ast.BinaryExpression):
+        left = _eval_expr(params, expr.lhs)
+        right = _eval_expr(params, expr.rhs)
+        if expr.op == openqasm3.ast.BinaryOperator["|"]:
+            return left | right
+        if expr.op == openqasm3.ast.BinaryOperator["&"]:
+            return left & right
+        if expr.op == openqasm3.ast.BinaryOperator["<<"]:
+            return left << right
+        if expr.op == openqasm3.ast.BinaryOperator[">>"]:
+            return left >> right
+        if expr.op == openqasm3.ast.BinaryOperator["+"]:
+            return left + right
+        if expr.op == openqasm3.ast.BinaryOperator["-"]:
+            return left - right
+        if expr.op == openqasm3.ast.BinaryOperator["*"]:
+            return left * right
+        if expr.op == openqasm3.ast.BinaryOperator["/"]:
+            return left / right
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX + f"operation {str(expr.op)!r} is not supported"
+        )
+    if isinstance(
+        expr,
+        (
+            openqasm3.ast.IntegerLiteral,
+            openqasm3.ast.FloatLiteral,
+            openqasm3.ast.ImaginaryLiteral,
+            openqasm3.ast.BooleanLiteral,
+        ),
+    ):
+        return expr.value
+    raise ClassiqError(
+        _CONVERSION_ERROR_PREFIX
+        + f"expression type {type(expr).__name__!r} is not supported"
+    )
+
+
+def _eval_var(
+    qubits: dict[str, "cudaq.QuakeValue"],
+    expr: "openqasm3.ast.IndexedIdentifier | openqasm3.ast.Identifier",
+) -> "cudaq.QuakeValue":
+    import openqasm3
+
+    if isinstance(expr, openqasm3.ast.Identifier):
+        if expr.name not in qubits:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + f"name {expr.name!r} is not defined"
+            )
+        return qubits[expr.name]
+    if isinstance(expr, openqasm3.ast.IndexedIdentifier):
+        if expr.name.name not in qubits:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + f"name {expr.name.name!r} is not defined"
+            )
+        if (
+            len(expr.indices) != 1
+            or not isinstance(accessor := expr.indices[0], list)
+            or len(accessor) != 1
+            or not isinstance(index := accessor[0], openqasm3.ast.IntegerLiteral)
+        ):
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX
+                + "only simple subscript expressions are supported (for example, q[0])"
+            )
+        return qubits[expr.name.name][index.value]
+    raise ClassiqError(
+        _CONVERSION_ERROR_PREFIX
+        + f"expression type {type(expr).__name__!r} is not supported"
+    )
+
+
+def _get_expr_vars(
+    params: dict[str, "cudaq.QuakeValue"], expr: "openqasm3.ast.Expression"
+) -> set[str]:
+    import openqasm3
+
+    if isinstance(expr, openqasm3.ast.Identifier):
+        if expr.name not in params:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + f"name {expr.name!r} is not defined"
+            )
+        return {expr.name}
+    if isinstance(expr, openqasm3.ast.UnaryExpression):
+        return _get_expr_vars(params, expr.expression)
+    if isinstance(expr, openqasm3.ast.BinaryExpression):
+        return _get_expr_vars(params, expr.lhs) | _get_expr_vars(params, expr.rhs)
+    if isinstance(
+        expr,
+        (
+            openqasm3.ast.IntegerLiteral,
+            openqasm3.ast.FloatLiteral,
+            openqasm3.ast.ImaginaryLiteral,
+            openqasm3.ast.BooleanLiteral,
+        ),
+    ):
+        return set()
+    raise ClassiqError(
+        _CONVERSION_ERROR_PREFIX
+        + f"expression type {type(expr).__name__!r} is not supported"
+    )
+
+
+def _eval_single_var(
+    params: dict[str, "cudaq.QuakeValue"], expr: "openqasm3.ast.Expression"
+) -> "cudaq.QuakeValue":
+    expr_vars = _get_expr_vars(params, expr)
+    if len(expr_vars) != 1:
+        if len(expr_vars) == 0:
+            suffix = "got none"
+        else:
+            suffix = f"got {readable_list(list(expr_vars), quote=True)}"
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX
+            + f"gate argument must contain exactly one angle variable, {suffix}"
+        )
+    return params[list(expr_vars)[0]]
+
+
+def _process_statement(
+    kernel: "cudaq.PyKernel",
+    gates: dict[str, "cudaq.PyKernel"],
+    qubits: dict[str, "cudaq.QuakeValue"],
+    params: dict[str, "cudaq.QuakeValue"],
+    statement: "openqasm3.ast.Statement | openqasm3.ast.Pragma",
+) -> None:
+    import openqasm3
+
+    if isinstance(statement, openqasm3.ast.QuantumGate):
+        if len(statement.modifiers) != 0:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + "gate modifiers are not supported"
+            )
+        if statement.duration:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + "gate duration is not supported"
+            )
+        qubit_args = [_eval_var(qubits, var) for var in statement.qubits]
+        gate_name = statement.name.name
+        if gate_name in gates:
+            angle_args = [
+                _eval_single_var(params, angle_expr)
+                for angle_expr in statement.arguments
+            ]
+            kernel.apply_call(gates[gate_name], *angle_args, *qubit_args)
+        elif gate_name in {"i", "id"}:
+            pass
+        elif gate_name in {
+            "x",
+            "y",
+            "z",
+            "h",
+            "s",
+            "t",
+            "sdg",
+            "tdg",
+            "rx",
+            "ry",
+            "rz",
+            "u3",
+            "cx",
+            "cy",
+            "cz",
+            "ch",
+            "cs",
+            "ct",
+            "crx",
+            "cry",
+            "crz",
+        }:
+            angle_args = [
+                _eval_expr(params, angle_expr) for angle_expr in statement.arguments
+            ]
+            getattr(kernel, gate_name)(*angle_args, *qubit_args)
+        else:
+            raise ClassiqError(
+                _CONVERSION_ERROR_PREFIX + f"gate {gate_name!r} is not defined"
+            )
+    else:
+        raise ClassiqError(
+            _CONVERSION_ERROR_PREFIX
+            + f"QASM statement {type(statement).__name__} is not supported"
+        )

{classiq-0.102.0.dist-info → classiq-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classiq
-Version: 0.102.0
+Version: 1.0.0
 Summary: Classiq's Python SDK for quantum computing
 Keywords: quantum computing,quantum circuits,quantum algorithms,QAD,QDL
 Author: Classiq Technologies
@@ -50,6 +50,8 @@ Requires-Dist: notebook>=7.2.2,<8 ; extra == 'analyzer-sdk'
 Requires-Dist: openfermion==1.6.1 ; python_full_version < '3.10' and extra == 'chemistry'
 Requires-Dist: openfermion==1.7.1 ; python_full_version >= '3.10' and extra == 'chemistry'
 Requires-Dist: openfermionpyscf>=0.5 ; extra == 'chemistry'
+Requires-Dist: cudaq>=0.12.0,<1 ; sys_platform == 'linux' and extra == 'cudaq'
+Requires-Dist: openqasm3[parser]>=1.0.1,<2 ; extra == 'cudaq'
 Requires-Dist: torch~=2.3 ; extra == 'qml'
 Requires-Dist: torchvision>=0.18,<1.0 ; extra == 'qml'
 Requires-Dist: cvxpy>=1.7.1,<2 ; extra == 'qsp'
@@ -60,6 +62,7 @@ Project-URL: examples, https://github.com/Classiq/classiq-library
 Project-URL: homepage, https://classiq.io
 Provides-Extra: analyzer-sdk
 Provides-Extra: chemistry
+Provides-Extra: cudaq
 Provides-Extra: qml
 Provides-Extra: qsp
 Description-Content-Type: text/markdown