classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/model/quantum_type.py

@@ -1,24 +1,32 @@
-from typing import Any, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import Extra
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
 
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import (
     RegisterArithmeticInfo,
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQBitProxy,
+    QmodQNumProxy,
+    QmodQScalarProxy,
 )
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
-from classiq.exceptions import ClassiqValueError
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 
 
-class QuantumType(HashablePydanticBaseModel):
-    class Config:
-        extra = Extra.forbid
+class QuantumType(HashableASTNode):
+    model_config = ConfigDict(extra="forbid")
 
     _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
 
@@ -40,112 +48,232 @@ class QuantumType(HashablePydanticBaseModel):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
+    def get_proxy(self, handle: "HandleBinding") -> QmodSizedProxy:
+        return QmodSizedProxy(handle=handle, size=self.size_in_bits)
 
-class QuantumBit(QuantumType):
+    @property
+    def qmod_type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def is_instantiated(self) -> bool:
+        raise NotImplementedError
+
+    @property
+    def is_evaluated(self) -> bool:
+        raise NotImplementedError
+
+
+class QuantumScalar(QuantumType):
+    def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
+        return QmodQScalarProxy(handle, size=self.size_in_bits)
+
+
+class QuantumBit(QuantumScalar):
     kind: Literal["qbit"]
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._size_in_bits = 1
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "qbit")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "QBit"
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQBitProxy:
+        return QmodQBitProxy(handle)
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
+
+    @property
+    def is_instantiated(self) -> bool:
+        return True
 
-class QuantumArray(QuantumType):
-    length: Optional[Expression]
+    @property
+    def is_evaluated(self) -> bool:
+        return True
 
 
-class QuantumBitvector(QuantumArray):
+class QuantumBitvector(QuantumType):
+    element_type: "ConcreteQuantumType" = Field(
+        discriminator="kind", default_factory=QuantumBit
+    )
     kind: Literal["qvec"]
+    length: Optional[Expression] = Field(default=None)
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "qvec")
 
     def _update_size_in_bits_from_declaration(self) -> None:
-        if self.length is not None and self.length.is_evaluated():
-            self._size_in_bits = self.length.to_int_value()
+        self.element_type._update_size_in_bits_from_declaration()
+        if self.element_type.has_size_in_bits and self.has_length:
+            assert self.length is not None
+            self._size_in_bits = (
+                self.element_type.size_in_bits * self.length.to_int_value()
+            )
 
+    @property
+    def has_length(self) -> bool:
+        return self.length is not None and self.length.is_evaluated()
 
-class QuantumNumeric(QuantumType):
-    size: Optional[Expression] = pydantic.Field()
-    kind: str = pydantic.Field()
+    @property
+    def length_value(self) -> int:
+        if not self.has_length:
+            raise ClassiqValueError(
+                "Tried to access unevaluated length of quantum array"
+            )
+        assert self.length is not None
+        return self.length.to_int_value()
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQArrayProxy:
+        element_size = self.element_type.size_in_bits
+        assert self.size_in_bits % element_size == 0
+        return QmodQArrayProxy(
+            handle,
+            self.element_type,
+            element_size,
+            self.size_in_bits // element_size,
+        )
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qnum")
+    @property
+    def qmod_type_name(self) -> str:
+        element_type = [self.element_type.qmod_type_name]
+        length = [self.length.expr] if self.length is not None else []
+        return f"QArray[{', '.join(element_type + length)}]"
 
-    _is_signed: bool = pydantic.PrivateAttr(default=False)
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
 
-    _fraction_digits: int = pydantic.PrivateAttr(default=0)
+    @property
+    def is_instantiated(self) -> bool:
+        return self.length is not None and self.element_type.is_instantiated
 
     @property
-    def size_in_bits_expr(self) -> Optional[Expression]:
-        return self.size
+    def is_evaluated(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.element_type.is_evaluated
+        )
+
+
+class QuantumNumeric(QuantumScalar):
+    kind: Literal["qnum"]
+
+    size: Optional[Expression] = pydantic.Field(default=None)
+    is_signed: Optional[Expression] = pydantic.Field(default=None)
+    fraction_digits: Optional[Expression] = pydantic.Field(default=None)
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(values, "kind", "qnum")
+
+    @pydantic.model_validator(mode="after")
+    def _validate_fields(self) -> Self:
+        has_sign = self.is_signed is not None
+        has_fraction_digits = self.fraction_digits is not None
+        if (has_sign and not has_fraction_digits) or (
+            not has_sign and has_fraction_digits
+        ):
+            raise ClassiqValueError(
+                "Assign neither or both of is_signed and fraction_digits"
+            )
+        return self
 
     @property
