qrisp.mcx#
- mcx(controls, target, method='auto', ctrl_state=- 1, num_ancilla=1)[source]#
Applies a multi-controlled X gate.
The following methods are available:
Method
Description
grayPerforms a gray code traversal which requires no ancillae but is rather inefficient for large numbers of control qubits.
gray_pt/gray_pt_invMore efficient but introduce extra phases that need to be uncomputed by performing the inverse of this gate on the same inputs. For more information on phase tolerance, check this paper.
balaucaMethod based on this paper with logarithmic depth but requires many ancilla qubits.
maslovDocumented here, requires less ancilla qubits but is only available for 4 or less control qubits.
yongCan be found int this article.This method requires only a single ancilla and has moderate scaling in depth and gate count.
amyA Toffoli-circuit (ie. only two control qubits are possible), which (temporarily) requires one ancilla qubit. However, instead of the no-ancilla T-depth 4, this circuit achieves a T-depth of 2. Find the implementation details in this paper.
jonesSimilar to
amybut uses two ancilla qubits, and has a T-depth of 1. Read about it here.gidneyA very unique way for synthesizing a logical AND. The Gidney Logical AND performs a circuit with T-depth 1 to compute the truth value and performs another circuit involving a measurement and a classically controlled CZ gate for uncomputation. The uncomputation circuit has T-depth 0, such that the combined T-depth is 1. Requires no ancillae. More details here. Works only for two control qubits.
hybridA flexible method which combines the other available methods, such that the amount of used ancillae is customizable. After several
balauca-layers, the recursion is canceled by either ayong,maslovorgraymcx, depending on what fits the most.autoRecompiles the mcx gate at compile time using the hybrid algorithm together with the information about how many clean/dirty ancillae qubits are available. For more information check
qrisp.QuantumSession.compile().Note
Due to Qrisp’s automatic qubit management, clean ancilla qubits are not as much of a sparse resource as one might think. Even though the
balaucamethod requires a considerable amount of ancillae, many other functions also do, implying there is alot of recycling potential. The net effect is that in more complex programs, the amount of qubits of the circuit returned by thecompile methodincreases only slightly.- Parameters
- controlslist[Qubits] or QuantumVariable
The Qubits to control on.
- targetQubit
The Qubit to perform the X gate on.
- methodstr, optional
The synthesis method. Available are
auto,gray,gray_pt,gray_pt_inv,maslov,balaucaandyong. The default isauto.- ctrl_stateint or str, optional
The state on which to activate the X gate. The default is “1111..”.
- num_ancillaint, optional
Specifies the amount of ancilla qubits to use. This parameter is used only if the method is set to
hybrid. The default is 1.
Examples
We apply a 3-contolled X gate
>>> from qrisp import QuantumVariable, mcx >>> control = QuantumVariable(3) >>> target = QuantumVariable(1) >>> mcx(control, target, method = "gray") >>> print(control.qs)
QuantumCircuit: -------------- control.0: ──■── │ control.1: ──■── │ control.2: ──■── ┌─┴─┐ target.0: ┤ X ├ └───┘ Live QuantumVariables: --------------------- QuantumVariable control QuantumVariable targetWe compare different performance indicators.
from qrisp import QuantumVariable, mcx def benchmark_mcx(n, methods): for method in methods: controls = QuantumVariable(n) target = QuantumVariable(1) mcx(controls, target, method = method) compiled_qc = controls.qs.compile() print(f"==================\nMethod: {method}\n------------------") print(f"Depth: \t\t\t{compiled_qc.depth()}") print(f"CNOT count: \t{compiled_qc.cnot_count()}") print(f"Qubit count: \t{compiled_qc.num_qubits()}")
>>> benchmark_mcx(4, methods = ["gray", "gray_pt", "maslov", "balauca", "yong"]) ================== Method: gray ------------------ Depth: 50 CNOT count: 30 Qubit count: 5 ================== Method: gray_pt ------------------ Depth: 34 CNOT count: 16 Qubit count: 5 ================== Method: maslov ------------------ Depth: 43 CNOT count: 18 Qubit count: 6 ================== Method: balauca ------------------ Depth: 22 CNOT count: 18 Qubit count: 7 ================== Method: yong ------------------ Depth: 77 CNOT count: 30 Qubit count: 6 >>> benchmark_mcx(10, methods = ["gray", "gray_pt", "balauca", "yong"]) ================== Method: gray ------------------ Depth: 3106 CNOT count: 2046 Qubit count: 11 ================== Method: gray_pt ------------------ Depth: 2050 CNOT count: 1024 Qubit count: 11 ================== Method: balauca ------------------ Depth: 53 CNOT count: 54 Qubit count: 18 ================== Method: yong ------------------ Depth: 621 CNOT count: 264 Qubit count: 12
Mid circuit measurement based methods
The
gidneyandjonesmethod are unique in the way that they require mid circuit measurements. The measurements are inserted retroactively by the.compilemethod, because immediate compilation would prevent evaluation of the statevector (since a measurement is involved).Instead a tentative (measurement free) representative is inserted and replaced at compile time.
To get a better understanding consider the following script:
>>> from qrisp import QuantumVariable, mcx >>> control = QuantumVariable(2) >>> target = QuantumVariable(1) >>> mcx(control, target, method = "jones") >>> print(control.qs) QuantumCircuit: --------------- ┌───────────────────────────┐ control.0: ┤0 ├ │ │ control.1: ┤1 ├ │ │ target.0: ┤2 uncompiled_jones_toffoli ├ │ │ jones_ancilla.0: ┤3 ├ │ │ jones_ancilla.1: ┤4 ├ └───────────────────────────┘ Live QuantumVariables: ---------------------- QuantumVariable control QuantumVariable target
We see that there is no classical bit and therefore also no measurement. The statevector can still be accessed:
>>> print(control.qs.statevector()) |00>*|0>
To introduce the measurement we simply call the
.compilemethod with the keywordcompile_mcm = True:>>> qc = control.qs.compile(compile_mcm = True) >>> print(qc) ┌─────────────────────────┐ control.0: ┤0 ├ │ │ control.1: ┤1 ├ │ │ target.0: ┤2 ├ │ compiled_jones_toffoli │ workspace_0: ┤3 ├ │ │ workspace_1: ┤4 ├ │ │ cb_0: ╡0 ╞ └─────────────────────────┘
Because there is a measurement now, the statevector can no longer be accessed.
>>> qc.statevector_array() Exception: Unitary of operation measure not defined.
However the T-depth went down by 50%:
>>> print(qc.t_depth()) 1 >>> print(control.qs.compile(compile_mcm = False).t_depth()) 2
A similar construction holds for the Gidney’s temporary logical AND. However there are additional details: This technique always comes in pairs. A computation and an uncomputation. The computation circuit has a T-depth of 1 and the uncomputation circuit has a T-depth of 0. The uncomputation circuit however contains a measurement.
As you can imagine, this measurement is also inserted at compile time.
Even though both circuits are not the inverses of each other, Qrisp will use the respective partner if called to invert:
>>> control = QuantumVariable(2) >>> target = QuantumVariable(1) >>> mcx(control, target, method = "gidney") >>> print(control.qs) QuantumCircuit: --------------- ┌────────────────────────┐ control.0: ┤0 ├ │ │ control.1: ┤1 uncompiled_gidney_mcx ├ │ │ target.0: ┤2 ├ └────────────────────────┘ Live QuantumVariables: ---------------------- QuantumVariable control QuantumVariable target
This even works in conjunction with the uncomputation module:
>>> target.uncompute() >>> print(target.qs) QuantumCircuit: --------------- ┌────────────────────────┐┌────────────────────────────┐ control.0: ┤0 ├┤0 ├ │ ││ │ control.1: ┤1 uncompiled_gidney_mcx ├┤1 uncompiled_gidney_mcx_inv ├ │ ││ │ target.0: ┤2 ├┤2 ├ └────────────────────────┘└────────────────────────────┘ Live QuantumVariables: ---------------------- QuantumVariable control
To introduce the measurement, we call the compile method.
>>> print(target.qs.compile(compile_mcm = True)) ┌──────────────────────┐┌──────────────────────────┐ control.0: ┤0 ├┤0 ├ │ ││ │ control.1: ┤1 compiled_gidney_mcx ├┤1 ├ │ ││ compiled_gidney_mcx_inv │ workspace_0: ┤2 ├┤2 ├ └──────────────────────┘│ │ cb_0: ════════════════════════╡0 ╞ └──────────────────────────┘
Apart from uncomputation, the inverted Gidney mcx can also be accessed via, the InversionEnvironment:
from qrisp import invert control = QuantumVariable(2) target = QuantumVariable(1) with invert(): mcx(control, target, method = "gidney")
>>> print(control.qs) QuantumCircuit: --------------- ┌────────────────────────────┐ control.0: ┤0 ├ │ │ control.1: ┤1 uncompiled_gidney_mcx_inv ├ │ │ target.0: ┤2 ├ └────────────────────────────┘ Live QuantumVariables: ---------------------- QuantumVariable control QuantumVariable target