classiq 0.36.1__py3-none-any.whl → 0.37.1__py3-none-any.whl

classiq/interface/model/quantum_if_operation.py

@@ -0,0 +1,95 @@
+from typing import TYPE_CHECKING, Optional
+
+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_qnum_proxy import QmodQNumProxy
+from classiq.interface.model.quantum_expressions.control_state import (
+    min_bit_length,
+    to_twos_complement,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.exceptions import ClassiqValueError
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_function_call import QuantumOperand
+
+
+QUANTUM_IF_INOUT_NAME = "ctrl"
+QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
+    "quantum_if condition must be of the form '<quantum-variable> == "
+    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
+)
+
+
+class QuantumIfOperation(QuantumExpressionOperation):
+    then: "QuantumOperand"
+    _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
+        default=None,
+    )
+    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
+        default=None,
+    )
+
+    @property
+    def condition(self) -> Expression:
+        return self.expression
+
+    @property
+    def ctrl(self) -> QmodQNumProxy:
+        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 not isinstance(condition, Equality):
+            raise ClassiqValueError(
+                f"quantum_if condition must be an equality, was {str(condition)!r}"
+            )
+        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(
+                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
+            )
+        if not isinstance(ctrl_val, Integer):
+            raise ClassiqValueError(
+                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format(
+                    "right", str(ctrl_val)
+                )
+            )
+        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
+
+    @property
+    def ctrl_state(self) -> str:
+        is_signed = self.ctrl.is_signed
+        fraction_places = self.ctrl.fraction_digits
+        ctrl_size = len(self.ctrl)
+        if not is_signed and self.ctrl_val < 0:
+            raise ClassiqValueError(
+                f"Variable {str(self.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(self.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"quantum-if on a non-integer quantum variable {str(self.ctrl)!r} is "
+                f"not supported at the moment"
+            )
+        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

classiq/interface/model/validations/handles_validator.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterable, Mapping, Set, Union
+from typing import Dict, Mapping, Set, Union
 
 from classiq.interface.generator.function_params import PortDirection
 from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
@@ -10,7 +10,6 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.local_variable_declaration import LocalVariableDeclaration
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import (
     QuantumFunctionCall,
@@ -30,20 +29,16 @@ from classiq.exceptions import ClassiqValueError
 
 def _initialize_handles_to_state(
     port_declarations: Mapping[str, PortDeclaration],
-    local_handles: Iterable[LocalVariableDeclaration],
 ) -> Dict[str, ValidationHandle]:
     handles_to_state: Dict[str, ValidationHandle] = dict()
 
     for port_decl in port_declarations.values():
         handles_to_state[port_decl.name] = ValidationHandle(
-            initial_state=HandleState.INITIALIZED
-            if port_decl.direction.includes_port_direction(PortDirection.Input)
-            else HandleState.UNINITIALIZED
-        )
-
-    for local_handle in local_handles:
-        handles_to_state[local_handle.name] = ValidationHandle(
-            initial_state=HandleState.UNINITIALIZED
+            initial_state=(
+                HandleState.INITIALIZED
+                if port_decl.direction.includes_port_direction(PortDirection.Input)
+                else HandleState.UNINITIALIZED
+            )
         )
 
     return handles_to_state
@@ -53,13 +48,10 @@ class HandleValidator(HandleValidationBase):
     def __init__(
         self,
         port_declarations: Mapping[str, PortDeclaration],
-        local_handles: Iterable[LocalVariableDeclaration],
     ) -> None:
         super().__init__(port_declarations)
         self._port_declarations = port_declarations.values()
-        self._handles_to_state = _initialize_handles_to_state(
-            port_declarations, local_handles
-        )
+        self._handles_to_state = _initialize_handles_to_state(port_declarations)
 
     @property
     def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:

classiq/interface/server/routes.py

@@ -4,9 +4,8 @@ LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
 CONVERSION_PREFIX = "/conversion"
 
-SYNTHESIS_SERVICE_PREFIX = "/synthesis/v1"
-
-EXECUTION_SERVICE_PREFIX = "/execution/v1"
+EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
+SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
 
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
@@ -51,10 +50,11 @@ TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
 TASK_RB_SUFFIX = TASKS_SUFFIX + RB
 TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
 
-
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
-EXECUTION_SERVICE_JOBS_FULL_PATH = EXECUTION_SERVICE_PREFIX + EXECUTION_JOBS_SUFFIX
+EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
+    EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
+)
 EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
 EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
@@ -62,8 +62,12 @@ ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 
+TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
+
 GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = SYNTHESIS_SERVICE_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
+GENERATE_HAMILTONIAN_FULL_PATH = (
+    SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
+)
 
 FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
 

classiq/model/function_handler.pyi

@@ -45,108 +45,108 @@ class FunctionHandler(abc.ABC, metaclass=abc.ABCMeta):
     def include_library(self, library: FunctionLibrary) -> None: ...
     @abc.abstractmethod
     def create_library(self) -> None: ...
-    def HypercubeEntangler(self, params: HypercubeEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def WStatePreparation(self, params: WStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Adder(self, params: Adder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def C3XGate(self, params: C3XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Exponentiation(self, params: Exponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RGate(self, params: RGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ExponentialStatePreparation(self, params: ExponentialStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RXXGate(self, params: RXXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def BellStatePreparation(self, params: BellStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UGate(self, params: UGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CYGate(self, params: CYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CZGate(self, params: CZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Equal(self, params: Equal, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Multiplier(self, params: Multiplier, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Modulo(self, params: Modulo, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Arithmetic(self, params: Arithmetic, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RShift(self, params: RShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Exponentiation(self, params: Exponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Mcu(self, params: Mcu, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PhaseEstimation(self, params: PhaseEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def CustomOracle(self, params: CustomOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def QFT(self, params: QFT, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseOr(self, params: BitwiseOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRYGate(self, params: CRYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Identity(self, params: Identity, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def AmplitudeLoading(self, params: AmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UCC(self, params: UCC, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRXGate(self, params: CRXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def LinearGCI(self, params: LinearGCI, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GroverDiffuser(self, params: GroverDiffuser, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RXGate(self, params: RXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CyclicShift(self, params: CyclicShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GHZStatePreparation(self, params: GHZStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RandomizedBenchmarking(self, params: RandomizedBenchmarking, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UnitaryGate(self, params: UnitaryGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HVA(self, params: HVA, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def TwoDimensionalEntangler(self, params: TwoDimensionalEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Mcu(self, params: Mcu, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CHGate(self, params: CHGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CSXGate(self, params: CSXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GreaterEqual(self, params: GreaterEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LessThan(self, params: LessThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Sign(self, params: Sign, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Negation(self, params: Negation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def WeightedAdder(self, params: WeightedAdder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def NotEqual(self, params: NotEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RangeMixer(self, params: RangeMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Modulo(self, params: Modulo, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RZGate(self, params: RZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HartreeFock(self, params: HartreeFock, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def StatePropagator(self, params: StatePropagator, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LessEqual(self, params: LessEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RShift(self, params: RShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LogicalAnd(self, params: LogicalAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GridEntangler(self, params: GridEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Mcx(self, params: Mcx, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def YGate(self, params: YGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Subtractor(self, params: Subtractor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CyclicShift(self, params: CyclicShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def ZGate(self, params: ZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GHZStatePreparation(self, params: GHZStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def HGate(self, params: HGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def IGate(self, params: IGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SGate(self, params: SGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SdgGate(self, params: SdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ComputationalBasisStatePreparation(self, params: ComputationalBasisStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HadamardTransform(self, params: HadamardTransform, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HardwareEfficientAnsatz(self, params: HardwareEfficientAnsatz, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def FinancePayoff(self, params: FinancePayoff, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SXGate(self, params: SXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RYYGate(self, params: RYYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Mcx(self, params: Mcx, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SXdgGate(self, params: SXdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RYGate(self, params: RYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CPhaseGate(self, params: CPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Power(self, params: Power, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CRZGate(self, params: CRZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def C4XGate(self, params: C4XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UnitaryGate(self, params: UnitaryGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Subtractor(self, params: Subtractor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def CCXGate(self, params: CCXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRYGate(self, params: CRYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def StatePreparation(self, params: StatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseAnd(self, params: BitwiseAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ArithmeticOracle(self, params: ArithmeticOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GridEntangler(self, params: GridEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PhaseGate(self, params: PhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRXGate(self, params: CRXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LessEqual(self, params: LessEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RZZGate(self, params: RZZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LShift(self, params: LShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseInvert(self, params: BitwiseInvert, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def QDrift(self, params: QDrift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LogicalOr(self, params: LogicalOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Max(self, params: Max, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def Min(self, params: Min, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def C4XGate(self, params: C4XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def GreaterThan(self, params: GreaterThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Finance(self, params: Finance, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def FinanceModels(self, params: FinanceModels, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CustomFunction(self, params: CustomFunction, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def ExponentialStatePreparation(self, params: ExponentialStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RangeMixer(self, params: RangeMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RGate(self, params: RGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LinearPauliRotations(self, params: LinearPauliRotations, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SuzukiTrotter(self, params: SuzukiTrotter, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def HartreeFock(self, params: HartreeFock, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RXXGate(self, params: RXXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Negation(self, params: Negation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Adder(self, params: Adder, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def QSVMFeatureMap(self, params: QSVMFeatureMap, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def InequalityMixer(self, params: InequalityMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def SXdgGate(self, params: SXdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def TGate(self, params: TGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CRZGate(self, params: CRZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def TdgGate(self, params: TdgGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def StatePropagator(self, params: StatePropagator, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Max(self, params: Max, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HypercubeEntangler(self, params: HypercubeEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseOr(self, params: BitwiseOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def SwapGate(self, params: SwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CPhaseGate(self, params: CPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def AmplitudeEstimation(self, params: AmplitudeEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RZGate(self, params: RZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def iSwapGate(self, params: iSwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def NotEqual(self, params: NotEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def MCPhaseGate(self, params: MCPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HadamardTransform(self, params: HadamardTransform, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Arithmetic(self, params: Arithmetic, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RXGate(self, params: RXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def GroverOperator(self, params: GroverOperator, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def AmplitudeLoading(self, params: AmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def LogicalAnd(self, params: LogicalAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def RYGate(self, params: RYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def AmplitudeEstimation(self, params: AmplitudeEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseXor(self, params: BitwiseXor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def FinanceModels(self, params: FinanceModels, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GreaterEqual(self, params: GreaterEqual, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Equal(self, params: Equal, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Sign(self, params: Sign, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ComputationalBasisStatePreparation(self, params: ComputationalBasisStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LinearPauliRotations(self, params: LinearPauliRotations, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def UGate(self, params: UGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def FinancePayoff(self, params: FinancePayoff, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CYGate(self, params: CYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CZGate(self, params: CZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LShift(self, params: LShift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def QSVMFeatureMap(self, params: QSVMFeatureMap, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseAnd(self, params: BitwiseAnd, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RYYGate(self, params: RYYGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def InequalityMixer(self, params: InequalityMixer, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GreaterThan(self, params: GreaterThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def TwoDimensionalEntangler(self, params: TwoDimensionalEntangler, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def QFT(self, params: QFT, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def StatePreparation(self, params: StatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def PiecewiseLinearAmplitudeLoading(self, params: PiecewiseLinearAmplitudeLoading, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def CXGate(self, params: CXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def WStatePreparation(self, params: WStatePreparation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def ArithmeticOracle(self, params: ArithmeticOracle, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def iSwapGate(self, params: iSwapGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def CommutingPauliExponentiation(self, params: CommutingPauliExponentiation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def BitwiseXor(self, params: BitwiseXor, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def MCPhaseGate(self, params: MCPhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Power(self, params: Power, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def UCC(self, params: UCC, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def Identity(self, params: Identity, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LessThan(self, params: LessThan, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Multiplier(self, params: Multiplier, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RZZGate(self, params: RZZGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CustomFunction(self, params: CustomFunction, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def PhaseGate(self, params: PhaseGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def Finance(self, params: Finance, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def QDrift(self, params: QDrift, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def SuzukiTrotter(self, params: SuzukiTrotter, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CXGate(self, params: CXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HardwareEfficientAnsatz(self, params: HardwareEfficientAnsatz, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
     def XGate(self, params: XGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
-    def PhaseEstimation(self, params: PhaseEstimation, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def HVA(self, params: HVA, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CHGate(self, params: CHGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def CSXGate(self, params: CSXGate, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def GroverDiffuser(self, params: GroverDiffuser, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def RandomizedBenchmarking(self, params: RandomizedBenchmarking, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def LogicalOr(self, params: LogicalOr, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...
+    def BitwiseInvert(self, params: BitwiseInvert, in_wires: Optional[Dict[str, Wire]] = None) -> Dict[str, Wire]: ...

classiq/model/model.py

@@ -1,4 +1,5 @@
 """Model module, implementing facilities for designing models and generating circuits using Classiq platform."""
+
 from __future__ import annotations
 
 import logging

classiq/qmod/__init__.py

@@ -1,10 +1,11 @@
 from . import symbolic
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
+from .classical_function import CFunc
 from .qmod_parameter import Array, QParam
 from .qmod_struct import QStruct
 from .qmod_variable import Input, Output, QArray, QBit, QNum
-from .quantum_callable import QCallable
+from .quantum_callable import QCallable, QCallableList
 from .quantum_function import QFunc, create_model
 
 __all__ = [
@@ -16,8 +17,10 @@ __all__ = [
     "QBit",
     "QNum",
     "QCallable",
+    "QCallableList",
     "QStruct",
     "QFunc",
+    "CFunc",
     "create_model",
     "symbolic",
 ] + _builtins_all

classiq/qmod/builtins/__init__.py

@@ -1,3 +1,9 @@
+from .classical_execution_primitives import *  # noqa: F403
+from .classical_execution_primitives import (
+    __all__ as _builtin_classical_execution_primitives,
+)
+from .classical_functions import *  # noqa: F403
+from .classical_functions import __all__ as _builtin_classical_functions
 from .functions import *  # noqa: F403
 from .functions import __all__ as _builtin_functions
 from .operations import *  # noqa: F403
@@ -5,4 +11,10 @@ from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs
 
-__all__ = _builtin_structs + _builtin_functions + _builtin_operations
+__all__ = (
+    _builtin_structs
+    + _builtin_functions
+    + _builtin_operations
+    + _builtin_classical_execution_primitives
+    + _builtin_classical_functions
+)

classiq/qmod/builtins/classical_execution_primitives.py

@@ -0,0 +1,109 @@
+from typing import Dict, List, Optional
+
+from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
+from classiq.interface.executor.iqae_result import IQAEResult
+from classiq.interface.executor.result import EstimationResult, ExecutionDetails
+from classiq.interface.executor.vqe_result import VQESolverResult
+from classiq.interface.generator.expressions.enums import Optimizer
+from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
+from classiq.interface.generator.types.combinatorial_problem import (
+    CombinatorialOptimizationStructDeclaration,
+)
+
+from classiq.applications.qsvm.qsvm import Data, Labels
+
+ExecutionParams = Dict[str, float]
+
+
+def save(values_to_save: dict) -> None:
+    pass
+
+
+def sample(  # type: ignore
+    execution_params: Optional[ExecutionParams] = None,
+) -> ExecutionDetails:
+    pass
+
+
+def estimate(  # type: ignore
+    hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+) -> EstimationResult:
+    pass
+
+
+def vqe(  # type: ignore
+    hamiltonian: List[QmodPyStruct],
+    maximize: bool,
+    initial_point: List[int],
+    optimizer: Optimizer,
+    max_iteration: int,
+    tolerance: float,
+    step_size: float,
+    skip_compute_variance: bool,
+    alpha_cvar: float,
+) -> VQESolverResult:
+    pass
+
+
+def qae_with_qpe_result_post_processing(  # type: ignore
+    estimation_register_size: int,
+    estimation_method: QaeWithQpeEstimationMethod,
+    result: ExecutionDetails,
+) -> float:
+    pass
+
+
+def qsvm_full_run(  # type: ignore
+    train_data: Data,
+    train_labels: Labels,
+    test_data: Data,
+    test_labels: Labels,
+    predict_data: Data,
+) -> QmodPyStruct:
+    pass
+
+
+def iqae(  # type: ignore
+    epsilon: float,
+    alpha: float,
+    execution_params: Optional[ExecutionParams] = None,
+) -> IQAEResult:
+    pass
+
+
+def molecule_ground_state_solution_post_process(  # type: ignore
+    problem: QmodPyStruct, vqe_result: VQESolverResult
+) -> QmodPyStruct:
+    pass
+
+
+def optimization_problem_to_hamiltonian(  # type: ignore
+    problem_struct: CombinatorialOptimizationStructDeclaration, penalty_energy: float
+) -> List[QmodPyStruct]:
+    pass
+
+
+def get_optimization_solution(  # type: ignore
+    problem_struct: CombinatorialOptimizationStructDeclaration,
+    vqe_result: VQESolverResult,
+    penalty_energy: float,
+) -> List[QmodPyStruct]:
+    pass
+
+
+__all__ = [
+    "save",
+    "sample",
+    "estimate",
+    "vqe",
+    "qae_with_qpe_result_post_processing",
+    "qsvm_full_run",
+    "iqae",
+    "molecule_ground_state_solution_post_process",
+    "optimization_problem_to_hamiltonian",
+    "get_optimization_solution",
+]
+
+
+def __dir__() -> List[str]:
+    return __all__

classiq/qmod/builtins/classical_functions.py

@@ -0,0 +1,68 @@
+# This file was generated automatically - do not edit manually
+
+from typing import List
+
+from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.symbolic import symbolic_function
+
+from .structs import *
+
+
+def compute_qaoa_initial_point(
+    hamiltonian: QParam[List[PauliTerm]],
+    repetitions: QParam[int],
+) -> QParam[List[float]]:
+    return symbolic_function(hamiltonian, repetitions)
+
+
+def molecule_problem_to_hamiltonian(
+    problem: QParam[MoleculeProblem],
+) -> QParam[List[PauliTerm]]:
+    return symbolic_function(problem)
+
+
+def fock_hamiltonian_problem_to_hamiltonian(
+    problem: QParam[FockHamiltonianProblem],
+) -> QParam[List[PauliTerm]]:
+    return symbolic_function(problem)
+
+
+def grid_entangler_graph(
+    num_qubits: QParam[int],
+    schmidt_rank: QParam[int],
+    grid_randomization: QParam[bool],
+) -> QParam[List[List[int]]]:
+    return symbolic_function(num_qubits, schmidt_rank, grid_randomization)
+
+
+def hypercube_entangler_graph(
+    num_qubits: QParam[int],
+) -> QParam[List[List[int]]]:
+    return symbolic_function(num_qubits)
+
+
+def log_normal_finance_post_process(
+    finance_model: QParam[LogNormalModel],
+    estimation_method: QParam[FinanceFunction],
+    probability: QParam[float],
+) -> QParam[float]:
+    return symbolic_function(finance_model, estimation_method, probability)
+
+
+def gaussian_finance_post_process(
+    finance_model: QParam[GaussianModel],
+    estimation_method: QParam[FinanceFunction],
+    probability: QParam[float],
+) -> QParam[float]:
+    return symbolic_function(finance_model, estimation_method, probability)
+
+
+__all__ = [
+    "compute_qaoa_initial_point",
+    "molecule_problem_to_hamiltonian",
+    "fock_hamiltonian_problem_to_hamiltonian",
+    "grid_entangler_graph",
+    "hypercube_entangler_graph",
+    "log_normal_finance_post_process",
+    "gaussian_finance_post_process",
+]