classiq 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

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

@@ -7,17 +7,10 @@ from classiq.interface.model.quantum_function_declaration import (
 QFT_STEP = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qft_step",
-    "param_decls": {
-        "num_qbits": {
-            "kind": "int"
-        }
-    },
+    "param_decls": {},
     "port_declarations": {
-        "qbv": {
-            "name": "qbv",
-            "size": {
-                "expr": "num_qbits"
-            },
+        "target": {
+            "name": "target",
             "direction": "inout"
         }
     },
@@ -29,21 +22,40 @@ QFT_STEP = QuantumFunctionDeclaration.parse_raw(
 QFT = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qft",
+    "param_decls": {},
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+STANDARD_QPE = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "standard_qpe",
     "param_decls": {
-        "num_qbits": {
+        "precision": {
             "kind": "int"
         }
     },
     "port_declarations": {
-        "qbv": {
-            "name": "qbv",
+        "phase": {
+            "name": "phase",
             "size": {
-                "expr": "num_qbits"
+                "expr": "precision"
             },
             "direction": "inout"
         }
     },
-    "operand_declarations": {},
+    "operand_declarations": {
+        "unitary": {
+            "name": "unitary"
+        }
+    },
     "positional_arg_declarations": []
 }"""
 )
@@ -52,41 +64,22 @@ QPE = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qpe",
     "param_decls": {
-        "reg_size": {
-            "kind": "int"
-        },
-        "qpe_reg_size": {
+        "precision": {
             "kind": "int"
         }
     },
     "port_declarations": {
-        "x": {
-            "name": "x",
-            "size": {
-                "expr": "reg_size"
-            },
-            "direction": "inout"
-        },
-        "q": {
-            "name": "q",
+        "phase": {
+            "name": "phase",
             "size": {
-                "expr": "qpe_reg_size"
+                "expr": "precision"
             },
-            "direction": "inout"
+            "direction": "output"
         }
     },
     "operand_declarations": {
-        "qfunc": {
-            "name": "qfunc",
-            "port_declarations": {
-                "target": {
-                    "name": "target",
-                    "size": {
-                        "expr": "reg_size"
-                    },
-                    "direction": "inout"
-                }
-            }
+        "unitary": {
+            "name": "unitary"
         }
     },
     "positional_arg_declarations": []
@@ -97,9 +90,6 @@ SINGLE_PAULI = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "single_pauli",
     "param_decls": {
-        "reg_size": {
-            "kind": "int"
-        },
         "slope": {
             "kind": "real"
         },
@@ -110,9 +100,6 @@ SINGLE_PAULI = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "x": {
             "name": "x",
-            "size": {
-                "expr": "reg_size"
-            },
             "direction": "inout"
         },
         "q": {
@@ -150,12 +137,6 @@ LINEAR_PAULI_ROTATIONS = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "linear_pauli_rotations",
     "param_decls": {
-        "reg_size": {
-            "kind": "int"
-        },
-        "num_state_qubits": {
-            "kind": "int"
-        },
         "bases": {
             "kind": "list",
             "element_type": {
@@ -178,16 +159,10 @@ LINEAR_PAULI_ROTATIONS = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "x": {
             "name": "x",
-            "size": {
-                "expr": "reg_size"
-            },
             "direction": "inout"
         },
         "q": {
             "name": "q",
-            "size": {
-                "expr": "num_state_qubits"
-            },
             "direction": "inout"
         }
     },
@@ -380,17 +355,10 @@ GROVER_OPERATOR = QuantumFunctionDeclaration.parse_raw(
 HADAMARD_TRANSFORM = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "hadamard_transform",
-    "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        }
-    },
+    "param_decls": {},
     "port_declarations": {
-        "q": {
-            "name": "q",
-            "size": {
-                "expr": "num_qubits"
-            },
+        "target": {
+            "name": "target",
             "direction": "inout"
         }
     },
@@ -402,17 +370,10 @@ HADAMARD_TRANSFORM = QuantumFunctionDeclaration.parse_raw(
 APPLY_TO_ALL = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "apply_to_all",
-    "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        }
-    },
+    "param_decls": {},
     "port_declarations": {
-        "q": {
-            "name": "q",
-            "size": {
-                "expr": "num_qubits"
-            },
+        "target": {
+            "name": "target",
             "direction": "inout"
         }
     },
@@ -503,9 +464,6 @@ QAOA_MIXER_LAYER = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qaoa_mixer_layer",
     "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        },
         "b": {
             "kind": "real"
         }
@@ -513,9 +471,6 @@ QAOA_MIXER_LAYER = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "target": {
             "name": "target",
-            "size": {
-                "expr": "num_qubits"
-            },
             "direction": "inout"
         }
     },
@@ -528,9 +483,6 @@ QAOA_COST_LAYER = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qaoa_cost_layer",
     "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        },
         "g": {
             "kind": "real"
         },
@@ -548,9 +500,6 @@ QAOA_COST_LAYER = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "target": {
             "name": "target",
-            "size": {
-                "expr": "num_qubits"
-            },
             "direction": "inout"
         }
     },
@@ -563,9 +512,6 @@ QAOA_LAYER = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qaoa_layer",
     "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        },
         "g": {
             "kind": "real"
         },
@@ -586,9 +532,6 @@ QAOA_LAYER = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "target": {
             "name": "target",
-            "size": {
-                "expr": "num_qubits"
-            },
             "direction": "inout"
         }
     },
@@ -600,17 +543,10 @@ QAOA_LAYER = QuantumFunctionDeclaration.parse_raw(
 QAOA_INIT = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qaoa_init",
-    "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        }
-    },
+    "param_decls": {},
     "port_declarations": {
         "target": {
             "name": "target",
-            "size": {
-                "expr": "num_qubits"
-            },
             "direction": "inout"
         }
     },
@@ -750,6 +686,7 @@ FULL_HEA = QuantumFunctionDeclaration.parse_raw(
 __all__ = [
     "QFT_STEP",
     "QFT",
+    "STANDARD_QPE",
     "QPE",
     "SINGLE_PAULI",
     "LINEAR_PAULI_ROTATIONS",

classiq/interface/generator/generated_circuit.py

@@ -1,8 +1,7 @@
-import abc
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Literal, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -17,9 +16,7 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
     VENDOR_TO_INSTRUCTION_SET,
     CodeAndSyntax,
 )
-from classiq.interface.generator.function_params import ArithmeticIODict
 from classiq.interface.generator.generated_circuit_data import (
-    ExecutionCircuitData,
     FunctionDebugInfo,
     GeneratedCircuitData,
 )
@@ -28,7 +25,6 @@ from classiq.interface.generator.model.model import ExecutionModel, SynthesisMod
 from classiq.interface.generator.synthesis_metadata.synthesis_duration import (
     SynthesisStepDurations,
 )
-from classiq.interface.helpers.pydantic_model_helpers import get_discriminator_field
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.ide.ide_data import CircuitMetrics
 
@@ -55,12 +51,15 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
-class GeneratedCircuitBase(abc.ABC, VersionedModel, CircuitCodeInterface):
+class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    data: Union[GeneratedCircuitData, ExecutionCircuitData]
     initial_values: Optional[InitialConditions]
-    model: Union[SynthesisModel, ExecutionModel]
-
+    data: GeneratedCircuitData
+    model: SynthesisModel
+    transpiled_circuit: Optional[TranspiledCircuitData]
+    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
+    synthesis_duration: Optional[SynthesisStepDurations]
+    debug_info: Optional[List[FunctionDebugInfo]]
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
@@ -135,41 +134,6 @@ class GeneratedCircuitBase(abc.ABC, VersionedModel, CircuitCodeInterface):
             for name, init_value in initial_values.items()
         }
 
-    @property
-    @abc.abstractmethod
-    def program_circuit(self) -> CircuitCodeInterface:
-        pass
-
-    @property
-    @abc.abstractmethod
-    def execution_model(self) -> ExecutionModel:
-        pass
-
-
-class ExecutionCircuit(GeneratedCircuitBase):
-    circuit_type: Literal["execution"] = get_discriminator_field("execution")
-    data: ExecutionCircuitData
-    model: ExecutionModel
-    arithmetic_outputs: ArithmeticIODict = dict()
-
-    @property
-    def program_circuit(self) -> CircuitCodeInterface:
-        return self
-
-    @property
-    def execution_model(self) -> ExecutionModel:
-        return self.model
-
-
-class GeneratedCircuit(GeneratedCircuitBase):
-    circuit_type: Literal["generated"] = get_discriminator_field("generated")
-    data: GeneratedCircuitData
-    model: SynthesisModel
-    transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
-    synthesis_duration: Optional[SynthesisStepDurations]
-    debug_info: List[FunctionDebugInfo]
-
     def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
         """
         Saves generated circuit results as json.

classiq/interface/generator/generated_circuit_data.py

@@ -83,26 +83,17 @@ class GeneratedFunction(pydantic.BaseModel):
         )
 
 
-class CircuitDataBase(pydantic.BaseModel):
+class GeneratedCircuitData(pydantic.BaseModel):
     width: int
     circuit_parameters: List[ParameterName] = pydantic.Field(default_factory=list)
     qubit_mapping: QubitMapping = pydantic.Field(default_factory=QubitMapping)
     execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
 
     @classmethod
-    def from_empty_logic_flow(cls) -> "CircuitDataBase":
+    def from_empty_logic_flow(cls) -> "GeneratedCircuitData":
         return cls(width=0)
 
 
-class ExecutionCircuitData(CircuitDataBase):
-    depth: Optional[int]
-    count_ops: Optional[Dict[str, int]]
-
-
-class GeneratedCircuitData(CircuitDataBase):
-    pass
-
-
 class FunctionDebugInfo(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction]
     children: List[Optional["FunctionDebugInfo"]]

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

@@ -65,6 +65,8 @@ class TranspilationOption(StrEnum):
     AUTO_OPTIMIZE = "auto optimize"
     LIGHT = "light"
     MEDIUM = "medium"
+    INTENSIVE = "intensive"
+    CUSTOM = "custom"
 
     def __bool__(self) -> bool:
         return self != TranspilationOption.NONE
@@ -89,9 +91,9 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         description="Custom hardware settings which will be used during optimization. "
         "This field is ignored if backend preferences are given.",
     )
-    support_circuit_visualization: bool = pydantic.Field(
+    debug_mode: bool = pydantic.Field(
         default=True,
-        description="Support visualizing the circuit via the IDE. "
+        description="Add debug information to the synthesized result. "
         "Setting this option to False can potentially speed up the synthesis, and is "
         "recommended for executing iterative algorithms.",
     )

classiq/interface/generator/quantum_function_call.py

@@ -79,7 +79,7 @@ class WirePair(HashablePydanticBaseModel):
     out_wire: WireName
 
 
-SUFFIX_RANDOMIZER = random.Random()
+SUFFIX_RANDOMIZER = random.Random()  # nosec B311
 
 
 def split_wire_pair_to_wires(

classiq/interface/hardware.py

@@ -13,6 +13,8 @@ class Provider(StrEnum):
     IONQ = "IonQ"
     CLASSIQ = "Classiq"
     GOOGLE = "Google"
+    ALICE_AND_BOB = "Alice and Bob"
+    OQC = "OQC"
 
     @property
     def id(self):

classiq/interface/ide/show.py

@@ -1,10 +1,8 @@
 import re
-from typing import Union
 
 import pydantic
 
 from classiq.interface.analyzer.result import QasmCode
-from classiq.interface.generator.generated_circuit import ExecutionCircuit
 
 from classiq import GeneratedCircuit
 from classiq._internals.api_wrapper import ApiWrapper
@@ -26,22 +24,11 @@ qasm_show_interactive = syncify_function(qasm_show_interactive_async)
 CANT_PARSE_QUANTUM_PROGRAM_MSG = (
     "Can not parse quantum_program into GeneratedCircuit, \n"
 )
-CANT_SHOW_EXECUTION_CIRCUIT_MSG = (
-    "It looks like the flag `support_circuit_visualization` in the model preferences "
-    "has been turned off. \n"
-    "The resulting circuit does not support visualization. \n"
-    "Make sure to set the flag to True, the default setting, and try again."
-)
-_Circuit = Union[GeneratedCircuit, ExecutionCircuit]
 
 
 def show(quantum_program: SerializedQuantumProgram) -> None:
     try:
         circuit = GeneratedCircuit.parse_raw(quantum_program)
     except pydantic.error_wrappers.ValidationError as exc:
-        try:
-            ExecutionCircuit.parse_raw(quantum_program)
-            raise ClassiqValueError(CANT_SHOW_EXECUTION_CIRCUIT_MSG) from None
-        except pydantic.error_wrappers.ValidationError:
-            raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
+        raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
     circuit.show()  # type: ignore[attr-defined]

classiq/interface/model/bind_operation.py

@@ -1,8 +1,12 @@
 from typing import Mapping
 
+import pydantic
+
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
+from classiq.exceptions import ClassiqValueError
+
 BIND_INPUT_NAME = "bind_input"
 BIND_OUTPUT_NAME = "bind_output"
 
@@ -18,3 +22,9 @@ class BindOperation(QuantumOperation):
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {BIND_OUTPUT_NAME: self.out_handle}
+
+    @pydantic.validator("in_handle", "out_handle")
+    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
+        if not handle.is_bindable():
+            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
+        return handle

classiq/interface/model/handle_binding.py

@@ -10,6 +10,12 @@ class HandleBinding(BaseModel):
         frozen = True
         extra = Extra.forbid
 
+    def __str__(self) -> str:
+        return self.name
+
+    def is_bindable(self) -> bool:
+        return True
+
 
 class SubscriptHandleBinding(HandleBinding):
     index: Expression
@@ -18,6 +24,12 @@ class SubscriptHandleBinding(HandleBinding):
         frozen = True
         extra = Extra.forbid
 
+    def __str__(self) -> str:
+        return f"{self.name}[{self.index}]"
+
+    def is_bindable(self) -> bool:
+        return False
+
 
 class SlicedHandleBinding(HandleBinding):
     start: Expression
@@ -26,3 +38,9 @@ class SlicedHandleBinding(HandleBinding):
     class Config:
         frozen = True
         extra = Extra.forbid
+
+    def __str__(self) -> str:
+        return f"{self.name}[{self.start}:{self.end}]"
+
+    def is_bindable(self) -> bool:
+        return False

classiq/interface/model/model.py

@@ -54,8 +54,8 @@ TYPE_NAME_CONFLICT_USER = (
 )
 
 
-def _create_default_functions() -> List[NativeFunctionDefinition]:
-    return [NativeFunctionDefinition(name=MAIN_FUNCTION_NAME)]
+def _create_empty_main_function() -> NativeFunctionDefinition:
+    return NativeFunctionDefinition(name=MAIN_FUNCTION_NAME)
 
 
 class VersionedSerializedModel(VersionedModel):
@@ -71,7 +71,7 @@ class Model(VersionedModel):
 
     # Must be validated before logic_flow
     functions: List[NativeFunctionDefinition] = pydantic.Field(
-        default_factory=_create_default_functions,
+        default_factory=list,
         description="The user-defined custom type library.",
     )
 
@@ -119,6 +119,15 @@ class Model(VersionedModel):
     def function_dict(self) -> Dict[str, QuantumFunctionDeclaration]:
         return nameables_to_dict(self.functions)
 
+    @pydantic.validator("functions", always=True)
+    def _add_empty_main(
+        cls, functions: List[NativeFunctionDefinition]
+    ) -> List[NativeFunctionDefinition]:
+        function_dict = nameables_to_dict(functions)
+        if MAIN_FUNCTION_NAME not in function_dict:
+            functions.append(_create_empty_main_function())
+        return functions
+
     @pydantic.root_validator()
     def validate_static_correctness(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         functions: Optional[List[QuantumFunctionDeclaration]] = values.get("functions")

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -40,7 +40,8 @@ class AmplitudeLoadingOperation(QuantumExpressionOperation):
     ) -> Mapping[
         str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
     ]:
-        assert len(self.var_handles) > 0
+        if len(self.var_handles) == 0:
+            return dict()
         return {AMPLITUDE_IO_NAME: self.var_handles[0]}
 
     def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -24,7 +24,9 @@ class ArithmeticOperation(QuantumExpressionOperation):
 
     def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:
         super().initialize_var_types(var_types)
-        self._result_type = compute_arithmetic_result_type(self.expr_str, var_types)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types
+        )
 
     @property
     def wiring_inouts(

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -4,6 +4,7 @@ from typing import Dict, List, Mapping, Optional, Set, Union
 
 import pydantic
 
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
@@ -30,12 +31,13 @@ class VarRefCollector(ast.NodeVisitor):
 
 
 class QuantumExpressionOperation(QuantumOperation):
-    expr_str: str = pydantic.Field(
-        description="The expression in terms of quantum variables"
-    )
+    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,
     )
@@ -45,9 +47,10 @@ class QuantumExpressionOperation(QuantumOperation):
 
     @property
     def var_handles(self) -> List[HandleBinding]:
-        vrc = VarRefCollector()
-        vrc.visit(ast.parse(self.expr_str))
-        return [HandleBinding(name=name) for name in vrc.var_names]
+        return self._var_handles
+
+    def set_var_handles(self, var_handles: List[HandleBinding]) -> None:
+        self._var_handles = var_handles
 
     @property
     def var_types(self) -> Dict[str, QuantumType]: