classiq 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -14,6 +14,8 @@ from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEn
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
+
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
@@ -29,9 +31,9 @@ class ClassicalType(HashableASTNode):
         )
 
     @property
-    def python_type(self) -> type:
+    def qmod_type(self) -> type:
         raise NotImplementedError(
-            f"{self.__class__.__name__!r} has no Python SDK equivalent"
+            f"{self.__class__.__name__!r} has no QMOD SDK equivalent"
         )
 
     class Config:
@@ -53,8 +55,10 @@ class Integer(ClassicalType):
         return values_with_discriminator(values, "kind", "int")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CInt
+
+        return CInt
 
 
 class Real(ClassicalType):
@@ -72,8 +76,10 @@ class Real(ClassicalType):
         return values_with_discriminator(values, "kind", "real")
 
     @property
-    def python_type(self) -> type:
-        return float
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CReal
+
+        return CReal
 
 
 class Bool(ClassicalType):
@@ -88,8 +94,10 @@ class Bool(ClassicalType):
         return values_with_discriminator(values, "kind", "bool")
 
     @property
-    def python_type(self) -> type:
-        return bool
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CBool
+
+        return CBool
 
 
 class ClassicalList(ClassicalType):
@@ -108,8 +116,10 @@ class ClassicalList(ClassicalType):
         return values_with_discriminator(values, "kind", "list")
 
     @property
-    def python_type(self) -> type:
-        return List[self.element_type.python_type]  # type:ignore[name-defined]
+    def qmod_type(self) -> type:
+        from classiq.qmod.qmod_parameter import CArray
+
+        return CArray[self.element_type.qmod_type]  # type:ignore[name-defined]
 
 
 class Pauli(ClassicalType):
@@ -124,8 +134,8 @@ class Pauli(ClassicalType):
         return values_with_discriminator(values, "kind", "pauli")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        return PauliEnum
 
 
 class StructMetaType(ClassicalType):
@@ -140,7 +150,7 @@ class StructMetaType(ClassicalType):
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class QStructBase:  # marker for Qmod structs in the Python SDK
+class CStructBase:  # marker for Qmod structs in the Python SDK
     pass
 
 
@@ -157,8 +167,8 @@ class Struct(ClassicalType):
         return values_with_discriminator(values, "kind", "struct_instance")
 
     @property
-    def python_type(self) -> type:
-        return type(self.name, (QStructBase,), dict())
+    def qmod_type(self) -> type:
+        return type(self.name, (CStructBase,), dict())
 
 
 class ClassicalArray(ClassicalType):
@@ -228,8 +238,8 @@ class LadderOperator(ClassicalType):
         return values_with_discriminator(values, "kind", "ladder_operator")
 
     @property
