classiq 0.36.1__py3-none-any.whl → 0.37.1__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/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"
         }
@@ -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",
@@ -22,6 +21,7 @@ REPEAT_OPERATOR = QuantumFunctionDeclaration(
 )
 
 OPERAND_FIELD_NAME = "operand"
+CTRL_FIELD_NAME = "ctrl"
 
 
 INVERT_OPERATOR = QuantumFunctionDeclaration(
@@ -35,8 +35,8 @@ INVERT_OPERATOR = QuantumFunctionDeclaration(
 CONTROL_OPERATOR = QuantumFunctionDeclaration(
     name="control",
     port_declarations={
-        "ctrl": PortDeclaration(
-            name="ctrl",
+        CTRL_FIELD_NAME: PortDeclaration(
+            name=CTRL_FIELD_NAME,
             direction=PortDeclarationDirection.Inout,
         )
     },
@@ -118,22 +118,6 @@ POWER_OPERATOR = QuantumFunctionDeclaration(
     },
 )
 
-
-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,
-        )
-    },
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
-    },
-)
-
 APPLY = QuantumFunctionDeclaration(
     name="apply",
     operand_declarations={
@@ -174,7 +158,6 @@ 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

@@ -78,15 +78,17 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         default=None
     )
     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_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/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/model/native_function_definition.py

@@ -1,9 +1,7 @@
-from typing import Any, Dict, List, Optional
+from typing import List
 
 import pydantic
 
-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 ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
@@ -28,12 +26,8 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
         default_factory=list, description="List of function calls to perform."
     )
 
-    local_handles: List[LocalVariableDeclaration] = pydantic.Field(
-        default_factory=list, description="List of local handles."
-    )
-
     def validate_body(self) -> None:
-        handle_validator = HandleValidator(self.port_declarations, self.local_handles)
+        handle_validator = HandleValidator(self.port_declarations)
 
         for statement in self.body:
             if isinstance(statement, VariableDeclarationStatement):
@@ -42,19 +36,3 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
                 handle_validator.handle_call(statement)
 
         handle_validator.report_errored_handles(ClassiqValueError)
-
-    @pydantic.validator("local_handles")
-    def validate_local_handles(
-        cls, local_handles: List[LocalVariableDeclaration], values: Dict[str, Any]
-    ) -> List[LocalVariableDeclaration]:
-        ports: Optional[Dict[str, PortDeclaration]] = values.get("port_declarations")
-        if ports is None:
-            return local_handles
-
-        intersection = {handle.name for handle in local_handles} & ports.keys()
-        if intersection:
-            raise ClassiqValueError(
-                f"The names {intersection} are both local handles and ports"
-            )
-
-        return local_handles

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -12,7 +12,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
+    QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric, QuantumType
 
@@ -27,7 +27,7 @@ VAR_DOMAIN_ILLEGAL = (
 )
 
 
-class AmplitudeLoadingOperation(QuantumExpressionOperation):
+class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
 
     @property

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -12,12 +12,12 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
+    QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_type import QuantumType
 
 
-class ArithmeticOperation(QuantumExpressionOperation):
+class ArithmeticOperation(QuantumAssignmentOperation):
     inplace_result: bool = pydantic.Field(
         description="Determines whether the result variable is initialized",
     )

classiq/interface/model/quantum_expressions/control_state.py

@@ -0,0 +1,38 @@
+from classiq.exceptions import ClassiqValueError
+
+
+def min_unsigned_bit_length(number: int) -> int:
+    if number < 0:
+        raise ClassiqValueError(
+            f"Quantum register is not signed but control value "  # noqa: B907
+            f"'{number}' is negative"
+        )
+    return 1 if number == 0 else number.bit_length()
+
+
+def min_signed_bit_length(number: int) -> int:
+    pos_val = abs(number)
+    is_whole = pos_val & (pos_val - 1) == 0
+    if number <= 0 and is_whole:
+        return min_unsigned_bit_length(pos_val)
+    return min_unsigned_bit_length(pos_val) + 1
+
+
+def min_bit_length(number: int, is_signed: bool) -> int:
+    return (
+        min_signed_bit_length(number) if is_signed else min_unsigned_bit_length(number)
+    )
+
+
+def to_twos_complement(value: int, bits: int, is_signed: bool) -> str:
+    required_bits = min_bit_length(value, is_signed)
+    if bits < required_bits:
+        raise ClassiqValueError(
+            f"Cannot express '{value}' using {bits} bits: "  # noqa: B907
+            f"at least {required_bits} bits are required"
+        )
+    if value >= 0:
+        return bin(value)[2:].zfill(bits)[::-1]
+    mask = (1 << bits) - 1
+    value = (abs(value) ^ mask) + 1
+    return bin(value)[:1:-1].rjust(bits, "1")

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -35,18 +35,12 @@ class VarRefCollector(ast.NodeVisitor):
 
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
-    result_var: HandleBinding = pydantic.Field(
-        description="The variable storing the expression result"
-    )
     _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
         default_factory=list,
     )
     _var_types: Dict[str, QuantumType] = pydantic.PrivateAttr(
         default_factory=dict,
     )
-    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
-        default=None,
-    )
 
     @property
     def var_handles(self) -> List[HandleBinding]:
@@ -75,15 +69,24 @@ class QuantumExpressionOperation(QuantumOperation):
     ]:
         return nameables_to_dict(self.var_handles)
 
-    @property
-    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return {self.result_name(): self.result_var}
+
+class QuantumAssignmentOperation(QuantumExpressionOperation):
+    result_var: HandleBinding = pydantic.Field(
+        description="The variable storing the expression result"
+    )
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
 
     @property
     def result_type(self) -> QuantumType:
         assert self._result_type is not None
         return self._result_type
 
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {self.result_name(): self.result_var}
+
     @classmethod
     @abc.abstractmethod
     def result_name(cls) -> str:

classiq/interface/model/quantum_function_call.py

@@ -38,6 +38,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import get_unique_handle_names
 from classiq.interface.model.variable_declaration_statement import (
@@ -356,6 +357,7 @@ ConcreteQuantumStatement = Union[
     BindOperation,
     NumericReinterpretationOperation,
     InplaceBinaryOperation,
+    QuantumIfOperation,
 ]
 
 
@@ -405,6 +407,7 @@ QuantumCallable = Union[str, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
 
 QuantumFunctionCall.update_forward_refs()
+QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
 
 
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:

classiq/interface/model/quantum_function_declaration.py

@@ -83,9 +83,9 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
         default_factory=list
     )
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "QuantumFunctionDeclaration"]
-    ] = {}
+    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[Dict[str, "QuantumFunctionDeclaration"]] = (
+        {}
+    )
 
     @property
     def input_set(self) -> Set[str]: