classiq 0.41.2__py3-none-any.whl → 0.42.1__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -7,6 +7,7 @@ from sympy import IndexedBase, Symbol
 from typing_extensions import Annotated
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
 from classiq.interface.generator.expressions.enums.ladder_operator import (
     LadderOperator as LadderOperatorEnum,
 )
@@ -39,6 +40,13 @@ class ClassicalType(HashableASTNode):
     class Config:
         extra = Extra.forbid
 
+    def __str__(self) -> str:
+        return str(type(self).__name__)
+
+
+class EnumType(ClassicalType):
+    pass
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -69,7 +77,7 @@ class Real(ClassicalType):
 
     @property
     def default_value(self) -> float:
-        return 0
+        return 0.0
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -122,7 +130,7 @@ class ClassicalList(ClassicalType):
         return CArray[self.element_type.qmod_type]  # type:ignore[name-defined]
 
 
-class Pauli(ClassicalType):
+class Pauli(EnumType):
     kind: Literal["pauli"]
 
     @property
@@ -187,6 +195,14 @@ class ClassicalArray(ClassicalType):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
+    @property
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CArray
+
+        return CArray[
+            self.element_type.qmod_type, self.size  # type:ignore[name-defined]
+        ]
+
 
 class OpaqueHandle(ClassicalType):
     @property
@@ -226,7 +242,7 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-class LadderOperator(ClassicalType):
+class LadderOperator(EnumType):
     kind: Literal["ladder_operator"]
 
     @property