-    def is_signed(self) -> bool:
-        return self._is_signed
+    def has_sign(self) -> bool:
+        return self.is_signed is not None
 
-    def set_signed(self, val: bool) -> None:
-        self._is_signed = val
+    @property
+    def sign_value(self) -> bool:
+        return False if self.is_signed is None else self.is_signed.to_bool_value()
 
     @property
-    def fraction_digits(self) -> int:
-        return self._fraction_digits
+    def has_fraction_digits(self) -> bool:
+        return self.fraction_digits is not None
 
-    def set_fraction_digits(self, val: int) -> None:
-        self._fraction_digits = val
+    @property
+    def fraction_digits_value(self) -> int:
+        return (
+            0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
+        )
 
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
 
+    def get_proxy(self, handle: "HandleBinding") -> QmodQNumProxy:
+        return QmodQNumProxy(
+            handle,
+            size=self.size_in_bits,
+            fraction_digits=self.fraction_digits_value,
+            is_signed=self.sign_value,
+        )
 
-class QuantumInteger(QuantumNumeric):
-    kind: Literal["qint"]
+    @property
+    def qmod_type_name(self) -> str:
+        if (
+            self.size is not None
+            and self.is_signed is not None
+            and self.fraction_digits is not None
+        ):
+            return f"QNum[{self.size.expr}, {self.is_signed.expr}, {self.fraction_digits.expr}]"
+        return "QNum"
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qint")
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
 
+    @property
+    def is_instantiated(self) -> bool:
+        return self.size is not None
 
-class QuantumFixedReal(QuantumNumeric):
-    fraction_places: Expression = pydantic.Field()
+    @property
+    def is_evaluated(self) -> bool:
+        if self.size is None or not self.size.is_evaluated():
+            return False
+        if self.is_signed is not None and not self.is_signed.is_evaluated():
+            return False
+        return not (
+            self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
+        )
 
-    kind: Literal["qfixed"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "qfixed")
+class RegisterQuantumType(BaseModel):
+    quantum_types: "ConcreteQuantumType"
+    size: int = Field(default=1)
 
     @property
-    def fraction_digits(self) -> int:
-        return self.fraction_places.to_int_value()
-
-    def set_fraction_digits(self, val: int) -> None:
-        if val != self.fraction_places.to_int_value():
-            raise ClassiqValueError(
-                "Cannot assign value of fixed-point number with incompatible fraction digits"
-            )
+    def qmod_type_name(self) -> str:
+        try:
+            return self.quantum_types.qmod_type_name.split("[")[0]
+        except AttributeError:
+            return "default"
 
 
-ConcreteQuantumType = Union[
-    QuantumBit,
-    QuantumBitvector,
-    QuantumNumeric,
-    QuantumInteger,
-    QuantumFixedReal,
-]
+RegisterQuantumTypeDict = dict[str, RegisterQuantumType]
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:
     result = QuantumNumeric()
     result.set_size_in_bits(reg_info.size)
-    result.set_signed(reg_info.is_signed)
-    result.set_fraction_digits(reg_info.fraction_places)
+    result.is_signed = Expression(expr=str(reg_info.is_signed))
+    result.fraction_digits = Expression(expr=str(reg_info.fraction_places))
     return result
 
 
@@ -153,10 +281,11 @@ UNRESOLVED_SIZE = 1000
 
 
 def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
-    signed = qtype.is_signed if isinstance(qtype, QuantumNumeric) else False
-    if isinstance(qtype, (QuantumFixedReal, QuantumNumeric)):
-        fraction_places = qtype.fraction_digits
+    if isinstance(qtype, QuantumNumeric):
+        signed = qtype.sign_value
+        fraction_places = qtype.fraction_digits_value
     else:
+        signed = False
         fraction_places = 0
     return RegisterUserInput(
         name=name,
@@ -164,3 +293,12 @@ def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
         is_signed=signed,
         fraction_places=fraction_places,
     )
+
+
+def quantum_type_to_register_quantum_type(
+    qtype: QuantumType, size: int
+) -> RegisterQuantumType:
+    return RegisterQuantumType(
+        quantum_types=qtype,
+        size=size,
+    )

classiq/interface/model/quantum_variable_declaration.py

@@ -1,29 +1,7 @@
-from typing import Any, Mapping, Optional
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 
-import pydantic
-from pydantic import BaseModel
 
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.quantum_type import (
-    ConcreteQuantumType,
-    QuantumBitvector,
-    QuantumNumeric,
-)
-
-
-class QuantumVariableDeclaration(BaseModel):
+class QuantumVariableDeclaration(ASTNode):
     name: str
-    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
-    size: Optional[Expression] = pydantic.Field(default=None)
-
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        if size is not None:
-            quantum_type = values.get("quantum_type")
-            if isinstance(quantum_type, QuantumBitvector):
-                quantum_type.length = size
-            elif isinstance(quantum_type, QuantumNumeric):
-                quantum_type.size = size
-        return size
+    quantum_type: ConcreteQuantumType

classiq/interface/model/repeat.py

@@ -0,0 +1,15 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Repeat(QuantumOperation):
+    kind: Literal["Repeat"]
+
+    iter_var: str
+    count: Expression
+    body: "StatementBlock"

classiq/interface/model/statement_block.py

@@ -0,0 +1,58 @@
+from typing import Annotated, Union
+
+from pydantic import Field
+
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+ConcreteQuantumStatement = Annotated[
+    Union[
+        Allocate,
+        QuantumFunctionCall,
+        ArithmeticOperation,
+        AmplitudeLoadingOperation,
+        VariableDeclarationStatement,
+        BindOperation,
+        InplaceBinaryOperation,
+        Repeat,
+        Power,
+        Invert,
+        ClassicalIf,
+        Control,
+        WithinApply,
+        PhaseOperation,
+    ],
+    Field(..., discriminator="kind"),
+]
+
+StatementBlock = list[ConcreteQuantumStatement]
+
+Control.model_rebuild()
+QuantumLambdaFunction.model_rebuild()
+Repeat.model_rebuild()
+Power.model_rebuild()
+Invert.model_rebuild()
+WithinApply.model_rebuild()
+ClassicalIf.model_rebuild()
+NativeFunctionDefinition.model_rebuild()
+PhaseOperation.model_rebuild()

classiq/interface/model/validation_handle.py

@@ -1,27 +1,34 @@
 import dataclasses
+from collections.abc import Mapping
 from enum import Enum
-from typing import List, Mapping, Optional, Set
+from typing import Optional
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.handle_binding import HandleBinding
 
-from classiq.exceptions import ClassiqError
-
 
 class HandleState(Enum):
     INITIALIZED = 0
     UNINITIALIZED = 1
     ERRORED = 2
 
+    def __invert__(self) -> "HandleState":
+        if self == HandleState.INITIALIZED:
+            return HandleState.UNINITIALIZED
+        if self == HandleState.UNINITIALIZED:
+            return HandleState.INITIALIZED
+        return self
+
 
 @dataclasses.dataclass
 class ValidationHandle:
     _state: HandleState
-    errors: List[str] = dataclasses.field(default_factory=list)
+    errors: list[str] = dataclasses.field(default_factory=list)
 
     def __init__(
         self,
         initial_state: Optional[HandleState] = None,
-        errors: Optional[List[str]] = None,
+        errors: Optional[list[str]] = None,
     ) -> None:
         if initial_state is None and not errors:
             raise ClassiqError("Missing initial state for ValidationHandle")
@@ -44,5 +51,5 @@ class ValidationHandle:
         self._state = HandleState.UNINITIALIZED
 
 
-def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> Set[str]:
+def get_unique_handle_names(io_dict: Mapping[str, HandleBinding]) -> set[str]:
     return {handle_binding.name for handle_binding in io_dict.values()}

classiq/interface/model/variable_declaration_statement.py

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -5,4 +7,4 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
-    pass
+    kind: Literal["VariableDeclarationStatement"]

classiq/interface/model/within_apply_operation.py

@@ -0,0 +1,13 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class WithinApply(QuantumOperation):
+    kind: Literal["WithinApply"]
+
+    compute: "StatementBlock"
+    action: "StatementBlock"

classiq/interface/pyomo_extension/pyomo_sympy_bimap.py

@@ -1,10 +1,13 @@
+from typing import Any
+
 import sympy
 from pyomo.core.base import _GeneralVarData
+from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 
 
 # This code is a pure copy paste from pyomo.core.expr.sympy_tools.PyomoSympyBimap.getSympySymbol
 # except one line.
-def get_sympy_symbol(self, pyomo_object):
+def get_sympy_symbol(self: PyomoSympyBimap, pyomo_object: Any) -> sympy.Symbol:
     if pyomo_object in self.pyomo2sympy:
         return self.pyomo2sympy[pyomo_object]
     # Pyomo currently ONLY supports Real variables (not complex

