Classiq Open-library Functions¶
The Classiq Open-library is a collection of reusable building blocks for implementing quantum algorithms. Below are the declarations of these functions. The full implementation of these functions is available in link
qfunc qft_step(target: qbit[]);
qfunc qft(target: qbit[]);
qfunc qpe_flexible<unitary_with_power: qfunc <arg0: int>()>(phase: qnum);
qfunc qpe<unitary: qfunc ()>(phase: qnum);
qfunc standard_qpe<precision: int, unitary: qfunc ()>(phase: qbit[precision]);
qfunc single_pauli<slope: real, offset: real, q1_qfunc: qfunc <theta: real>(target: qbit)>(x: qbit[], q: qbit);
qfunc linear_pauli_rotations<bases: Pauli[], slopes: real[], offsets: real[]>(x: qbit[], q: qbit[]);
qfunc amplitude_estimation<num_phase_qubits: int, num_unitary_qubits: int, sp_op: qfunc <num_unitary_qubits: int>(spq: qbit[num_unitary_qubits]), oracle_op: qfunc <num_unitary_qubits: int>(oq: qbit[num_unitary_qubits])>(output phase_port: qnum<num_phase_qubits, False, num_phase_qubits>, output unitary_port: qbit[num_unitary_qubits]);
qfunc phase_oracle<predicate: qfunc (arg0: qbit[], arg1: qbit)>(target: qbit[]);
qfunc reflect_about_zero(packed_vars: qbit[]);
qfunc grover_diffuser<space_transform: qfunc (arg0: qbit[])>(packed_vars: qbit[]);
qfunc grover_operator<oracle: qfunc (arg0: qbit[]), space_transform: qfunc (arg0: qbit[])>(packed_vars: qbit[]);
qfunc grover_search<reps: int, oracle: qfunc (arg0: qbit[])>(packed_vars: qbit[]);
qfunc hadamard_transform(target: qbit[]);
qfunc apply_to_all<gate_operand: qfunc (target: qbit)>(target: qbit[]);
qfunc allocate_num<num_qubits: int, is_signed: bool, fraction_digits: int>(output out: qnum<num_qubits, is_signed, fraction_digits>);
qfunc qaoa_mixer_layer<b: real>(target: qbit[]);
qfunc qaoa_cost_layer<g: real, hamiltonian: PauliTerm[]>(target: qbit[]);
qfunc qaoa_layer<g: real, b: real, hamiltonian: PauliTerm[]>(target: qbit[]);
qfunc qaoa_init(target: qbit[]);
qfunc qaoa_penalty<num_qubits: int, params_list: real[], hamiltonian: PauliTerm[]>(target: qbit[num_qubits]);
qfunc full_hea<num_qubits: int, is_parametrized: int[], angle_params: real[], connectivity_map: int[][], reps: int, operands_1qubit: qfunc[] <angle: real>(q: qbit), operands_2qubit: qfunc[] <angle: real>(q1: qbit, q2: qbit)>(x: qbit[num_qubits]);
qfunc swap_test(state1: qbit[], state2: qbit[], output test: qbit);
qfunc prepare_ghz_state<size: int>(output q: qbit[]);
qfunc prepare_exponential_state<rate: int>(q: qbit[]);
qfunc prepare_bell_state<state_num: int>(output q: qbit[2]);
qfunc inplace_prepare_int<value: int>(target: qbit[]);
qfunc prepare_int<value: int>(output out: qnum);
qfunc switch<selector: int, cases: qfunc[] ()>();
@qfunc(external=True)
def qft_step(
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qft(
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qpe_flexible(
unitary_with_power: QCallable[CInt],
phase: QNum,
) -> None:
pass
@qfunc(external=True)
def qpe(
unitary: QCallable,
phase: QNum,
) -> None:
pass
@qfunc(external=True)
def standard_qpe(
precision: CInt,
unitary: QCallable,
phase: QArray[QBit, Literal["precision"]],
) -> None:
pass
@qfunc(external=True)
def single_pauli(
slope: CReal,
offset: CReal,
q1_qfunc: QCallable[CReal, QBit],
x: QArray[QBit],
q: QBit,
) -> None:
pass
@qfunc(external=True)
def linear_pauli_rotations(
bases: CArray[CInt],
slopes: CArray[CReal],
offsets: CArray[CReal],
x: QArray[QBit],
q: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def amplitude_estimation(
num_phase_qubits: CInt,
num_unitary_qubits: CInt,
sp_op: QCallable[CInt, QArray[QBit, Literal["num_unitary_qubits"]]],
oracle_op: QCallable[CInt, QArray[QBit, Literal["num_unitary_qubits"]]],
phase_port: Output[QNum],
unitary_port: Output[QArray[QBit, Literal["num_unitary_qubits"]]],
) -> None:
pass
@qfunc(external=True)
def phase_oracle(
predicate: QCallable[QArray[QBit], QArray[QBit]],
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def reflect_about_zero(
packed_vars: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def grover_diffuser(
space_transform: QCallable[QArray[QBit]],
packed_vars: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def grover_operator(
oracle: QCallable[QArray[QBit]],
space_transform: QCallable[QArray[QBit]],
packed_vars: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def grover_search(
reps: CInt,
oracle: QCallable[QArray[QBit]],
packed_vars: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def hadamard_transform(
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def apply_to_all(
gate_operand: QCallable[QBit],
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def allocate_num(
num_qubits: CInt,
is_signed: CBool,
fraction_digits: CInt,
out: Output[QNum],
) -> None:
pass
@qfunc(external=True)
def qaoa_mixer_layer(
b: CReal,
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qaoa_cost_layer(
g: CReal,
hamiltonian: CArray[PauliTerm],
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qaoa_layer(
g: CReal,
b: CReal,
hamiltonian: CArray[PauliTerm],
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qaoa_init(
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def qaoa_penalty(
num_qubits: CInt,
params_list: CArray[CReal],
hamiltonian: CArray[PauliTerm],
target: QArray[QBit, Literal["num_qubits"]],
) -> None:
pass
@qfunc(external=True)
def full_hea(
num_qubits: CInt,
is_parametrized: CArray[CInt],
angle_params: CArray[CReal],
connectivity_map: CArray[CArray[CInt]],
reps: CInt,
operands_1qubit: QCallableList[CReal, QBit],
operands_2qubit: QCallableList[CReal, QBit, QBit],
x: QArray[QBit, Literal["num_qubits"]],
) -> None:
pass
@qfunc(external=True)
def swap_test(
state1: QArray[QBit],
state2: QArray[QBit],
test: Output[QArray[QBit]],
) -> None:
pass
@qfunc(external=True)
def prepare_ghz_state(
size: CInt,
q: Output[QArray[QBit]],
) -> None:
pass
@qfunc(external=True)
def prepare_exponential_state(
rate: CInt,
q: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def prepare_bell_state(
state_num: CInt,
q: Output[QArray[QBit]],
) -> None:
pass
@qfunc(external=True)
def inplace_prepare_int(
value: CInt,
target: QArray[QBit],
) -> None:
pass
@qfunc(external=True)
def prepare_int(
value: CInt,
out: Output[QNum],
) -> None:
pass
@qfunc(external=True)
def switch(
selector: CInt,
cases: QCallableList,
) -> None:
pass