-    def python_type(self) -> type:
-        return int
+    def qmod_type(self) -> type:
+        return LadderOperatorEnum
 
 
 ConcreteClassicalType = Annotated[

classiq/interface/generator/model/preferences/preferences.py

@@ -11,7 +11,9 @@ from classiq.interface.backend.quantum_backend_providers import (
     AllBackendsNameByVendor,
     ProviderVendor,
 )
-from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
 from classiq.interface.generator.hardware.hardware_data import (
     BACKEND_VALIDATION_ERROR_MESSAGE,
     CustomHardwareSettings,
@@ -78,7 +80,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
     _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
         default=None
     )
-    machine_precision: PydanticMachinePrecision = MAXIMAL_MACHINE_PRECISION
+    machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
     backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
         pydantic.Field(

classiq/interface/generator/synthesis_metadata/synthesis_duration.py

@@ -1,10 +1,7 @@
-from typing import Optional
-
 import pydantic
 
 
 class SynthesisStepDurations(pydantic.BaseModel):
-    model_preprocessing: Optional[float] = None
     preprocessing: float
     solving: float
     conversion_to_circuit: float
@@ -14,7 +11,6 @@ class SynthesisStepDurations(pydantic.BaseModel):
         return sum(
             time if time is not None else 0
             for time in (
-                self.model_preprocessing,
                 self.preprocessing,
                 self.solving,
                 self.conversion_to_circuit,

classiq/interface/model/bind_operation.py

@@ -1,4 +1,4 @@
-from typing import List, Mapping
+from typing import List, Literal, Mapping
 
 import pydantic
 
@@ -12,6 +12,8 @@ BIND_OUTPUT_NAME = "bind_output"
 
 
 class BindOperation(QuantumOperation):
+    kind: Literal["BindOperation"]
+
     in_handles: List[HandleBinding]
     out_handles: List[HandleBinding]
 

classiq/interface/model/call_synthesis_data.py

@@ -36,24 +36,13 @@ class CallSynthesisData(Mapping):
             should_control=self.should_control and other.should_control,
         )
 
-    def set_control(self, ctrl_name: str, ctrl_size: int) -> None:
+    def set_control(self, ctrl_name: str, ctrl_size: int, ctrl_state: str) -> None:
         self.control_states = [
             ControlState(
-                name=ctrl_name,
-                num_ctrl_qubits=ctrl_size,
+                name=ctrl_name, num_ctrl_qubits=ctrl_size, ctrl_state=ctrl_state
             )
         ]
 
-    def update_control_state(self, ctrl_size: int, ctrl_state: str) -> None:
-        prev_ctrl_state = self.control_states.pop()
-        self.control_states.append(
-            ControlState(
-                name=prev_ctrl_state.name,
-                num_ctrl_qubits=ctrl_size,
-                ctrl_state=ctrl_state,
-            )
-        )
-
     @property
     def has_control(self) -> bool:
         return bool(self.control_states)

classiq/interface/model/classical_if.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,6 +8,8 @@ if TYPE_CHECKING:
 
 
 class ClassicalIf(QuantumOperation):
+    kind: Literal["ClassicalIf"]
+
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"

classiq/interface/model/classical_parameter_declaration.py

@@ -1,7 +1,20 @@
+from typing import Any, Dict, Literal
+
+import pydantic
+
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 
 class ClassicalParameterDeclaration(ASTNode):
+    kind: Literal["ClassicalParameterDeclaration"]
+
     name: str
     classical_type: ConcreteClassicalType
+
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(
+            values, "kind", "ClassicalParameterDeclaration"
+        )

classiq/interface/model/control.py

@@ -1,16 +1,14 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
 )
-from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
-class Control(QuantumOperation):
-    control: Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+class Control(QuantumExpressionOperation):
+    kind: Literal["Control"]
+
     body: "StatementBlock"

classiq/interface/model/inplace_binary_operation.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from typing import Literal, Mapping
 
 import pydantic
 
@@ -23,6 +23,8 @@ class BinaryOperation(StrEnum):
 
 
 class InplaceBinaryOperation(QuantumOperation):
+    kind: Literal["InplaceBinaryOperation"]
+
     target: HandleBinding
     value: HandleBinding
     operation: BinaryOperation

classiq/interface/model/invert.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -7,4 +7,6 @@ if TYPE_CHECKING:
 
 
 class Invert(QuantumOperation):
+    kind: Literal["Invert"]
+
     body: "StatementBlock"

classiq/interface/model/port_declaration.py

@@ -1,10 +1,11 @@
-from typing import Any, Mapping
+from typing import Any, Dict, Literal, Mapping
 
 import pydantic
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
 )
@@ -13,8 +14,14 @@ from classiq.exceptions import ClassiqValueError
 
 
 class PortDeclaration(QuantumVariableDeclaration):
+    kind: Literal["PortDeclaration"]
+
     direction: PortDeclarationDirection
 
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", "PortDeclaration")
+
     @pydantic.validator("direction")
     def _direction_validator(
         cls, direction: PortDeclarationDirection, values: Mapping[str, Any]

classiq/interface/model/power.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,5 +8,7 @@ if TYPE_CHECKING:
 
 
 class Power(QuantumOperation):
+    kind: Literal["Power"]
+
     power: Expression
     body: "StatementBlock"

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Mapping, Union
+from typing import Dict, Literal, Mapping, Union
 
 import pydantic
 
@@ -28,6 +28,8 @@ VAR_DOMAIN_ILLEGAL = (
 
 
 class AmplitudeLoadingOperation(QuantumAssignmentOperation):
+    kind: Literal["AmplitudeLoadingOperation"]
+
     _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
 
     @property
@@ -52,7 +54,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     ) -> None:
         if len(var_types) != 1:
             raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
-        var_type = var_types[self.var_handles[0].name]
+        var_type = list(var_types.values())[0]
         if not (
             isinstance(var_type, QuantumNumeric)
             and var_type.fraction_digits_value == var_type.size_in_bits

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Mapping, Union
+from typing import Dict, Literal, Mapping, Union
 
 import pydantic
 
@@ -18,6 +18,8 @@ from classiq.interface.model.quantum_type import QuantumType
 
 
 class ArithmeticOperation(QuantumAssignmentOperation):
+    kind: Literal["ArithmeticOperation"]
+
     inplace_result: bool = pydantic.Field(
         description="Determines whether the result variable is initialized",
     )

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -33,6 +33,16 @@ class VarRefCollector(ast.NodeVisitor):
         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(
@@ -58,7 +68,7 @@ class QuantumExpressionOperation(QuantumOperation):
         var_types: Dict[str, QuantumType],
         machine_precision: int,
     ) -> None:
-        assert len(var_types) == len(self.var_handles)
+        assert len(var_types) == len(self.var_handles) or len(self.var_handles) == 0
         self._var_types = var_types
 
     @property

classiq/interface/model/quantum_function_call.py

@@ -1,6 +1,6 @@
 import itertools
 import re
-from typing import Any, Dict, List, Mapping, Optional, Set, Type, Union
+from typing import Any, Dict, List, Literal, Mapping, Optional, Set, Type, Union
 
 import pydantic
 
@@ -23,7 +23,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
-    LambdaListComprehension,
     QuantumCallable,
     QuantumLambdaFunction,
     QuantumOperand,
@@ -114,6 +113,8 @@ class OperandIdentifier(ASTNode):
 
 
 class QuantumFunctionCall(QuantumOperation):
+    kind: Literal["QuantumFunctionCall"]
+
     function: Union[str, OperandIdentifier] = pydantic.Field(
         description="The function that is called"
     )
@@ -304,10 +305,7 @@ class QuantumFunctionCall(QuantumOperation):
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
     if isinstance(operand, list):
         return operand
-    elif isinstance(operand, LambdaListComprehension):
-        return [operand.func]
-    else:
-        return [operand]
+    return [operand]
 
 
 def _check_ports_against_declaration(
@@ -368,10 +366,6 @@ def _check_operand_against_declaration(
         if operand_argument.func_decl is None:
             return
         operand_arg_decl = operand_argument.func_decl
-    elif isinstance(operand_argument, LambdaListComprehension):
-        if operand_argument.func.func_decl is None:
-            return
-        operand_arg_decl = operand_argument.func.func_decl
     else:
         raise ClassiqValueError(
             f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "

classiq/interface/model/quantum_function_declaration.py

@@ -1,6 +1,18 @@
-from typing import Any, ClassVar, Dict, List, Mapping, Sequence, Set, Type, Union
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Sequence,
+    Set,
+    Type,
+    Union,
+)
 
 import pydantic
+from typing_extensions import Annotated
 
 from classiq.interface.generator.function_params import ArithmeticIODict, PortDirection
 from classiq.interface.generator.functions.function_declaration import (
@@ -9,7 +21,10 @@ from classiq.interface.generator.functions.function_declaration import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.helpers.pydantic_model_helpers import Nameable
+from classiq.interface.helpers.pydantic_model_helpers import (
+    Nameable,
+    values_with_discriminator,
+)
 from classiq.interface.helpers.validation_helpers import (
     validate_nameables_mapping,
     validate_nameables_no_overlap,
@@ -49,8 +64,9 @@ def _populate_declaration_dicts_with_positional_lists(
         )
 
 
-PositionalArg = Union[
-    ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration
+PositionalArg = Annotated[
+    Union[ClassicalParameterDeclaration, "QuantumOperandDeclaration", PortDeclaration],
+    pydantic.Field(..., discriminator="kind"),
 ]
 
 
@@ -218,10 +234,16 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
 
 
 class QuantumOperandDeclaration(QuantumFunctionDeclaration):
+    kind: Literal["QuantumOperandDeclaration"]
+
     is_list: bool = pydantic.Field(
         description="Indicate whether the operand expects an unnamed list of lambdas",
         default=False,
     )
 
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", "QuantumOperandDeclaration")
+
 
 QuantumFunctionDeclaration.update_forward_refs()

classiq/interface/model/quantum_lambda_function.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Dict, List, Optional, Union
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
@@ -36,23 +35,5 @@ class QuantumLambdaFunction(ASTNode):
         self._func_decl = fd
 
 
-class LambdaListComprehension(ASTNode):
-    """
-    Specification of a list of lambda functions iteratively
-    """
-
-    count: Expression = pydantic.Field(
-        description="The number of lambda functions in the list"
-    )
-
-    index_var: str = pydantic.Field(
-        description="The name of the integer variable holding the iteration index"
-    )
-
-    func: QuantumLambdaFunction = pydantic.Field(
-        description="A lambda function definition replicated for index values 0 to count-1"
-    )
-
-
 QuantumCallable = Union[str, QuantumLambdaFunction]
-QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
+QuantumOperand = Union[QuantumCallable, List[QuantumCallable]]

classiq/interface/model/quantum_statement.py

@@ -1,8 +1,9 @@
-from typing import Mapping, Union
+from typing import Any, Dict, Mapping, Union
 
-from pydantic import Extra
+from pydantic import Extra, root_validator
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
@@ -11,9 +12,15 @@ from classiq.interface.model.handle_binding import (
 
 
 class QuantumStatement(ASTNode):
+    kind: str
+
     class Config:
         extra = Extra.forbid
 
+    @root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", cls.__name__)  # type: ignore[attr-defined]
+
 
 class QuantumOperation(QuantumStatement):
     @property

classiq/interface/model/quantum_type.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
@@ -65,12 +66,9 @@ class QuantumBit(QuantumScalar):
         return values_with_discriminator(values, "kind", "qbit")
 
 
-class QuantumArray(QuantumType):
-    length: Optional[Expression]
-
-
-class QuantumBitvector(QuantumArray):
+class QuantumBitvector(QuantumType):
     kind: Literal["qvec"]
+    length: Optional[Expression]
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -80,6 +78,9 @@ class QuantumBitvector(QuantumArray):
         if self.length is not None and self.length.is_evaluated():
             self._size_in_bits = self.length.to_int_value()
 
+    def get_proxy(self, name: str) -> QmodQArrayProxy:
+        return QmodQArrayProxy(name, self.size_in_bits)
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]

classiq/interface/model/repeat.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
@@ -8,6 +8,8 @@ if TYPE_CHECKING:
 
 
 class Repeat(QuantumOperation):
+    kind: Literal["Repeat"]
+
     iter_var: str
     count: Expression
     body: "StatementBlock"

classiq/interface/model/resolvers/function_call_resolver.py

@@ -9,7 +9,6 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIf
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.within_apply_operation import WithinApply
 
@@ -33,10 +32,6 @@ class FunctionCallResolver(Visitor):
         for fc in control.body:
             self.visit(fc)
 
-    def visit_QuantumIf(self, quantum_if: QuantumIf) -> None:
-        for fc in quantum_if.then:
-            self.visit(fc)
-
     def visit_WithinApply(self, within_apply: WithinApply) -> None:
         for fc in itertools.chain(within_apply.compute, within_apply.action):
             self.visit(fc)