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

classiq/interface/generator/expressions/qmod_qnum_proxy.py

@@ -0,0 +1,22 @@
+from sympy import Symbol
+
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+
+class QmodQNumProxy(Symbol, QmodSizedProxy):
+    def __new__(cls, name, **assumptions):
+        return super().__new__(cls, name, **assumptions)
+
+    def __init__(self, name: str, quantum_type: QuantumNumeric) -> None:
+        super().__init__(quantum_type.size_in_bits)
+        self._fraction_digits = quantum_type.fraction_digits
+        self._is_signed = quantum_type.is_signed
+
+    @property
+    def fraction_digits(self) -> int:
+        return self._fraction_digits
+
+    @property
+    def is_signed(self) -> bool:
+        return self._is_signed

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,16 +1,6 @@
-from sympy import Symbol
-
-
-class QmodSizedProxy(Symbol):
-    def __new__(cls, name, **assumptions):
-        return super().__new__(cls, name, **assumptions)
-
-    def __init__(self, name: str, size: int) -> None:
+class QmodSizedProxy:
+    def __init__(self, size: int) -> None:
         self._size = size
 
-    @property
-    def size(self) -> int:
-        return self.args[0]
-
     def __len__(self) -> int:
         return self._size

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/atomic_quantum_functions.py

@@ -473,8 +473,23 @@ ADD_FUNCTION = QuantumFunctionDeclaration(
 )
 
 
