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

classiq/interface/generator/functions/classical_type.py

@@ -14,6 +14,10 @@ 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": len,
+}
+
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
@@ -29,9 +33,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 +57,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 +78,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 +96,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 +118,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 +136,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 +152,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 +169,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 +240,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/model/control.py

@@ -1,16 +1,112 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Optional
 
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
+import pydantic
+from sympy import Equality
+from sympy.core.numbers import Integer
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+    QmodSizedProxy,
+)
+from classiq.interface.model.quantum_expressions.control_state import (
+    min_bit_length,
+    to_twos_complement,
 )
-from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.exceptions import ClassiqValueError
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
+CONTROL_INOUT_NAME = "ctrl"
+CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT = (
+    "control condition must be of the form '<quantum-variable> == "
+    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
+)
+
 
-class Control(QuantumOperation):
-    control: Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+class Control(QuantumExpressionOperation):
     body: "StatementBlock"
+    _ctrl: Optional[QmodSizedProxy] = pydantic.PrivateAttr(
+        default=None,
+    )
+    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
+        default=None,
+    )
+
+    @property
+    def condition(self) -> Expression:
+        return self.expression
+
+    @property
+    def ctrl(self) -> QmodSizedProxy:
+        assert self._ctrl is not None
+        return self._ctrl
+
+    @property
+    def ctrl_val(self) -> int:
+        assert self._ctrl_val is not None
+        return self._ctrl_val
+
+    def resolve_condition(self) -> None:
+        condition = self.condition.value.value
+        if isinstance(condition, QmodSizedProxy):
+            self._resolve_port_condition(condition)
+        elif isinstance(condition, Equality):
+            self._resolve_num_condition(condition)
+        else:
+            raise ClassiqValueError(
+                f"control condition must be a qubit, an array of qubits, or a quantum "
+                f"numeric equality, was {str(condition)!r}"
+            )
+
+    def _resolve_port_condition(self, condition: QmodSizedProxy) -> None:
+        self._ctrl = condition
+
+    def _resolve_num_condition(self, condition: Equality) -> None:
+        ctrl, ctrl_val = condition.args
+        if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
+            ctrl, ctrl_val = ctrl_val, ctrl
+        if not isinstance(ctrl, QmodQNumProxy):
+            raise ClassiqValueError(
+                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
+            )
+        if not isinstance(ctrl_val, Integer):
+            raise ClassiqValueError(
+                CONTROL_CTRL_ARG_ERROR_MESSAGE_FORMAT.format("right", str(ctrl_val))
+            )
+        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
+
+    @property
+    def has_ctrl_state(self) -> bool:
+        assert self._ctrl is not None
+        return self._ctrl_val is not None
+
+    @property
+    def ctrl_state(self) -> str:
+        ctrl = self.ctrl
+        assert isinstance(ctrl, QmodQNumProxy)
+        is_signed = ctrl.is_signed
+        fraction_places = ctrl.fraction_digits
+        ctrl_size = len(ctrl)
+        if not is_signed and self.ctrl_val < 0:
+            raise ClassiqValueError(
+                f"Variable {str(ctrl)!r} is not signed but control value "
+                f"{self.ctrl_val} is negative"
+            )
+        required_qubits = min_bit_length(self.ctrl_val, is_signed)
+        if ctrl_size < required_qubits:
+            raise ClassiqValueError(
+                f"Variable {str(ctrl)!r} has {ctrl_size} qubits but control value "
+                f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
+            )
+        if fraction_places != 0:
+            raise ClassiqValueError(
+                f"Comparison (`==`) on a non-integer quantum variable {str(ctrl)!r} is "
+                f"not supported at the moment"
+            )
+        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

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/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)

classiq/interface/model/statement_block.py

@@ -13,7 +13,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_if_operation import QuantumIf
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
@@ -28,19 +27,17 @@ ConcreteQuantumStatement = Union[
     VariableDeclarationStatement,
     BindOperation,
     InplaceBinaryOperation,
-    Control,
     Repeat,
     Power,
     Invert,
     ClassicalIf,
-    QuantumIf,
+    Control,
     WithinApply,
 ]
 
 StatementBlock = List[ConcreteQuantumStatement]
 
 Control.update_forward_refs(StatementBlock=StatementBlock)
-QuantumIf.update_forward_refs(StatementBlock=StatementBlock)
 QuantumLambdaFunction.update_forward_refs(StatementBlock=StatementBlock)
 Repeat.update_forward_refs(StatementBlock=StatementBlock)
 Power.update_forward_refs(StatementBlock=StatementBlock)

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, QParam
+from .qmod_parameter import Array, CArray, CBool, CInt, CReal, QParam
 from .qmod_struct import struct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
 from .quantum_callable import QCallable, QCallableList
@@ -13,8 +13,11 @@ from .quantum_function import create_model
 from .write_qmod import write_qmod
 
 __all__ = [
-    "QParam",
     "Array",
+    "CArray",
+    "CBool",
+    "CInt",
+    "CReal",
     "Input",
     "Output",
     "QArray",
@@ -23,6 +26,7 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
+    "QParam",
     "struct",
     "qfunc",
     "cfunc",

classiq/qmod/builtins/classical_functions.py

@@ -1,69 +1,64 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
-
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
 
 
 def qft_const_adder_phase(
-    bit_index: QParam[int],
-    value: QParam[int],
-    reg_len: QParam[int],
-) -> QParam[float]:
-    return symbolic_function(bit_index, value, reg_len, return_type=QParam[float])
+    bit_index: CInt,
+    value: CInt,
+    reg_len: CInt,
+) -> CReal:
+    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
 
 
 def molecule_problem_to_hamiltonian(
-    problem: QParam[MoleculeProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+    problem: MoleculeProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
-    problem: QParam[FockHamiltonianProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem, return_type=QParam[List[PauliTerm]])
+    problem: FockHamiltonianProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def grid_entangler_graph(
-    num_qubits: QParam[int],
-    schmidt_rank: QParam[int],
-    grid_randomization: QParam[bool],
-) -> QParam[List[List[int]]]:
+    num_qubits: CInt,
+    schmidt_rank: CInt,
+    grid_randomization: CBool,
+) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits,
-        schmidt_rank,
-        grid_randomization,
-        return_type=QParam[List[List[int]]],
+        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
     )
 
 
 def hypercube_entangler_graph(
-    num_qubits: QParam[int],
-) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits, return_type=QParam[List[List[int]]])
+    num_qubits: CInt,
+) -> CArray[CArray[CInt]]:
+    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
 
 
 def log_normal_finance_post_process(
-    finance_model: QParam[LogNormalModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+    finance_model: LogNormalModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )
 
 
 def gaussian_finance_post_process(
-    finance_model: QParam[GaussianModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
+    finance_model: GaussianModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=QParam[float]
+        finance_model, estimation_method, probability, return_type=CReal
     )