How do I translate a quantum circuit for computing x + y mod 8 into a program?

Question

I have made the above quantum circuit that gives the mod $8=2^3$ operation between $|x\rangle$ and $|y\rangle$. Now I want to write its corresponding program using some language. Where can I do that i.e. online or on my hardware? And what programming language can I use for this purpose? Also please check my circuit for correctness.

Answer 1

I'm not sure if you are trying to represent $x$ and $y$ in little-endian or big-endian format, but either way the circuit does not look correct.

Let's consider the case of $x = 2$ and $y = 2$: they are conveniently represented the same way in LE and BE formats, as $010$, so the encoding will only matter when reading out the answer.

• You start with $|010\ 010\ 0\rangle$ (writing the states of the qubits in top-to-bottom order).
• After the first 3 gates you'll get $|010\ 010\ 1\rangle$ - indeed, OR of these wires is 1.
• The next three gates are controlled on the first qubit, which is in state $|0\rangle$, so we can ignore them: still $|010\ 010\ 1\rangle$.
• The second-to-last CNOT is executed: $|010\ 000\ 1\rangle$.
• The last CNOT has no effect again, so the final answer is $000$ - no matter whether you read it as little-endian or big-endian, it yields an incorrect sum of 0.

I believe this circuit doesn't handle the second carry bit properly.

---

For reference, here is the Q# code I wrote to test this circuit and find a test case for which it fails (you mentioned in the chat that you tried Quantum Development Kit, so this might be helpful):

// Allocate x, y and auxiliary qubits
using ((x, y, a) = (Qubit[3], Qubit[3], Qubit())) {
    for (xint in 0..7) {
        for (yint in 0..7) {
            // x and y qubits start in |0⟩ state; set them to their starting values - in little-endian
            ApplyPauliFromBitString(PauliX, true, IntAsBoolArray(xint, 3), x);
            ApplyPauliFromBitString(PauliX, true, IntAsBoolArray(yint, 3), y);

            // Calculate x + y mod 8 using the circuit
            // (assume the wires top to bottom are x0, x1, x2, y0, y1, y2, a)
            CCNOT(x[1], y[1], a);
            CNOT(x[1], a);
            CNOT(y[1], a);
            Controlled X([x[0], y[0], a], y[2]);
            CCNOT(x[0], y[0], y[1]);
            CNOT(x[0], y[0]);
            CNOT(x[1], y[1]);
            CNOT(x[2], y[2]);

            // Read out the result from y register (still as LE)
            let sum = MeasureInteger(LittleEndian(y));
            if (sum != (xint + yint) % 8) {
                Message($"Incorrect sum for x = {xint}, y = {yint}: sum = {sum}");
            }

            // Reset all qubits before next iteration
            ResetAll(x);
            ResetAll(y);
            Reset(a);
        }
    }
}

You can switch it to using big-endian by wrapping IntAsBoolArray and y register in measurement line in Reverse function to reverse the order of qubits.

---

As a side note, Q# has a library implementation of an adder, you can look it up here.