-INPLACE_ADD_FUNCTION = QuantumFunctionDeclaration(
-    name="inplace_add",
+MODULAR_ADD_FUNCTION = QuantumFunctionDeclaration(
+    name="modular_add",
+    port_declarations={
+        "left": PortDeclaration(
+            name="left",
+            direction=PortDeclarationDirection.Inout,
+        ),
+        "right": PortDeclaration(
+            name="right",
+            direction=PortDeclarationDirection.Inout,
+        ),
+    },
+)
+
+
+INTEGER_XOR_FUNCTION = QuantumFunctionDeclaration(
+    name="integer_xor",
     port_declarations={
         "left": PortDeclaration(
             name="left",
@@ -541,6 +556,47 @@ FREE_FUNCTION = QuantumFunctionDeclaration(
     },
 )
 
+
+RANDOMIZED_BENCHMARKING = QuantumFunctionDeclaration(
+    name="randomized_benchmarking",
+    port_declarations={
+        DEFAULT_TARGET_NAME: PortDeclaration(
+            name=DEFAULT_TARGET_NAME,
+            direction=PortDeclarationDirection.Inout,
+        ),
+    },
+    param_decls={
+        "num_of_cliffords": Integer(),
+    },
+)
+
+
+INPLACE_PREPARE_STATE = QuantumFunctionDeclaration(
+    name="inplace_prepare_state",
+    param_decls={"probabilities": ClassicalList(element_type=Real()), "bound": Real()},
+    port_declarations={
+        "target": PortDeclaration(
+            name="target",
+            direction=PortDeclarationDirection.Inout,
+            size=Expression(expr="log(len(probabilities), 2)"),
+        )
+    },
+)
+
+
+INPLACE_PREPARE_AMPLITUDES = QuantumFunctionDeclaration(
+    name="inplace_prepare_amplitudes",
+    param_decls={"amplitudes": ClassicalList(element_type=Real()), "bound": Real()},
+    port_declarations={
+        "target": PortDeclaration(
+            name="target",
+            direction=PortDeclarationDirection.Inout,
+            size=Expression(expr="log(len(amplitudes), 2)"),
+        )
+    },
+)
+
+
 __all__ = [
     "H_FUNCTION",
     "X_FUNCTION",
@@ -573,9 +629,13 @@ __all__ = [
     "PREPARE_AMPLITUDES_FUNCTION",
     "UNITARY_FUNCTION",
     "ADD_FUNCTION",
-    "INPLACE_ADD_FUNCTION",
+    "MODULAR_ADD_FUNCTION",
+    "INTEGER_XOR_FUNCTION",
     "U_FUNCTION",
     "CCX_FUNCTION",
     "ALLOCATE_FUNCTION",
     "FREE_FUNCTION",
+    "RANDOMIZED_BENCHMARKING",
+    "INPLACE_PREPARE_STATE",
+    "INPLACE_PREPARE_AMPLITUDES",
 ]

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/std_lib_functions.py

@@ -34,35 +34,101 @@ QFT = QuantumFunctionDeclaration.parse_raw(
 }"""
 )
 
-STANDARD_QPE = QuantumFunctionDeclaration.parse_raw(
+QPE_FLEXIBLE = QuantumFunctionDeclaration.parse_raw(
     """{
-    "name": "standard_qpe",
-    "param_decls": {
-        "precision": {
-            "kind": "int"
+    "name": "qpe_flexible",
+    "param_decls": {},
+    "port_declarations": {
+        "phase": {
+            "name": "phase",
+            "quantum_type": {
+                "size": null,
+                "kind": "qnum"
+            },
+            "direction": "inout"
         }
     },
+    "operand_declarations": {
+        "unitary_with_power": {
+            "name": "unitary_with_power",
+            "positional_arg_declarations": [
+                {
+                    "name": "arg0",
+                    "classical_type": {
+                        "kind": "int"
+                    }
+                }
+            ],
+            "is_list": false
+        }
+    },
+    "positional_arg_declarations": [
+        {
+            "name": "unitary_with_power",
+            "positional_arg_declarations": [
+                {
+                    "name": "arg0",
+                    "classical_type": {
+                        "kind": "int"
+                    }
+                }
+            ],
+            "is_list": false
+        },
+        {
+            "name": "phase",
+            "quantum_type": {
+                "size": null,
+                "kind": "qnum"
+            },
+            "direction": "inout"
+        }
+    ]
+}"""
+)
+
+QPE = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qpe",
+    "param_decls": {},
     "port_declarations": {
         "phase": {
             "name": "phase",
-            "size": {
-                "expr": "precision"
+            "quantum_type": {
+                "size": null,
+                "kind": "qnum"
             },
             "direction": "inout"
         }
     },
     "operand_declarations": {
         "unitary": {
-            "name": "unitary"
+            "name": "unitary",
+            "positional_arg_declarations": [],
+            "is_list": false
         }
     },
-    "positional_arg_declarations": []
+    "positional_arg_declarations": [
+        {
+            "name": "unitary",
+            "positional_arg_declarations": [],
+            "is_list": false
+        },
+        {
+            "name": "phase",
+            "quantum_type": {
+                "size": null,
+                "kind": "qnum"
+            },
+            "direction": "inout"
+        }
+    ]
 }"""
 )
 
-QPE = QuantumFunctionDeclaration.parse_raw(
+STANDARD_QPE = QuantumFunctionDeclaration.parse_raw(
     """{
-    "name": "qpe",
+    "name": "standard_qpe",
     "param_decls": {
         "precision": {
             "kind": "int"
@@ -74,7 +140,7 @@ QPE = QuantumFunctionDeclaration.parse_raw(
             "size": {
                 "expr": "precision"
             },
-            "direction": "output"
+            "direction": "inout"
         }
     },
     "operand_declarations": {
@@ -450,7 +516,7 @@ PREPARE_INT = QuantumFunctionDeclaration.parse_raw(
         "out": {
             "name": "out",
             "quantum_type": {
-                "kind": "qint"
+                "kind": "qnum"
             },
             "direction": "output"
         }
@@ -467,11 +533,11 @@ ALLOCATE_NUM = QuantumFunctionDeclaration.parse_raw(
         "num_qubits": {
             "kind": "int"
         },
-        "fraction_digits": {
-            "kind": "int"
-        },
         "is_signed": {
             "kind": "bool"
+        },
+        "fraction_digits": {
+            "kind": "int"
         }
     },
     "port_declarations": {
@@ -711,11 +777,70 @@ FULL_HEA = QuantumFunctionDeclaration.parse_raw(
 }"""
 )
 
+SWAP_TEST = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "swap_test",
+    "param_decls": {},
+    "port_declarations": {
+        "state1": {
+            "name": "state1",
+            "quantum_type": {
+                "length": null,
+                "kind": "qvec"
+            },
+            "direction": "inout"
+        },
+        "state2": {
+            "name": "state2",
+            "quantum_type": {
+                "length": null,
+                "kind": "qvec"
+            },
+            "direction": "inout"
+        },
+        "test": {
+            "name": "test",
+            "quantum_type": {
+                "kind": "qbit"
+            },
+            "direction": "output"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": [
+        {
+            "name": "state1",
+            "quantum_type": {
+                "length": null,
+                "kind": "qvec"
+            },
+            "direction": "inout"
+        },
+        {
+            "name": "state2",
+            "quantum_type": {
+                "length": null,
+                "kind": "qvec"
+            },
+            "direction": "inout"
+        },
+        {
+            "name": "test",
+            "quantum_type": {
+                "kind": "qbit"
+            },
+            "direction": "output"
+        }
+    ]
+}"""
+)
+
 __all__ = [
     "QFT_STEP",
     "QFT",
-    "STANDARD_QPE",
+    "QPE_FLEXIBLE",
     "QPE",
+    "STANDARD_QPE",
     "SINGLE_PAULI",
     "LINEAR_PAULI_ROTATIONS",
     "AMPLITUDE_ESTIMATION",
@@ -733,4 +858,5 @@ __all__ = [
     "QAOA_INIT",
     "QAOA_PENALTY",
     "FULL_HEA",
+    "SWAP_TEST",
 ]

classiq/interface/generator/functions/core_lib_declarations/quantum_operators.py

@@ -9,7 +9,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_type import QuantumInteger
 
 REPEAT_OPERATOR = QuantumFunctionDeclaration(
     name="repeat",
@@ -21,22 +20,29 @@ REPEAT_OPERATOR = QuantumFunctionDeclaration(
     },
 )
 
+OPERAND_FIELD_NAME = "operand"
+CTRL_FIELD_NAME = "ctrl"
+
 
 INVERT_OPERATOR = QuantumFunctionDeclaration(
     name="invert",
-    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
+    },
 )
 
 
 CONTROL_OPERATOR = QuantumFunctionDeclaration(
     name="control",
     port_declarations={
-        "ctrl": PortDeclaration(
-            name="ctrl",
+        CTRL_FIELD_NAME: PortDeclaration(
+            name=CTRL_FIELD_NAME,
             direction=PortDeclarationDirection.Inout,
         )
     },
-    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
+    },
 )
 
 IF_OPERATOR = QuantumFunctionDeclaration(
@@ -107,21 +113,38 @@ PERMUTE_OPERATOR = QuantumFunctionDeclaration(
 POWER_OPERATOR = QuantumFunctionDeclaration(
     name="power",
     param_decls={"power": Integer()},
-    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
+    },
 )
 
+APPLY = QuantumFunctionDeclaration(
+    name="apply",
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
+            name=OPERAND_FIELD_NAME,
+        )
+    },
+)
 
-CONTROL_WITH_VALUE_OPERATOR = QuantumFunctionDeclaration(
-    name="control_with_value",
-    param_decls={"ctrl_val": Integer()},
-    port_declarations={
-        "ctrl": PortDeclaration(
-            name="ctrl",
-            quantum_type=QuantumInteger(),
-            direction=PortDeclarationDirection.Inout,
+
+COMPUTE = QuantumFunctionDeclaration(
+    name="compute",
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
+            name=OPERAND_FIELD_NAME,
+        )
+    },
+)
+
+
+UNCOMPUTE = QuantumFunctionDeclaration(
+    name="uncompute",
+    operand_declarations={
+        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
+            name=OPERAND_FIELD_NAME,
         )
     },
-    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
 )
 
 
@@ -135,7 +158,9 @@ BUILTIN_QUANTUM_OPERATOR_LIST = [
     SPLIT_OPERATOR,
     PERMUTE_OPERATOR,
     POWER_OPERATOR,
-    CONTROL_WITH_VALUE_OPERATOR,
+    APPLY,
+    COMPUTE,
+    UNCOMPUTE,
 ]
 
 

classiq/interface/generator/functions/native_function_definition.py

@@ -89,9 +89,9 @@ class SynthesisNativeFunctionDefinition(SynthesisQuantumFunctionDeclaration):
 
     @pydantic.root_validator
     def validate_ports(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        port_declarations: Optional[
-            Dict[IOName, SynthesisPortDeclaration]
-        ] = values.get("port_declarations")
+        port_declarations: Optional[Dict[IOName, SynthesisPortDeclaration]] = (
+            values.get("port_declarations")
+        )
         if port_declarations is None:
             return values
         cls._validate_direction_ports(

classiq/interface/generator/model/constraints.py

@@ -40,9 +40,9 @@ class Constraints(BaseModel, extra=Extra.forbid):
     )
     max_depth: Optional[pydantic.PositiveInt] = None
 
-    max_gate_count: Dict[
-        TranspilerBasisGates, pydantic.NonNegativeInt
-    ] = pydantic.Field(default_factory=lambda: defaultdict(int))
+    max_gate_count: Dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
+        pydantic.Field(default_factory=lambda: defaultdict(int))
+    )
 
     optimization_parameter: OptimizationParameterType = pydantic.Field(
         default=OptimizationParameter.NO_OPTIMIZATION,

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

@@ -11,12 +11,14 @@ 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.hardware.hardware_data import (
     BACKEND_VALIDATION_ERROR_MESSAGE,
     CustomHardwareSettings,
 )
 from classiq.interface.generator.model.preferences.randomness import create_random_seed
 from classiq.interface.hardware import Provider
+from classiq.interface.helpers.custom_pydantic_types import PydanticMachinePrecision
 
 from classiq._internals.enum_utils import StrEnum
 
@@ -50,7 +52,6 @@ _SERVICE_PROVIDER_TO_FORMAT: Dict[Provider, QuantumFormat] = {
     Provider.AMAZON_BRAKET: QuantumFormat.QASM,
 }
 
-
 if TYPE_CHECKING:
     PydanticConstrainedQuantumFormatList = List[QuantumFormat]
 else:
@@ -76,15 +77,18 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
     _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
         default=None
     )
-    backend_service_provider: Optional[
-        Union[Provider, ProviderVendor, str]
-    ] = pydantic.Field(
-        default=None, description="Provider company or cloud for the requested backend."
+    machine_precision: PydanticMachinePrecision = MAXIMAL_MACHINE_PRECISION
+
+    backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
+        pydantic.Field(
+            default=None,
+            description="Provider company or cloud for the requested backend.",
+        )
     )
-    backend_name: Optional[
-        Union[PydanticBackendName, AllBackendsNameByVendor]
-    ] = pydantic.Field(
-        default=None, description="Name of the requested backend or target."
+    backend_name: Optional[Union[PydanticBackendName, AllBackendsNameByVendor]] = (
+        pydantic.Field(
+            default=None, description="Name of the requested backend or target."
+        )
     )
     custom_hardware_settings: CustomHardwareSettings = pydantic.Field(
         default_factory=CustomHardwareSettings,

classiq/interface/generator/noise_properties.py

@@ -7,9 +7,9 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class NoiseProperties(BaseModel):
-    measurement_bit_flip_probability: Optional[
-        PydanticProbabilityFloat
-    ] = pydantic.Field(
-        default=None,
-        description="Probability of measuring the wrong value for each qubit.",
+    measurement_bit_flip_probability: Optional[PydanticProbabilityFloat] = (
+        pydantic.Field(
+            default=None,
+            description="Probability of measuring the wrong value for each qubit.",
+        )
     )

classiq/interface/generator/qpe.py

@@ -84,11 +84,11 @@ class PhaseEstimation(FunctionParams):
         description="The unitary function parameters.",
         default_factory=CustomFunction,
     )
-    exponentiation_specification: Optional[
-        ExponentiationSpecification
-    ] = pydantic.Field(
-        default=None,
-        description="The specifications for phase estimation of exponentiation functions.",
+    exponentiation_specification: Optional[ExponentiationSpecification] = (
+        pydantic.Field(
+            default=None,
+            description="The specifications for phase estimation of exponentiation functions.",
+        )
     )
 
     _output_name: IOName = pydantic.PrivateAttr(

classiq/interface/generator/quantum_function_call.py

@@ -537,9 +537,11 @@ class SynthesisQuantumFunctionCall(BaseModel):
         valid_matches: List[Match] = []
         invalid_expressions: List[str] = []
         for expression, expression_match in zip(expressions, expression_matches):
-            invalid_expressions.append(
-                expression
-            ) if expression_match is None else valid_matches.append(expression_match)
+            (
+                invalid_expressions.append(expression)
+                if expression_match is None
+                else valid_matches.append(expression_match)
+            )
 
         invalid_slicings: List[str] = []
         invalid_names: List[str] = []

classiq/interface/generator/randomized_benchmarking.py

@@ -3,16 +3,18 @@ import pydantic
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import FunctionParams
 
-_DEFAULT_RB_NAME = "rb_reg"
+RANDOMIZED_BENCHMARKING_INPUT: str = "TARGET"
+RANDOMIZED_BENCHMARKING_OUTPUT: str = "TARGET"
 
 
 class RandomizedBenchmarking(FunctionParams):
     num_of_qubits: pydantic.PositiveInt
     num_of_cliffords: pydantic.PositiveInt
-    register_name: str = _DEFAULT_RB_NAME
 
     def _create_ios(self) -> None:
         self._inputs = {
-            self.register_name: RegisterArithmeticInfo(size=self.num_of_qubits)
+            RANDOMIZED_BENCHMARKING_INPUT: RegisterArithmeticInfo(
+                size=self.num_of_qubits
+            )
         }
         self._outputs = {**self._inputs}

classiq/interface/generator/visitor.py

@@ -81,8 +81,7 @@ class Visitor:
 class Transformer(Visitor):
     if TYPE_CHECKING:
 
-        def visit(self, node: NodeType) -> Any:
-            ...
+        def visit(self, node: NodeType) -> Any: ...
 
     def visit_list(self, node: List[NodeType]) -> List[RetType]:
         return [self.visit(elem) for elem in node]

classiq/interface/hardware.py

@@ -13,7 +13,7 @@ class Provider(StrEnum):
     IONQ = "IonQ"
     CLASSIQ = "Classiq"
     GOOGLE = "Google"
-    ALICE_AND_BOB = "Alice and Bob"
+    ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
 
     @property

classiq/interface/helpers/custom_pydantic_types.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Any, List, Tuple
 
 import pydantic
 
+from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
 from classiq.interface.generator.parameters import ParameterComplexType
 
 # General int types
@@ -10,11 +11,16 @@ MAX_EXPRESSION_SIZE = 32768
 
 if TYPE_CHECKING:
     PydanticLargerThanOneInteger = int
+    PydanticMachinePrecision = int
 else:
 
     class PydanticLargerThanOneInteger(pydantic.ConstrainedInt):
         gt = 1
 
+    class PydanticMachinePrecision(pydantic.ConstrainedInt):
+        gt = 0
+        le = MAXIMAL_MACHINE_PRECISION
+
 
 # Probability float types
 if TYPE_CHECKING: