classiq 0.32.1__py3-none-any.whl → 0.34.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,17 +22,10 @@ QFT_STEP = QuantumFunctionDeclaration.parse_raw(
 QFT = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qft",
-    "param_decls": {
-        "num_qbits": {
-            "kind": "int"
-        }
-    },
+    "param_decls": {},
     "port_declarations": {
-        "qbv": {
-            "name": "qbv",
-            "size": {
-                "expr": "num_qbits"
-            },
+        "target": {
+            "name": "target",
             "direction": "inout"
         }
     },
@@ -52,41 +38,22 @@ QPE = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "qpe",
     "param_decls": {
-        "reg_size": {
-            "kind": "int"
-        },
-        "qpe_reg_size": {
+        "precision": {
             "kind": "int"
         }
     },
     "port_declarations": {
-        "x": {
-            "name": "x",
+        "phase": {
+            "name": "phase",
             "size": {
-                "expr": "reg_size"
+                "expr": "precision"
             },
-            "direction": "inout"
-        },
-        "q": {
-            "name": "q",
-            "size": {
-                "expr": "qpe_reg_size"
-            },
-            "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 +64,6 @@ SINGLE_PAULI = QuantumFunctionDeclaration.parse_raw(
     """{
     "name": "single_pauli",
     "param_decls": {
-        "reg_size": {
-            "kind": "int"
-        },
         "slope": {
             "kind": "real"
         },
@@ -110,9 +74,6 @@ SINGLE_PAULI = QuantumFunctionDeclaration.parse_raw(
     "port_declarations": {
         "x": {
             "name": "x",
-            "size": {
-                "expr": "reg_size"
-            },
             "direction": "inout"
         },
         "q": {
@@ -150,12 +111,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 +133,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"
         }
     },
@@ -377,20 +326,13 @@ GROVER_OPERATOR = QuantumFunctionDeclaration.parse_raw(
 }"""
 )
 
-UNIFORM_SUPERPOSITION = QuantumFunctionDeclaration.parse_raw(
+HADAMARD_TRANSFORM = QuantumFunctionDeclaration.parse_raw(
     """{
-    "name": "uniform_superposition",
-    "param_decls": {
-        "num_qubits": {
-            "kind": "int"
-        }
-    },
+    "name": "hadamard_transform",
+    "param_decls": {},
     "port_declarations": {
-        "q": {
-            "name": "q",
-            "size": {
-                "expr": "num_qubits"
-            },
+        "target": {
+            "name": "target",
             "direction": "inout"
         }
     },
@@ -402,17 +344,10 @@ UNIFORM_SUPERPOSITION = 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"
         }
     },
@@ -499,6 +434,229 @@ PREPARE_INT = QuantumFunctionDeclaration.parse_raw(
 }"""
 )
 
+QAOA_MIXER_LAYER = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qaoa_mixer_layer",
+    "param_decls": {
+        "b": {
+            "kind": "real"
+        }
+    },
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+QAOA_COST_LAYER = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qaoa_cost_layer",
+    "param_decls": {
+        "g": {
+            "kind": "real"
+        },
+        "hamiltonian": {
+            "kind": "list",
+            "element_type": {
+                "kind": "struct_instance",
+                "name": "PauliTerm"
+            }
+        },
+        "is_st": {
+            "kind": "bool"
+        }
+    },
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+QAOA_LAYER = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qaoa_layer",
+    "param_decls": {
+        "g": {
+            "kind": "real"
+        },
+        "b": {
+            "kind": "real"
+        },
+        "hamiltonian": {
+            "kind": "list",
+            "element_type": {
+                "kind": "struct_instance",
+                "name": "PauliTerm"
+            }
+        },
+        "is_st": {
+            "kind": "bool"
+        }
+    },
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+QAOA_INIT = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qaoa_init",
+    "param_decls": {},
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+QAOA_PENALTY = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "qaoa_penalty",
+    "param_decls": {
+        "num_qubits": {
+            "kind": "int"
+        },
+        "params_list": {
+            "kind": "list",
+            "element_type": {
+                "kind": "real"
+            }
+        },
+        "hamiltonian": {
+            "kind": "list",
+            "element_type": {
+                "kind": "struct_instance",
+                "name": "PauliTerm"
+            }
+        },
+        "is_st": {
+            "kind": "bool"
+        }
+    },
+    "port_declarations": {
+        "target": {
+            "name": "target",
+            "size": {
+                "expr": "num_qubits"
+            },
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {},
+    "positional_arg_declarations": []
+}"""
+)
+
+FULL_HEA = QuantumFunctionDeclaration.parse_raw(
+    """{
+    "name": "full_hea",
+    "param_decls": {
+        "num_qubits": {
+            "kind": "int"
+        },
+        "is_parametrized": {
+            "kind": "list",
+            "element_type": {
+                "kind": "int"
+            }
+        },
+        "angle_params": {
+            "kind": "list",
+            "element_type": {
+                "kind": "real"
+            }
+        },
+        "connectivity_map": {
+            "kind": "list",
+            "element_type": {
+                "kind": "list",
+                "element_type": {
+                    "kind": "int"
+                }
+            }
+        },
+        "reps": {
+            "kind": "int"
+        }
+    },
+    "port_declarations": {
+        "x": {
+            "name": "x",
+            "size": {
+                "expr": "num_qubits"
+            },
+            "direction": "inout"
+        }
+    },
+    "operand_declarations": {
+        "operands_1qubit": {
+            "name": "operands_1qubit",
+            "param_decls": {
+                "angle": {
+                    "kind": "real"
+                }
+            },
+            "port_declarations": {
+                "q": {
+                    "name": "q",
+                    "size": {
+                        "expr": "1"
+                    },
+                    "direction": "inout"
+                }
+            },
+            "is_list": true
+        },
+        "operands_2qubit": {
+            "name": "operands_2qubit",
+            "param_decls": {
+                "angle": {
+                    "kind": "real"
+                }
+            },
+            "port_declarations": {
+                "q1": {
+                    "name": "q1",
+                    "size": {
+                        "expr": "1"
+                    },
+                    "direction": "inout"
+                },
+                "q2": {
+                    "name": "q2",
+                    "size": {
+                        "expr": "1"
+                    },
+                    "direction": "inout"
+                }
+            },
+            "is_list": true
+        }
+    },
+    "positional_arg_declarations": []
+}"""
+)
+
 __all__ = [
     "QFT_STEP",
     "QFT",
@@ -509,8 +667,14 @@ __all__ = [
     "SIMPLE_ORACLE",
     "GROVER_DIFFUSER",
     "GROVER_OPERATOR",
-    "UNIFORM_SUPERPOSITION",
+    "HADAMARD_TRANSFORM",
     "APPLY_TO_ALL",
     "GROVER_SEARCH",
     "PREPARE_INT",
+    "QAOA_MIXER_LAYER",
+    "QAOA_COST_LAYER",
+    "QAOA_LAYER",
+    "QAOA_INIT",
+    "QAOA_PENALTY",
+    "FULL_HEA",
 ]

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

@@ -23,24 +23,7 @@ REPEAT_OPERATOR = QuantumFunctionDeclaration(
 
 INVERT_OPERATOR = QuantumFunctionDeclaration(
     name="invert",
-    port_declarations={
-        "target": PortDeclaration(
-            name="target",
-            direction=PortDeclarationDirection.Inout,
-        ),
-    },
-    operand_declarations={
-        "operand": QuantumOperandDeclaration(
-            name="operand",
-            port_declarations={
-                "target": PortDeclaration(
-                    name="target",
-                    direction=PortDeclarationDirection.Inout,
-                    size=Expression(expr="len(target)"),
-                )
-            },
-        ),
-    },
+    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
 )
 
 
@@ -50,24 +33,9 @@ CONTROL_OPERATOR = QuantumFunctionDeclaration(
         "ctrl": PortDeclaration(
             name="ctrl",
             direction=PortDeclarationDirection.Inout,
-        ),
-        "target": PortDeclaration(
-            name="target",
-            direction=PortDeclarationDirection.Inout,
-        ),
-    },
-    operand_declarations={
-        "operand": QuantumOperandDeclaration(
-            name="operand",
-            port_declarations={
-                "target": PortDeclaration(
-                    name="target",
-                    direction=PortDeclarationDirection.Inout,
-                    size=Expression(expr="len(target)"),
-                )
-            },
         )
     },
+    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
 )
 
 IF_OPERATOR = QuantumFunctionDeclaration(
@@ -138,28 +106,11 @@ PERMUTE_OPERATOR = QuantumFunctionDeclaration(
 POWER_OPERATOR = QuantumFunctionDeclaration(
     name="power",
     param_decls={"power": Integer()},
-    port_declarations={
-        "qbv": PortDeclaration(
-            name="qbv",
-            direction=PortDeclarationDirection.Inout,
-        )
-    },
-    operand_declarations={
-        "operand": QuantumOperandDeclaration(
-            name="operand",
-            port_declarations={
-                "qbv": PortDeclaration(
-                    name="qbv",
-                    direction=PortDeclarationDirection.Inout,
-                    size=Expression(expr="len(qbv)"),
-                )
-            },
-        )
-    },
+    operand_declarations={"operand": QuantumOperandDeclaration(name="operand")},
 )
 
 
-_BUILTIN_QUANTUM_OPERATOR_LIST = [
+BUILTIN_QUANTUM_OPERATOR_LIST = [
     REPEAT_OPERATOR,
     INVERT_OPERATOR,
     CONTROL_OPERATOR,
@@ -173,5 +124,5 @@ _BUILTIN_QUANTUM_OPERATOR_LIST = [
 
 
 QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.update(
-    nameables_to_dict(_BUILTIN_QUANTUM_OPERATOR_LIST)
+    nameables_to_dict(BUILTIN_QUANTUM_OPERATOR_LIST)
 )

classiq/interface/generator/generated_circuit.py

@@ -1,7 +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
@@ -16,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,
 )
@@ -27,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
 
@@ -50,11 +47,20 @@ class TranspiledCircuitData(CircuitCodeInterface):
         return CircuitMetrics(depth=self.depth, count_ops=self.count_ops)
 
 
-class GeneratedCircuitBase(abc.ABC, VersionedModel, CircuitCodeInterface):
+def get_uuid_as_str() -> str:
+    return str(uuid.uuid4())
+
+
+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:
         circuit_code = self.program_circuit.get_code_by_priority()
@@ -128,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

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -13,6 +13,22 @@ ParameterName = str
 IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
 
 
+CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
+
+VISUALIZATION_HIDE_LIST = [
+    "apply_to_all",
+    "repeat",
+    "control",
+    "mcx",
+    "iteration",
+    "operand",
+]
+
+
+def last_name_in_call_hierarchy(name: str) -> str:
+    return name.split(CLASSIQ_HIERARCHY_SEPARATOR)[-1]
+
+
 class QubitMapping(pydantic.BaseModel):
     logical_inputs: IOQubitMapping = pydantic.Field(default_factory=dict)
     logical_outputs: IOQubitMapping = pydantic.Field(default_factory=dict)
@@ -59,49 +75,25 @@ class GeneratedFunction(pydantic.BaseModel):
         except KeyError:
             return None
 
+    @property
+    def should_appear_in_visualization(self) -> bool:
+        return all(
+            hide_regex not in last_name_in_call_hierarchy(self.name.lower())
+            for hide_regex in VISUALIZATION_HIDE_LIST
+        )
+
 
-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):
-    generated_functions: List[GeneratedFunction] = pydantic.Field(default_factory=list)
-
-    def __len__(self) -> int:
-        return self.generated_functions.__len__()
-
-    def __iter__(self):
-        yield from self.generated_functions
-
-    def pprint(self) -> None:
-        print("Circuit Synthesis Metrics")
-        print(f"The circuit has {len(self.generated_functions)} functions:")
-        for index, fm in enumerate(self.generated_functions):
-            print(f"{index}) {fm.name}")
-            print(
-                f"  depth: {fm.depth} ; "
-                f"width: {fm.width} ; "
-                f"registers: {len(fm.registers)}"
-            )
-            for reg_index, register in enumerate(fm.registers):
-                print(
-                    f"  {reg_index}) {register.role.value} - {register.name} ; "
-                    f"qubits: {register.qubit_indexes_absolute}"
-                )
-
-
 class FunctionDebugInfo(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction]
     children: List[Optional["FunctionDebugInfo"]]