classiq 0.60.1__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -8,7 +8,7 @@ from classiq.qmod.qmod_parameter import CArray, CInt, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -24,7 +24,7 @@ def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: RX(b, target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_cost_layer(
     g: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
@@ -45,7 +45,7 @@ def qaoa_cost_layer(
     suzuki_trotter(hamiltonian, g, 1, 1, target)
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_layer(
     g: CReal, b: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
@@ -69,7 +69,7 @@ def qaoa_layer(
     qaoa_mixer_layer(b, target)
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_init(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -86,7 +86,7 @@ def qaoa_init(target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: H(target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_penalty(
     num_qubits: CInt,
     params_list: CArray[CReal],

classiq/qmod/builtins/functions/qft_functions.py

@@ -5,7 +5,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.symbolic import pi
 
 
-@qfunc(external=True)
+@qfunc
 def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -32,7 +32,7 @@ def qft_no_swap(qbv: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def qft(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/qpe.py

@@ -1,15 +1,15 @@
 from classiq.qmod.builtins.functions.qft_functions import qft
 from classiq.qmod.builtins.functions.standard_gates import H
 from classiq.qmod.builtins.functions.utility_functions import apply_to_all
-from classiq.qmod.builtins.operations import bind, control, invert, power, repeat
+from classiq.qmod.builtins.operations import control, invert, power, repeat
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QNum
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
 
 
-@qfunc(external=True)
-def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
+@qfunc
+def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -20,22 +20,19 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
         unitary_with_power: A callable that returns the unitary operator $U^k$ given an integer $k$. This callable is used to control the application of powers of the unitary operator.
         phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
     """
-    phase_array: QArray = QArray("phase_array")
-    bind(phase, phase_array)
-    apply_to_all(H, phase_array)
+    apply_to_all(H, phase)
 
     repeat(
-        count=phase_array.len,
+        count=phase.len,
         iteration=lambda index: control(
-            ctrl=phase_array[index], stmt_block=lambda: unitary_with_power(2**index)
+            ctrl=phase[index], stmt_block=lambda: unitary_with_power(2**index)
         ),
     )
 
-    invert(lambda: qft(phase_array))
-    bind(phase_array, phase)
+    invert(lambda: qft(phase))
 
 
-@qfunc(external=True)
+@qfunc
 def qpe(unitary: QCallable, phase: QNum) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/qsvt.py

@@ -1,13 +1,13 @@
 from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H
-from classiq.qmod.builtins.operations import if_, invert, repeat
+from classiq.qmod.builtins.operations import control, if_, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic import floor
+from classiq.qmod.symbolic import floor, min as qmin
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt_step(
     phase1: CReal,
     phase2: CReal,
@@ -23,7 +23,7 @@ def qsvt_step(
     Applies a single QSVT step, composed of 2 projector-controlled-phase rotations, and applications of the block encoding unitary `u` and its inverse:
 
     $$
-    \\Pi_{\\phi_2}U^{\\dagger}\tilde{\\Pi}_{\\phi_{1}}U
+    \\Pi_{\\phi_2}U^{\\dagger}\\tilde{\\Pi}_{\\phi_{1}}U
     $$
 
     Args:
@@ -41,7 +41,7 @@ def qsvt_step(
     projector_controlled_phase(phase2, proj_cnot_1, qvar, aux)
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt(
     phase_seq: CArray[CReal],
     proj_cnot_1: QCallable[QArray[QBit], QBit],
@@ -53,17 +53,17 @@ def qsvt(
     """
     [Qmod Classiq-library function]
 
-    Implements the Quantum Singular Value Transformation (QSVT) - an algorithmic framework, used to apply polynomial transformations of degree `d` on the singular values of a block encoded matrix, given as the unitary `u`.    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
-    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
+    Implements the Quantum Singular Value Transformation (QSVT) - an algorithmic framework, used to apply polynomial transformations of degree `d` on the singular values of a block encoded matrix, given as the unitary `u`.    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
+    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
 
     $$
-    \tilde{\\Pi}_{\\phi_{d+1}}U \\prod_{k=1}^{(d-1)/2} (\\Pi_{\\phi_{d-2k}} U^{\\dagger}\tilde{\\Pi}_{\\phi_{d - (2k+1)}}U)\\Pi_{\\phi_{1}}
+    \\tilde{\\Pi}_{\\phi_{d+1}}U \\prod_{k=1}^{(d-1)/2} (\\Pi_{\\phi_{d-2k}} U^{\\dagger}\\tilde{\\Pi}_{\\phi_{d - (2k+1)}}U)\\Pi_{\\phi_{1}}
     $$
 
     for odd $d$, and:
 
     $$
-    \\prod_{k=1}^{d/2} (\\Pi_{\\phi_{d-(2k-1)}} U^{\\dagger}\tilde{\\Pi}_{\\phi_{d-2k}}U)\\Pi_{\\phi_{1}}
+    \\prod_{k=1}^{d/2} (\\Pi_{\\phi_{d-(2k-1)}} U^{\\dagger}\\tilde{\\Pi}_{\\phi_{d-2k}}U)\\Pi_{\\phi_{1}}
     $$
 
     for even $d$.
@@ -111,7 +111,7 @@ def qsvt(
     H(aux)
 
 
-@qfunc(external=True)
+@qfunc
 def projector_controlled_phase(
     phase: CReal,
     proj_cnot: QCallable[QArray[QBit], QBit],
@@ -128,17 +128,15 @@ def projector_controlled_phase(
     $$
 
     Args:
-        phase_seq: A rotation phase.
+        phase: A rotation phase.
         proj_cnot: Projector-controlled-not unitary that sets an auxilliary qubit to |1> when the state is in the projection.
         qvar: The quantum variable to which the rotation applies, which resides in the entire block encoding space.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
     """
-    proj_cnot(qvar, aux)
-    RZ(phase, aux)
-    proj_cnot(qvar, aux)
+    within_apply(lambda: proj_cnot(qvar, aux), lambda: RZ(phase, aux))
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt_inversion(
     phase_seq: CArray[CReal],
     block_encoding_cnot: QCallable[QArray[QBit], QBit],
@@ -167,3 +165,167 @@ def qsvt_inversion(
         qvar,
         aux,
     )
+
+
+@qfunc
+def projector_controlled_double_phase(
+    phase_even: CReal,
+    phase_odd: CReal,
+    proj_cnot: QCallable[QArray[QBit], QBit],
+    qvar: QArray[QBit],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Assigns 2 phases to the entire subspace determined by the given projector, each one is controlled differentely on a given `lcu` qvar.
+    Used in the context of the `qsvt_lcu` function. Corresponds to the operation:
+
+    $$
+    \\Pi_{\\phi_{odd}, \\phi_{even}} = (C_{\\Pi}NOT) (C_{lcu=1}e^{-i\\frac{\\phi_{even}}{2}Z}) (C_{lcu=0}e^{-i\\frac{\\phi_{odd}}{2}Z}) (C_{\\Pi}NOT)
+    $$
+
+    Args:
+        phase_even: Rotation phase, corresponds to 'lcu'=1.
+        phase_odd: Rotation phase, corresponds to 'lcu'=0.
+        proj_cnot: Projector-controlled-not unitary that sets an auxilliary qubit to |1> when the state is in the projection.
+        qvar: The quantum variable to which the rotation applies, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+    """
+    within_apply(
+        lambda: proj_cnot(qvar, aux),
+        lambda: control(lcu, lambda: RZ(phase_even, aux), lambda: RZ(phase_odd, aux)),
+    )
+
+
+@qfunc
+def qsvt_lcu_step(
+    phases_even: CArray[CReal],
+    phases_odd: CArray[CReal],
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies a single QSVT-lcu step, composed of 2 double phase projector-controlled-phase rotations, and applications of the block encoding unitary `u` and its inverse:
+
+    $$
+    (C_{lcu=1}\\Pi^{even}_{\\phi_2})(C_{lcu=0}\\Pi^{odd}_{\\phi_2})U^{\\dagger}(C_{lcu=1}\\tilde{\\Pi}^{even}_{\\phi_1})(C_{lcu=0}\\tilde{\\Pi}^{odd}_{\\phi_1})U
+    $$
+
+    Args:
+        phases_even: 2 rotation phases for the even polynomial
+        phases_odd: 2 rotation phases for the odd polynomial
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        u: A block encoded unitary matrix.
+        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+        lcu: A qubit used for the combination of 2 polynomials within a single qsvt application
+    """
+    u(qvar)
+    projector_controlled_double_phase(
+        phases_even[0], phases_odd[0], proj_cnot_2, qvar, aux, lcu
+    )
+    invert(lambda: u(qvar))
+    projector_controlled_double_phase(
+        phases_even[1], phases_odd[1], proj_cnot_1, qvar, aux, lcu
+    )
+
+
+@qfunc
+def qsvt_lcu(
+    phase_seq_even: CArray[CReal],
+    phase_seq_odd: CArray[CReal],
+    proj_cnot_1: QCallable[QArray[QBit], QBit],
+    proj_cnot_2: QCallable[QArray[QBit], QBit],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements the Quantum Singular Value Transformation (QSVT) for a linear combination of odd and even polynomials, so that
+    it is possible to encode a polynomial of indefinite parity, such as approximation to exp(i*A) or exp(A). Should work
+    for Hermitian block encodings.
+
+    The function is equivalent to applying the `qsvt` function for odd and even polynomials with a LCU function, but
+    is more efficient as the two polynomials share the same applications of the given unitary.
+
+    The function is intended to be called within a context of LCU, where it is called as the SELECT operator, and wrapped
+    with initialization of the `lcu` qubit to get the desired combination coefficients.
+    The even polynomial corresponds to the case where the $lcu=|0\\rangle$, while the odd to #lcu=|1\\rangle$.
+
+    Note: the two polynomials should have the same degree up to a difference of 1.
+
+    Args:
+        phase_seq_odd: A sequence of phase angles of length d+1 for the odd polynomial.
+        phase_seq_even: A sequence of phase angles of length d+1 for the even polynomial.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
+        u: A block encoded unitary matrix.
+        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+        lcu: A qubit used for the combination of 2 polynomials within a single qsvt application
+    """
+    H(aux)
+    projector_controlled_double_phase(
+        phase_seq_even[0], phase_seq_odd[0], proj_cnot_1, qvar, aux, lcu
+    )
+    repeat(
+        count=floor((qmin(phase_seq_odd.len, phase_seq_even.len)) / 2),
+        iteration=lambda index: qsvt_lcu_step(
+            phase_seq_even[2 * index + 1 : 2 * index + 3],
+            phase_seq_odd[2 * index + 1 : 2 * index + 3],
+            proj_cnot_1,
+            proj_cnot_2,
+            u,
+            qvar,
+            aux,
+            lcu,
+        ),
+    )
+    if_(
+        condition=phase_seq_odd.len > phase_seq_even.len,
+        then=lambda: control(
+            lcu == 0,
+            lambda: [  # type:ignore[arg-type]
+                u(qvar),  # type:ignore[func-returns-value]
+                projector_controlled_phase(
+                    phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
+                ),
+            ],
+        ),
+    )
+    if_(
+        condition=phase_seq_odd.len < phase_seq_even.len,
+        then=lambda: (  # type:ignore[arg-type]
+            u(qvar),  # type:ignore[func-returns-value]
+            projector_controlled_double_phase(
+                phase_seq_even[phase_seq_even.len - 1],
+                phase_seq_odd[phase_seq_odd.len - 1],
+                proj_cnot_2,
+                qvar,
+                aux,
+                lcu,
+            ),
+            control(
+                lcu,
+                lambda: [  # type:ignore[arg-type]
+                    invert(lambda: u(qvar)),  # type:ignore[func-returns-value]
+                    projector_controlled_phase(
+                        phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
+                    ),
+                ],
+            ),
+        ),
+    )
+    H(aux)

classiq/qmod/builtins/functions/state_preparation.py

@@ -46,7 +46,7 @@ def allocate(
     pass
 
 
-@qfunc(external=True)
+@qfunc
 def allocate_num(
     num_qubits: CInt,
     is_signed: CBool,
@@ -200,7 +200,7 @@ def prepare_uniform_trimmed_state_apply_rotation(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def _prepare_uniform_trimmed_state_step(
     size_lsb: CInt, ctrl_val: CInt, lsbs_val: CInt, ctrl_var: QNum, rotation_var: QBit
 ) -> None:
@@ -215,7 +215,7 @@ def _prepare_uniform_trimmed_state_step(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -261,7 +261,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -287,7 +287,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
     modular_increment(start, q)
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -319,7 +319,7 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
     repeat(floor(log(size - 1, 2)) + 1, inner_lop)  # type:ignore[arg-type]
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
     """
 
@@ -338,7 +338,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
     repeat(q.len, lambda i: RY(2.0 * atan(exp((-rate * 2.0**i) / 2.0)), q[i]))
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -387,7 +387,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
     CX(q[0], q[1])
 
 
-@qfunc(external=True)
+@qfunc
 def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -412,7 +412,7 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_int(
     value: CInt,
     out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],

classiq/qmod/builtins/functions/swap_test.py

@@ -5,7 +5,7 @@ from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 
 
-@qfunc(external=True)
+@qfunc
 def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/utility_functions.py

@@ -6,7 +6,7 @@ from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QCallable
 
 
-@qfunc(external=True)
+@qfunc
 def apply_to_all(
     gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
 ) -> None:
@@ -23,7 +23,7 @@ def apply_to_all(
     repeat(target.len, lambda index: gate_operand(target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def hadamard_transform(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/variational.py

@@ -8,7 +8,7 @@ from classiq.qmod.qmod_variable import Output, QArray, QBit
 from classiq.qmod.symbolic import ceiling, floor, pi
 
 
-@qfunc(external=True)
+@qfunc
 def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -28,7 +28,7 @@ def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/operations.py

@@ -434,14 +434,14 @@ __all__ = [
     "assign_amplitude",
     "bind",
     "control",
-    "invert",
     "if_",
     "inplace_add",
     "inplace_xor",
+    "invert",
+    "phase",
     "power",
-    "within_apply",
     "repeat",
-    "phase",
+    "within_apply",
 ]
 
 

classiq/qmod/builtins/structs.py

@@ -134,18 +134,18 @@ BUILTIN_STRUCT_DECLARATIONS = {
 
 
 __all__ = [
-    "PauliTerm",
-    "MoleculeProblem",
-    "Molecule",
     "ChemistryAtom",
-    "Position",
-    "FockHamiltonianProblem",
-    "LadderTerm",
-    "LadderOp",
     "CombinatorialOptimizationSolution",
+    "FinanceFunction",
+    "FockHamiltonianProblem",
     "GaussianModel",
+    "LadderOp",
+    "LadderTerm",
     "LogNormalModel",
-    "FinanceFunction",
-    "QsvmResult",
+    "Molecule",
+    "MoleculeProblem",
+    "PauliTerm",
+    "Position",
     "QSVMFeatureMapPauli",
+    "QsvmResult",
 ]

classiq/qmod/native/pretty_printer.py

@@ -51,7 +51,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -60,7 +59,10 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -76,6 +78,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.qmod.builtins.functions import OPEN_LIBRARY_FUNCTIONS
 from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -85,11 +88,11 @@ class DSLPrettyPrinter(Visitor):
     def __init__(
         self,
         decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,
-        rename_phase: bool = False,
+        emit_open_lib_functions: bool = False,
     ) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
-        self._rename_phase = rename_phase
+        self._emit_open_lib_functions = emit_open_lib_functions
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -168,10 +171,7 @@ class DSLPrettyPrinter(Visitor):
     def visit_QuantumVariableDeclaration(
         self, var_decl: QuantumVariableDeclaration
     ) -> str:
-        var_name = var_decl.name
-        if self._rename_phase and var_name == "phase":
-            var_name = "phase_var"
-        return f"{var_name}: {self.visit(var_decl.quantum_type)}"
+        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         dir_str = (
@@ -179,12 +179,7 @@ class DSLPrettyPrinter(Visitor):
             if port_decl.direction != PortDeclarationDirection.Inout
             else ""
         )
-        port_name = (
-            port_decl.name
-            if not (self._rename_phase and port_decl.name == "phase")
-            else "phase_var"
-        )
-        param_name = f"{port_name}: " if port_decl.name is not None else ""
+        param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
         return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
@@ -250,6 +245,10 @@ class DSLPrettyPrinter(Visitor):
         return self.visit_AnonQuantumOperandDeclaration(op_decl)
 
     def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
+        if not self._emit_open_lib_functions and func_def.name in [
+            qfunc_.func_decl.name for qfunc_ in OPEN_LIBRARY_FUNCTIONS
+        ]:
+            return ""
         self._level += 1
         body = "".join(self.visit(qvar_decl) for qvar_decl in func_def.body)
         self._level -= 1
@@ -350,11 +349,7 @@ class DSLPrettyPrinter(Visitor):
         return f"lambda({positional_args}) {{\n{body}{self._indent}}}"
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
-        return (
-            var_ref.name
-            if not (self._rename_phase and var_ref.name == "phase")
-            else "phase_var"
-        )
+        return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
         return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
@@ -391,6 +386,9 @@ class DSLPrettyPrinter(Visitor):
     def visit_list(self, node: list) -> str:
         return "[" + ", ".join(self.visit(elem) for elem in node) + "]"
 
+    def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
+        return str(op)
+
     @property
     def _indent(self) -> str:
         return "  " * self._level

classiq/qmod/pretty_print/pretty_printer.py

@@ -52,7 +52,6 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
@@ -61,7 +60,10 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -285,10 +287,8 @@ class PythonPrettyPrinter(Visitor):
             raise ClassiqInternalError
 
         is_unsigned = (
-            is_signed_expr.is_evaluated()
-            and not is_signed_expr.to_bool_value()
-            or is_signed_expr.expr == "UNSIGNED"
-        )
+            is_signed_expr.is_evaluated() and not is_signed_expr.to_bool_value()
+        ) or is_signed_expr.expr == "UNSIGNED"
         is_integer = (
             fraction_digits_expr.is_evaluated()
             and fraction_digits_expr.to_int_value() == 0
@@ -526,6 +526,9 @@ class PythonPrettyPrinter(Visitor):
     def visit_list(self, node: list) -> str:
         return "[" + ", ".join(self.visit(elem) for elem in node) + "]"
 
+    def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
+        return str(op)
+
     @property
     def _indent(self) -> str:
         return "    " * self._level