classiq 0.36.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

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 WeightedAdder(self, params: WeightedAdder, 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 Mcu(self, params: Mcu, 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 Mcx(self, params: Mcx, 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 HadamardTransform(self, params: HadamardTransform, 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 CRZGate(self, params: CRZGate, 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 Subtractor(self, params: Subtractor, 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 PhaseEstimation(self, params: PhaseEstimation, 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 CHGate(self, params: CHGate, 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 BitwiseInvert(self, params: BitwiseInvert, 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 LessEqual(self, params: LessEqual, 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 LogicalOr(self, params: LogicalOr, 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 CustomFunction(self, params: CustomFunction, 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 ExponentialStatePreparation(self, params: ExponentialStatePreparation, 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 YGate(self, params: YGate, 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 ZGate(self, params: ZGate, 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 HVA(self, params: HVA, 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 IGate(self, params: IGate, 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 SGate(self, params: SGate, 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 SdgGate(self, params: SdgGate, 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 StatePropagator(self, params: StatePropagator, 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 PhaseEstimation(self, params: PhaseEstimation, 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 MCPhaseGate(self, params: MCPhaseGate, 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 BitwiseOr(self, params: BitwiseOr, 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 SwapGate(self, params: SwapGate, 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 SdgGate(self, params: SdgGate, 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 LinearPauliRotations(self, params: LinearPauliRotations, 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 TdgGate(self, params: TdgGate, 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 PiecewiseLinearRotationAmplitudeLoading(self, params: PiecewiseLinearRotationAmplitudeLoading, 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 HypercubeEntangler(self, params: HypercubeEntangler, 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 QDrift(self, params: QDrift, 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 C4XGate(self, params: C4XGate, 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 LogicalAnd(self, params: LogicalAnd, 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 GroverDiffuser(self, params: GroverDiffuser, 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 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 ExponentialStatePreparation(self, params: ExponentialStatePreparation, 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 BitwiseXor(self, params: BitwiseXor, 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 CustomFunction(self, params: CustomFunction, 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 GreaterThan(self, params: GreaterThan, 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 RZGate(self, params: RZGate, 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 LessEqual(self, params: LessEqual, 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 Power(self, params: Power, 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 BitwiseAnd(self, params: BitwiseAnd, 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 Finance(self, params: Finance, 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 ComputationalBasisStatePreparation(self, params: ComputationalBasisStatePreparation, 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 SwapGate(self, params: SwapGate, 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 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 iSwapGate(self, params: iSwapGate, 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 Power(self, params: Power, 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 Adder(self, params: Adder, 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 LogicalOr(self, params: LogicalOr, 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 RYGate(self, params: RYGate, 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 RZZGate(self, params: RZZGate, 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 CHGate(self, params: CHGate, 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 Exponentiation(self, params: Exponentiation, 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 PiecewiseLinearAmplitudeLoading(self, params: PiecewiseLinearAmplitudeLoading, 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 QDrift(self, params: QDrift, 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 StatePropagator(self, params: StatePropagator, 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 RYYGate(self, params: RYYGate, 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 CustomOracle(self, params: CustomOracle, 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 LinearPauliRotations(self, params: LinearPauliRotations, 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 CommutingPauliExponentiation(self, params: CommutingPauliExponentiation, 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 RGate(self, params: RGate, 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 RXXGate(self, params: RXXGate, 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 CustomOracle(self, params: CustomOracle, 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 Exponentiation(self, params: Exponentiation, 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 CRYGate(self, params: CRYGate, 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 UGate(self, params: UGate, 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 WStatePreparation(self, params: WStatePreparation, 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 LessThan(self, params: LessThan, 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 CPhaseGate(self, params: CPhaseGate, 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 InequalityMixer(self, params: InequalityMixer, 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 WeightedAdder(self, params: WeightedAdder, 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 CXGate(self, params: CXGate, 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 FinancePayoff(self, params: FinancePayoff, 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 HadamardTransform(self, params: HadamardTransform, 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 Equal(self, params: Equal, 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 QSVMFeatureMap(self, params: QSVMFeatureMap, 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 CRXGate(self, params: CRXGate, 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 Sign(self, params: Sign, 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 XGate(self, params: XGate, 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 LinearGCI(self, params: LinearGCI, 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 MCPhaseGate(self, params: MCPhaseGate, 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 SuzukiTrotter(self, params: SuzukiTrotter, 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 UniformDistributionStatePreparation(self, params: UniformDistributionStatePreparation, 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 RYGate(self, params: RYGate, 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 RShift(self, params: RShift, 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 GroverOperator(self, params: GroverOperator, 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 AmplitudeEstimation(self, params: AmplitudeEstimation, 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 UnitaryGate(self, params: UnitaryGate, 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 PiecewiseLinearAmplitudeLoading(self, params: PiecewiseLinearAmplitudeLoading, 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 iSwapGate(self, params: iSwapGate, 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 HypercubeEntangler(self, params: HypercubeEntangler, 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]: ...

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,9 +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__ = [
@@ -15,7 +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",
+]

classiq/qmod/builtins/functions.py

@@ -4,7 +4,7 @@ from typing import List, Literal
 
 from classiq.qmod.qmod_parameter import QParam
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
-from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_function import ExternalQFunc
 
 from .structs import *
@@ -257,7 +257,15 @@ def add(
 
 
 @ExternalQFunc
-def inplace_add(
+def modular_add(
+    left: QArray[QBit],
+    right: QArray[QBit],
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def integer_xor(
     left: QArray[QBit],
     right: QArray[QBit],
 ) -> None:
@@ -298,6 +306,32 @@ def free(
     pass
 
 
+@ExternalQFunc
+def randomized_benchmarking(
+    num_of_cliffords: QParam[int],
+    target: QArray[QBit],
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def inplace_prepare_state(
+    probabilities: QParam[List[float]],
+    bound: QParam[float],
+    target: QArray[QBit, Literal["log(len(probabilities), 2)"]],
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def inplace_prepare_amplitudes(
+    amplitudes: QParam[List[float]],
+    bound: QParam[float],
+    target: QArray[QBit, Literal["log(len(amplitudes), 2)"]],
+) -> None:
+    pass
+
+
 @ExternalQFunc
 def single_pauli_exponent(
     pauli_string: QParam[List[int]],
@@ -353,19 +387,26 @@ def qft(
 
 
 @ExternalQFunc
-def standard_qpe(
-    precision: QParam[int],
-    unitary: QCallable,
-    phase: QArray[QBit, Literal["precision"]],
+def qpe_flexible(
+    unitary_with_power: QCallable[QParam[int]],
+    phase: QNum,
 ) -> None:
     pass
 
 
 @ExternalQFunc
 def qpe(
+    unitary: QCallable,
+    phase: QNum,
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def standard_qpe(
     precision: QParam[int],
     unitary: QCallable,
-    phase: Output[QArray[QBit, Literal["precision"]]],
+    phase: QArray[QBit, Literal["precision"]],
 ) -> None:
     pass
 
@@ -466,8 +507,8 @@ def prepare_int(
 @ExternalQFunc
 def allocate_num(
     num_qubits: QParam[int],
-    fraction_digits: QParam[int],
     is_signed: QParam[bool],
+    fraction_digits: QParam[int],
     out: Output[QNum],
 ) -> None:
     pass
@@ -527,13 +568,22 @@ def full_hea(
     angle_params: QParam[List[float]],
     connectivity_map: QParam[List[List[int]]],
     reps: QParam[int],
-    operands_1qubit: QCallable[QParam[float], QBit],
-    operands_2qubit: QCallable[QParam[float], QBit, QBit],
+    operands_1qubit: QCallableList[QParam[float], QBit],
+    operands_2qubit: QCallableList[QParam[float], QBit, QBit],
     x: QArray[QBit, Literal["num_qubits"]],
 ) -> None:
     pass
 
 
+@ExternalQFunc
+def swap_test(
+    state1: QArray[QBit],
+    state2: QArray[QBit],
+    test: Output[QArray[QBit]],
+) -> None:
+    pass
+
+
 @ExternalQFunc
 def repeat(
     count: QParam[int],
@@ -569,7 +619,7 @@ def if_(
 @ExternalQFunc
 def switch(
     selector: QParam[int],
-    cases: QCallable,
+    cases: QCallableList,
 ) -> None:
     pass
 
@@ -596,7 +646,7 @@ def split(
 
 @ExternalQFunc
 def permute(
-    functions: QCallable,
+    functions: QCallableList,
 ) -> None:
     pass
 
@@ -610,10 +660,22 @@ def power(
 
 
 @ExternalQFunc
-def control_with_value(
-    ctrl_val: QParam[int],
+def apply(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def compute(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@ExternalQFunc
+def uncompute(
     operand: QCallable,
-    ctrl: QNum,
 ) -> None:
     pass
 
@@ -773,19 +835,24 @@ __all__ = [
     "prepare_amplitudes",
     "unitary",
     "add",
-    "inplace_add",
+    "modular_add",
+    "integer_xor",
     "U",
     "CCX",
     "allocate",
     "free",
+    "randomized_benchmarking",
+    "inplace_prepare_state",
+    "inplace_prepare_amplitudes",
     "single_pauli_exponent",
     "suzuki_trotter",
     "qdrift",
     "exponentiation_with_depth_constraint",
     "qft_step",
     "qft",
-    "standard_qpe",
+    "qpe_flexible",
     "qpe",
+    "standard_qpe",
     "single_pauli",
     "linear_pauli_rotations",
     "amplitude_estimation",
@@ -803,6 +870,7 @@ __all__ = [
     "qaoa_init",
     "qaoa_penalty",
     "full_hea",
+    "swap_test",
     "repeat",
     "invert",
     "control",
@@ -812,7 +880,9 @@ __all__ = [
     "split",
     "permute",
     "power",
-    "control_with_value",
+    "apply",
+    "compute",
+    "uncompute",
     "molecule_ucc",
     "molecule_hva",
     "molecule_hartree_fock",