@@ -263,6 +279,8 @@ ConcreteClassicalType = Annotated[
 ClassicalList.update_forward_refs()
 ClassicalArray.update_forward_refs()
 
+PythonClassicalTypes = (int, float, bool, list, CStructBase, ClassicalEnum)
+
 
 def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
     return {

classiq/interface/generator/generated_circuit_data.py

@@ -98,6 +98,8 @@ class FunctionDebugInfo(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction]
     children: List["FunctionDebugInfo"]
     relative_qubits: Tuple[int, ...]
+    absolute_qubits: Optional[Tuple[int, ...]]
+    is_basis_gate: Optional[bool]
 
     @property
     def registers(self) -> List[GeneratedRegister]:

classiq/interface/generator/model/model.py

@@ -16,6 +16,7 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.model.quantum_register import QReg, QRegGenericAlias
 from classiq.interface.generator.quantum_function_call import (
     SUFFIX_RANDOMIZER,
     SynthesisQuantumFunctionCall,
@@ -26,7 +27,6 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
-from classiq.interface.model.quantum_register import QReg, QRegGenericAlias
 
 from classiq import ForeignFunctionDefinition as SynthesisForeignFunctionDefinition
 from classiq.exceptions import ClassiqValueError

classiq/interface/{model → generator/model}/quantum_register.py

@@ -87,6 +87,9 @@ class QReg:
             raise ClassiqQRegError(f"Cannot create {size} new qubits")
         self._qubits = [Qubit() for _ in range(size)]
 
+    def __hash__(self) -> int:
+        return super.__hash__(self)
+
     @classmethod
     def _from_qubits(cls, qubits: List[Qubit]) -> "QReg":
         if (

classiq/interface/helpers/classproperty.py

@@ -0,0 +1,8 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+
+class classproperty(property):  # noqa: N801
+    def __get__(self, owner_self: Any, owner_cls: Optional[type] = None) -> Any:
+        if TYPE_CHECKING:
+            assert self.fget is not None
+        return self.fget(owner_cls)

classiq/interface/ide/visual_model.py

@@ -0,0 +1,68 @@
+from typing import Dict, List, Optional, Tuple
+
+import pydantic
+
+from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+from classiq._internals.enum_utils import StrEnum
+
+
+class OperationLevel(StrEnum):
+    USER_DEFINED = "USER_DEFINED"
+    ENGINE_GENERATED = "ENGINE_GENERATED"
+    BASIS_GATE = "BASIS_GATE"
+    UNKNOWN = "UNKNOWN"
+
+
+class OperationType(StrEnum):
+    REGULAR = "REGULAR"
+    VAR_INITIALIZATION = "VAR_INITIALIZATION"
+    BIND = "BIND"
+
+
+class OperationData(pydantic.BaseModel):
+    approximated_depth: Optional[int]
+    width: int
+    gate_count: Dict[str, int] = pydantic.Field(default_factory=dict)
+
+
+class ProgramData(pydantic.BaseModel):
+    hardware_data: SynthesisHardwareData
+
+
+class OperationParameter(pydantic.BaseModel):
+    label: str
+    value: Optional[float]
+
+
+class OperationLink(pydantic.BaseModel):
+    label: str
+    qubits: Tuple[int, ...]
+    type: str
+
+
+class OperationLinks(pydantic.BaseModel):
+    inputs: List[OperationLink]
+    outputs: List[OperationLink]
+
+
+class Operation(pydantic.BaseModel):
+    name: str
+    children: List["Operation"]
+    operation_data: Optional[OperationData]
+    operation_links: OperationLinks
+    control_qubits: Tuple[int, ...] = pydantic.Field(default_factory=tuple)
+    auxiliary_qubits: Tuple[int, ...]
+    target_qubits: Tuple[int, ...]
+    parameters: List[OperationParameter] = pydantic.Field(default_factory=list)
+    operation_level: OperationLevel
+    # This field is meant to identify unique operations, such as variable initialization
+    # These will be visualized differently. We don't identify them yet, though, so
+    # we always set this field to be REGULAR
+    operation_type: OperationType = pydantic.Field(default=OperationType.REGULAR)
+
+
+class ProgramVisualModel(VersionedModel):
+    main_operation: Operation
+    program_data: ProgramData

classiq/interface/model/control.py

@@ -1,5 +1,7 @@
 from typing import TYPE_CHECKING, Literal
 
+import pydantic
+
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
@@ -10,5 +12,13 @@ if TYPE_CHECKING:
 
 class Control(QuantumExpressionOperation):
     kind: Literal["Control"]
-
     body: "StatementBlock"
+
+    _ctrl_state: str = pydantic.PrivateAttr(default="")
+
+    @property
+    def ctrl_state(self) -> str:
+        return self._ctrl_state
+
+    def set_ctrl_state(self, ctrl_state: str) -> None:
+        self._ctrl_state = ctrl_state

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -22,9 +22,7 @@ MULTI_VARS_UNSUPPORTED_ERROR = (
     "Amplitude Loading with more than one input variable is unsupported."
 )
 
-VAR_DOMAIN_ILLEGAL = (
-    "Amplitude Loading input variable should be a fixed-point number between 0 and 1"
-)
+VAR_TYPE_ILLEGAL = "Amplitude Loading input variable should be a quantum numeric"
 
 
 class AmplitudeLoadingOperation(QuantumAssignmentOperation):
@@ -55,11 +53,8 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
         if len(var_types) != 1:
             raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
         var_type = list(var_types.values())[0]
-        if not (
-            isinstance(var_type, QuantumNumeric)
-            and var_type.fraction_digits_value == var_type.size_in_bits
-        ):
-            raise ClassiqValueError(VAR_DOMAIN_ILLEGAL)
+        if not isinstance(var_type, QuantumNumeric):
+            raise ClassiqValueError(VAR_TYPE_ILLEGAL)
         super().initialize_var_types(var_types, machine_precision)
 
     @classmethod

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -1,16 +1,9 @@
 import abc
-import ast
-from typing import Dict, List, Mapping, Optional, Set, Union
+from typing import Dict, List, Mapping, Optional, Union
 
 import pydantic
 
-from classiq.interface.generator.arith.arithmetic_expression_validator import (
-    DEFAULT_SUPPORTED_FUNC_NAMES,
-)
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.sympy_supported_expressions import (
-    SYMPY_SUPPORTED_EXPRESSIONS,
-)
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -21,28 +14,6 @@ from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.quantum_type import QuantumType
 
 
-class VarRefCollector(ast.NodeVisitor):
-    def __init__(self) -> None:
-        self.var_names: Set[str] = set()
-
-    def generic_visit(self, node: ast.AST) -> None:
-        if isinstance(node, ast.Name) and node.id not in set(
-            SYMPY_SUPPORTED_EXPRESSIONS
-        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
-            self.var_names.add(node.id)
-        super().generic_visit(node)
-
-
-class VarRefTransformer(ast.NodeTransformer):
-    def __init__(self, var_mapping: Dict[str, str]) -> None:
-        self.var_mapping = var_mapping
-
-    def visit_Name(self, node: ast.Name) -> ast.Name:
-        if node.id in self.var_mapping:
-            node.id = self.var_mapping[node.id]
-        return node
-
-
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
     _var_handles: List[HandleBinding] = pydantic.PrivateAttr(

classiq/interface/model/quantum_function_call.py

@@ -12,7 +12,6 @@ from classiq.interface.generator.functions.function_declaration import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.call_synthesis_data import CallSynthesisData
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
@@ -143,10 +142,6 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
-    _synthesis_data: CallSynthesisData = pydantic.PrivateAttr(
-        default_factory=CallSynthesisData
-    )
-
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         if self._func_decl is None:
@@ -282,13 +277,6 @@ class QuantumFunctionCall(QuantumOperation):
                 if isinstance(qlambda, QuantumLambdaFunction):
                     qlambda.set_op_decl(op_decl)
 
-    @property
-    def synthesis_data(self) -> CallSynthesisData:
-        return self._synthesis_data
-
-    def merge_synthesis_data(self, other: CallSynthesisData) -> None:
-        self._synthesis_data = self._synthesis_data.merge(other)
-
     @pydantic.root_validator()
     def validate_handles(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         inputs = values.get("inputs", dict())

classiq/interface/model/validations/handles_validator.py

@@ -62,13 +62,8 @@ class HandleValidator(HandleValidationBase):
         elif isinstance(op, WithinApply):
             self._handle_apply(op.action)
 
-        if isinstance(op, QuantumFunctionCall) and op.synthesis_data.is_inverse:
-            self._handle_inputs(op.wiring_outputs)
-            self._handle_outputs(op.wiring_inputs)
-        else:
-            self._handle_inputs(op.wiring_inputs)
-            self._handle_outputs(op.wiring_outputs)
-
+        self._handle_inputs(op.wiring_inputs)
+        self._handle_outputs(op.wiring_outputs)
         self._handle_inouts(op.wiring_inouts)
 
     def handle_variable_declaration(

classiq/interface/server/routes.py

@@ -37,6 +37,7 @@ IDE_QASM_TASK = f"{TASKS_SUFFIX}/generated_circuit_from_qasm"
 IDE_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_QASM_TASK}"
 TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
 TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
+TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 MODEL_GENERATE_PREFIX = "/generate_model"
 CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"

classiq/qmod/builtins/classical_execution_primitives.py

@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.exceptions import ClassiqError
 
-ExecutionParams = Dict[str, Union[float, int]]
+ExecutionParams = Dict[str, Union[float, int, List[int], List[float]]]
 
 _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'

classiq/qmod/builtins/functions.py

@@ -474,13 +474,6 @@ def exponentiation_with_depth_constraint(
     pass
 
 
-@qfunc(external=True)
-def qft_step(
-    target: QArray[QBit],
-) -> None:
-    pass
-
-
 @qfunc(external=True)
 def qft(
     target: QArray[QBit],
@@ -538,7 +531,7 @@ def amplitude_estimation(
 
 @qfunc(external=True)
 def phase_oracle(
-    predicate: QCallable[QArray[QBit], QArray[QBit]],
+    predicate: QCallable[QArray[QBit], QBit],
     target: QArray[QBit],
 ) -> None:
     pass
@@ -603,7 +596,7 @@ def qft_no_swap(
 def _check_msb(
     ref: CInt,
     x: QArray[QBit],
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -612,7 +605,7 @@ def _check_msb(
 def _ctrl_x(
     ref: CInt,
     ctrl: QNum,
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -630,9 +623,9 @@ def cc_modular_add(
     n: CInt,
     a: CInt,
     phi_b: QArray[QBit],
-    c1: QArray[QBit],
-    c2: QArray[QBit],
-    aux: QArray[QBit],
+    c1: QBit,
+    c2: QBit,
+    aux: QBit,
 ) -> None:
     pass
 
@@ -643,8 +636,8 @@ def c_modular_multiply(
     a: CInt,
     b: QArray[QBit],
     x: QArray[QBit],
-    ctrl: QArray[QBit],
-    aux: QArray[QBit],
+    ctrl: QBit,
+    aux: QBit,
 ) -> None:
     pass
 
@@ -662,8 +655,8 @@ def inplace_c_modular_multiply(
     n: CInt,
     a: CInt,
     x: QArray[QBit],
-    ctrl: QArray[QBit],
-    aux: QArray[QBit],
+    ctrl: QBit,
+    aux: QBit,
 ) -> None:
     pass
 
@@ -680,13 +673,13 @@ def modular_exp(
 
 @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]],
+    phase1: CReal,
+    phase2: CReal,
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
     u: QCallable[QArray[QBit]],
     qvar: QArray[QBit],
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -694,11 +687,11 @@ def qsvt_step(
 @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]],
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
     u: QCallable[QArray[QBit]],
     qvar: QArray[QBit],
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -706,9 +699,9 @@ def qsvt(
 @qfunc(external=True)
 def projector_controlled_phase(
     phase: CReal,
-    proj_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    proj_cnot: QCallable[QArray[QBit], QBit],
     qvar: QArray[QBit],
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -716,10 +709,10 @@ def projector_controlled_phase(
 @qfunc(external=True)
 def qsvt_inversion(
     phase_seq: CArray[CReal],
-    block_encoding_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    block_encoding_cnot: QCallable[QArray[QBit], QBit],
     u: QCallable[QArray[QBit]],
     qvar: QArray[QBit],
-    aux: QArray[QBit],
+    aux: QBit,
 ) -> None:
     pass
 
@@ -796,7 +789,7 @@ def full_hea(
 def swap_test(
     state1: QArray[QBit],
     state2: QArray[QBit],
-    test: Output[QArray[QBit]],
+    test: Output[QBit],
 ) -> None:
     pass
 
@@ -849,6 +842,59 @@ def switch(
     pass
 
 
+@qfunc(external=True)
+def _qct_d_operator(
+    x: QNum,
+    q: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def _qct_pi_operator(
+    x: QArray[QBit],
+    q: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qct_qst_type1(
+    x: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qct_qst_type2(
+    x: QArray[QBit],
+    q: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qct_type2(
+    x: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qst_type2(
+    x: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def modular_increment(
+    a: CInt,
+    x: QArray[QBit],
+) -> None:
+    pass
+
+
 __all__ = [
     "permute",
     "apply",
@@ -906,7 +952,6 @@ __all__ = [
     "suzuki_trotter",
     "qdrift",
     "exponentiation_with_depth_constraint",
-    "qft_step",
     "qft",
     "qpe_flexible",
     "qpe",
@@ -947,4 +992,11 @@ __all__ = [
     "inplace_prepare_int",
     "prepare_int",
     "switch",
+    "_qct_d_operator",
+    "_qct_pi_operator",
+    "qct_qst_type1",
+    "qct_qst_type2",
+    "qct_type2",
+    "qst_type2",
+    "modular_increment",
 ]

classiq/qmod/builtins/operations.py

@@ -161,7 +161,12 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
             name=REPEAT_OPERATOR_NAME, param_decls={"index": Integer()}
         ),
         iteration,
+        repeat.__name__,
     )
+    if not isinstance(iteration_operand, QuantumLambdaFunction):
+        raise ClassiqValueError(
+            "`repeat`'s `iteration` argument must be a lambda function"
+        )
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Repeat(
             iter_var=inspect.getfullargspec(iteration).args[0],
@@ -251,7 +256,17 @@ def _get_operand_hint(
 
 
 def _operand_to_body(callable_: Union[QCallable, Callable[[], None]]) -> StatementBlock:
-    to_operand = prepare_arg(QuantumOperandDeclaration(name=""), callable_)
+    op_name = sys._getframe(1).f_code.co_name
+    if (
+        isinstance(callable_, QCallable)
+        and len(callable_.func_decl.positional_arg_declarations) > 0
+    ):
+        raise ClassiqValueError(
+            f"Operand argument {callable_.func_decl.name!r} to {op_name!r} should "
+            f"receive 0 parameters, not "
+            f"{len(callable_.func_decl.positional_arg_declarations)}"
+        )
+    to_operand = prepare_arg(QuantumOperandDeclaration(name=""), callable_, op_name)
     if isinstance(to_operand, str):
         return [QuantumFunctionCall(function=to_operand)]
     elif isinstance(to_operand, QuantumLambdaFunction):

classiq/qmod/declaration_inferrer.py

@@ -1,9 +1,23 @@
 import dataclasses
 import inspect
-from typing import Any, Callable, Dict, List, Optional, Type, get_args, get_origin
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Type,
+    get_args,
+    get_origin,
+)
 
 from typing_extensions import _AnnotatedAlias
 
+from classiq.interface.generator.expressions.enums.ladder_operator import (
+    LadderOperator as LadderOperatorEnum,
+)
+from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEnum
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
@@ -11,6 +25,8 @@ from classiq.interface.generator.functions.classical_type import (
     ConcreteClassicalType,
     CStructBase,
     Integer,
+    LadderOperator as LadderOperatorType,
+    Pauli as PauliType,
     Real,
     Struct,
 )
@@ -33,6 +49,10 @@ from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 OPERAND_ARG_NAME = "arg{i}"
+ENUM_TYPE_MAPPING: Mapping[type, type] = {
+    PauliEnum: PauliType,
+    LadderOperatorEnum: LadderOperatorType,
+}
 
 
 def python_type_to_qmod(
@@ -44,6 +64,8 @@ def python_type_to_qmod(
         return Real()
     elif py_type == bool or py_type is CBool:
         return Bool()
+    elif py_type in ENUM_TYPE_MAPPING:
+        return ENUM_TYPE_MAPPING[py_type]()
     elif get_origin(py_type) == list:
         return ClassicalList(
             element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
@@ -124,9 +146,11 @@ def _extract_positional_args(
         name = unmangle_keyword(name)
         if (
             inspect.isclass(py_type)
-            and issubclass(py_type, CParam)
-            or inspect.isclass(py_type)
-            and issubclass(py_type, CStructBase)
+            and (
+                issubclass(py_type, CParam)
+                or issubclass(py_type, CStructBase)
+                or py_type in ENUM_TYPE_MAPPING
+            )
             or get_origin(py_type) == CArray
         ):
             result.append(