classiq/interface/server/global_versions.py

@@ -1,15 +1,14 @@
-from datetime import datetime
-from typing import Any, Dict
+from datetime import date
+from typing import Any
 
-import pydantic
 from pydantic import BaseModel
 
 
 class DeprecationInfo(BaseModel):
-    deprecation_date: datetime = pydantic.Field()
-    removal_date: datetime = pydantic.Field()
+    deprecation_date: date
+    removal_date: date
 
 
 class GlobalVersions(BaseModel):
-    deprecated: Dict[str, DeprecationInfo] = pydantic.Field()
-    deployed: Dict[str, Any] = pydantic.Field()
+    deprecated: dict[str, DeprecationInfo]
+    deployed: dict[str, Any]

classiq/interface/server/routes.py

@@ -1,8 +1,11 @@
 ANALYZER_PREFIX = "/analyzer"
 CHEMISTRY_PREFIX = "/chemistry"
-LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
+EXECUTION_SESSIONS_PREFIX = EXECUTION_PREFIX + "/sessions"
 CONVERSION_PREFIX = "/conversion"
+PROVIDERS_PREFIX = "/providers"
+
+IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 
 EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
 SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
@@ -18,21 +21,20 @@ ANALYZER_HC_TABLE_GRAPH_FULL_PATH = ANALYZER_PREFIX + ANALYZER_HC_TABLE_GRAPH
 
 ANALYZER_HC_GRAPH_NEW = "/graphs/hardware_connectivity/new"
 
-ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
-ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
-
 TASKS_SUFFIX = "/tasks"
-QUANTUM_PROGRAM_SUFFIX = "/quantum_program"
-ESTIMATE_SUFFIX = "/estimate"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"
 ANALYZER_QASM_TASK = f"{TASKS_SUFFIX}/qasm"
+ANALYZER_GET_VISUAL_MODEL = "/get_visual_model"
+ANALYZER_GET_IDE_DATA = "/get_ide_data"
 IDE_EVENT_TASK = f"{TASKS_SUFFIX}/event"
 DATA_DOG_EVENT_TASK = f"{TASKS_SUFFIX}/data_dog_event"
 
 ANALYZER_DATA_TASK_UPLOAD_FILE = f"{TASKS_SUFFIX}/data/file_upload"
 ANALYZER_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_DATA_TASK}"
 ANALYZER_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_QASM_TASK}"
+ANALYZER_GET_VISUAL_MODEL_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_VISUAL_MODEL}"
+ANALYZER_GET_IDE_DATA_FULL_PATH = f"{ANALYZER_PREFIX}{ANALYZER_GET_IDE_DATA}"
 IDE_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_EVENT_TASK}"
 DATA_DOG_EVENT_TASK_FULL_PATH = f"{ANALYZER_PREFIX}{DATA_DOG_EVENT_TASK}"
 
@@ -40,9 +42,13 @@ IDE_QASM_TASK = f"{TASKS_SUFFIX}/generated_circuit_from_qasm"
 IDE_QASM_FULL_PATH = f"{ANALYZER_PREFIX}{IDE_QASM_TASK}"
 TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
 TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
+TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
-MODEL_GENERATE_PREFIX = "/generate_model"
-CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"
+
+CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
+GROVER_QMOD_PATH = "/generate_model/grover/qmod"
+FINANCE_QMOD_PATH = "/generate_model/finance/qmod"
+
 
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
@@ -55,8 +61,6 @@ EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
 EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
     EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
 )
-EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
-EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
@@ -65,19 +69,16 @@ GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
 
 GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = (
-    SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
-)
-
-FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
-
-GROVER_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/grover"
-
-QMOD_PREFIX = ANALYZER_PREFIX + "/qmods"
-QMOD_METADATA_PATH = QMOD_PREFIX + "/metadata"
-QMOD_FILE_PATH = QMOD_PREFIX + "/file"
+GENERATE_HAMILTONIAN_FULL_PATH = CHEMISTRY_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
 
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
 )
+
+STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
+
+IQCC_INIT_AUTH_SUFFIX = "/init_auth"
+IQCC_INIT_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_INIT_AUTH_SUFFIX
+IQCC_PROBE_AUTH_SUFFIX = "/probe_auth"
+IQCC_PROBE_AUTH_FULL_PATH = IQCC_PREFIX + IQCC_PROBE_AUTH_SUFFIX