QCEngine Intro

QCEngine Hands-On Introduction

This is an active QC simulator, which provides a programming interface, as well as a programmer's visual model, for QC operations. It's not finished yet, but you're welcome to browse. Please give feedback to qc@machinelevel.com!

©2000-2015 All rights reserved. For more information, please send email to qc@machinelevel.com

Welcome to the intro!

This page provides a functional hands-on introduction to this system.
The simulator is live and running at all times, so you can write code as though you had an actual QC running.

See this link for a QCEngine Quick Programming Reference .

Why does QCEngine exist?

QCEngine is a quantum computation playground for software engineers which...

...is practical and easy to use so that you can start right away, even if you've never done QC development before.
...can scale up so that you can build interesting complex things which will map onto hardware in the future.
...can scale down so that you can actually implement your programs on simple quantum logic devices systems.
...runs on all platforms including mobile phones.
...can be integrated into your own programs, for easy quantum logic simulation.

1. Basic operation
Here's a simple program which just does a bunch of basic operations. Try this: Run the program, and then click in the gates on the chart to inspct the quantum state after each operation. You can run the program forward or backward, but be aware that non-reversible operations only really make sense if you run them forward. Try this: Modify the program! Change the number of qubits. Ask the sim for a hundred of them, or a thousand. That'll work, but once you're above 24 or so, the sim wili become digital-only (non-quantum) so many operations will still work, but not interference or superposition.	qc.reset(2); // Set up a device with 2 qubits qc.write(0); // Write the initial value qc.not(1); // Simple not on bit 1 qc.hadamard(2); // Hadamard transform of bit 2 qc.phase(90, 2); // Rotate the phase of bit 2 qc.cnot(1, 2); // cnot bit 1, with cond bit 2 qc.hadamard(1\|2); // Hadamard both bits qc.read(2); // Read bit 2	Ready.

2. Entanglement
Here's a program which demonstrates entanglement of two qubits. Try this: Run the program several times, and watch the output. Notice that the values of the two bits are always random, but always match. Try this: Click the gates to watch the entanglement happen.	qc.reset(2); qc.write(0); qc.codeLabel('entangle'); qc.hadamard(2); qc.cnot(1, 2); qc.codeLabel(''); qc.print('Result: ' + qc.read() + '\n');	Ready.

This program does entanglement using a CZ gate instead of a cnot gate. Try this: Click the gates to watch the entanglement happen.	qc.reset(2); qc.write(0); qc.codeLabel('entangle'); qc.hadamard(); qc.phase(180, 1\|2);	Ready.

3. Teleportation
Here's a quick teleportation circuit. Notice: We've started using the qint type to label the qunbits. Try this: Increase the "num_bits", so that Alice can teleport more data to bob.	var num_bits = 1; qc.reset(3 * num_bits); var alice = qint.new(num_bits, 'alice'); var epair1 = qint.new(num_bits, 'epair1'); var bob = qint.new(num_bits, 'bob (epair2)'); qc.codeLabel('entangle'); epair1.write(0); bob.write(0); epair1.hadamard(); bob.cnot(epair1); qc.codeLabel('prep'); alice.write(0); alice.roty(25); alice.phase(25); qc.codeLabel('send'); epair1.cnot(alice); alice.hadamard(); alice.read(); epair1.read(); qc.codeLabel('receive'); bob.cnot(epair1); bob.hadamard(); bob.cnot(alice); bob.hadamard();	Ready.

The example above uses the convenient notation of Bob doing a cnot on Alice's result bits. That's not necessary, and here we show reading the values directly and applying them. Try this: Run it several times, and watch bob change his actions depending on Alice's results.	var num_bits = 1; qc.reset(3 * num_bits); var alice = qint.new(num_bits, 'alice'); var epair1 = qint.new(num_bits, 'epair1'); var bob = qint.new(num_bits, 'bob (epair2)'); qc.codeLabel('entangle'); epair1.write(0); bob.write(0); epair1.hadamard(); bob.cnot(epair1); qc.codeLabel('prep'); alice.write(0); alice.roty(25); alice.phase(25); qc.codeLabel('send'); epair1.cnot(alice); alice.hadamard(); var a2 = alice.read(); var a1 = epair1.read(); qc.codeLabel('receive'); bob.not(a1); bob.hadamard(); bob.not(a2); bob.hadamard();	Ready.

We don't actually need to construct it from gates each time; all of this can be wrapped up into functions, for convenience.	var num_bits = 1; qc.reset(3 * num_bits); var alice = qint.new(num_bits, 'alice'); var epair1 = qint.new(num_bits, 'epair1'); var bob = qint.new(num_bits, 'bob (epair2)'); qc.codeLabel('entangle'); epair1.write(0); bob.write(0); epair1.hadamard(); bob.cnot(epair1); qc.codeLabel('prep'); alice.write(0); alice.roty(25); alice.phase(25); qc.codeLabel('send'); var a_bits = alice.teleport_send(epair1); qc.codeLabel('receive'); bob.teleport_receive(a_bits);	Ready.

4. Cluster States
Here we construct all of the different topological 4-bit cluster states. Notice: The program turns on the "color by phase" option, to make it easier to see the cluster states.	qc_options.color_by_phase = true; qc.reset(4); qc.codeLabel('Star'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 1\|4); qc.phase(180, 1\|8); qc.codeLabel('Complete'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 1\|4); qc.phase(180, 1\|8); qc.phase(180, 2\|4); qc.phase(180, 2\|8); qc.phase(180, 4\|8); qc.codeLabel('Kite'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 2\|4); qc.phase(180, 2\|8); qc.phase(180, 4\|8); qc.codeLabel('Square'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 2\|4); qc.phase(180, 1\|8); qc.phase(180, 4\|8); qc.codeLabel('Line'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 2\|4); qc.phase(180, 1\|8); qc.codeLabel('Diamond'); qc.write(0); qc.hadamard(); qc.phase(180, 1\|2); qc.phase(180, 1\|4); qc.phase(180, 1\|8); qc.phase(180, 2\|4); qc.phase(180, 2\|8);	Ready.

4b. Stabilizer Sim For working with large graph states, the stabilizer simulation is useful. It's based on CHP, written by Scott Aaronson and Daniel Gottesman. The CHP sim simulates a small subset of gates (CNOT, Hadamard, 90-degree phase) which isn't enough for universal computation. The CHP simulation may be turned on and off as desired during a program, in order to accelerate operations where it's sufficient.
This simple demo uses CHP to perform entannglement of 1000 qubits, very quickly.	qc_options.color_by_phase = false; function main() { entangle(1000); } function entangle(num_qubits) { if (!num_qubits) return; qc.reset(num_qubits); // Set up the state vector qc.write(0); qc.start_chp_sim(); // Activate the CHP simulation qc.hadamard(1); // Hadamard the first qubit var bf = new BitField(2, qc.qReg.numQubits); for (var i = 1; i < num_qubits; ++i) { qc.cnot(bf, 1); // Entangle all the other qubits bf.shiftLeft1(); } qc.read(); // Measure all the qubits qc.stop_chp_sim(); } main();	Ready.
Here we turn on CHP to generate a cluster quickly, but then switch it off to perform a QFT, which is something it can't do. Note that it prints out the stabilizer state after constructing the cluster. Pro tips: By *clicking* in the gates window, you can single-step, in all modes. Use *Shift + mousewheel* in the circle window to see tiny state vectors. Use *Ctrl + mousewheel* in the circle or gates window to zoom.	qc_options.color_by_phase = true; function main() { var use_chp_sim = true; var grid_x = 3; var grid_y = 3; var num_qubits = grid_x * grid_y; qc.reset(num_qubits); var qnum = qint.new(num_qubits, 'qnum'); build_cluster_grid(grid_x, grid_y, use_chp_sim); qnum.QFT(); } function build_cluster_grid(gx, gy, use_chp_sim) { qc.codeLabel('cluster prep'); qc.write(0); if (use_chp_sim) qc.start_chp_sim(); qc.hadamard(); var top = 0; for (var x = 0; x < gx; ++x) { qc.codeLabel('vert'); for (var y = 0; y < gy - 1; ++y) { var bit1 = 1 << (top + y); var bit2 = 1 << (top + y + 1); qc.phase(180, bit1 \| bit2); } if (x < gx - 1) { qc.codeLabel('horiz'); for (var y = 0; y < gy; ++y) { var bit1 = 1 << (top + y); var bit2 = 1 << (top + y + gy); qc.phase(180, bit1 \| bit2); } } top += gy; } qc.chp.printstate(); // Print the state! if (use_chp_sim) qc.stop_chp_sim(); } main();	Ready.
...and here are some of the samples which come with CHP. In the source code, you can see that they're the original content, just inserted as JavaScript strings.	qc_options.color_by_phase = true; function main() { var use_chp_sim = true; var prog_okay = [1, 1, 1, 1, 1]; var prog_text = [prog_epr, prog_ghz, prog_teleport, prog_simon, prog_qecc9]; var prog_name = ['epr', 'ghz', 'teleport', 'simon', 'qecc9']; qc.reset(12); for (var i = 0; i < prog_text.length; ++i) { if (prog_okay[i]) { qc.codeLabel(prog_name[i]); if (use_chp_sim) qc.start_chp_sim(); qc.parse_chp_commands(prog_text[i]); if (use_chp_sim) qc.stop_chp_sim(); qc.codeLabel(''); qc.discard(); qc.nop(); } } } var prog_epr = [ 'Prepares an EPR pair \|00>+\|11> across qubits', '0 and 1, then measures qubit 1. The outcome', 'should be random.', '#', 'h 0', 'c 0 1', 'm 1', ]; var prog_ghz = [ 'Runs a GHZ (Greenberger-Horne-Zeilinger) experiment:', 'Players A, B, and C are given the state', '\|000>-\|011>-\|101>-\|110>,', 'as well as bits a,b,c (a=b=1 and c=0 in this example).', 'Their goal is to output bits x,y,z respectively such', 'that x+y+z(mod 2) = a OR b OR c, under the promise that', 'a+b+c=0(mod 2). In contrast to the classical case, there', 'exists a quantum strategy that always succeeds: each', 'player measures in the standard basis if his bit is 0,', 'or in the Hadamard basis if his bit is 1, then outputs', 'whatever he observes. When this program is run, the', 'outcomes of the 3 measurements should be uniformly random', 'conditioned on having parity=1.', '#', 'h 0', 'h 1', 'c 0 2', 'c 1 2', 'p 0', 'p 1', 'p 2', '', 'h 0', 'm 0', 'h 1', 'm 1', 'm 2', ]; var prog_qecc9 = [ 'Encodes a qubit of your choice using the Shor 9-qubit quantum', 'error-correcting code, then applies an encoded Pauli operation of', 'your choice to the codeword, and finally decodes the codeword and', 'measures the result.', 'The qubit to be encoded is stored in qubit 0. Qubit 1 is 1 if and', 'only if an X operation should be applied to the codeword, and qubit', '2 is 1 if and only if a Z should be applied. So for example, if', 'you want to encode \|0> and then apply a Y=-iXZ operation, type the', 'following at the command line:', 'chp qecc9 zZZ', 'The output in this case should be \|1>. Or, if you want to encode', '\|0>+i\|1> and then apply X, type the following:', 'chp qecc9 yZz', 'The output in this case should be random (since the final state is', '\|0>-i\|1>). In general:', 'x for \|0>', 'X for \|1>', 'y for \|0>+i\|1>', 'Y for \|0>-i\|1>', 'z for \|0>+\|1>', 'Z for \|0>-\|1>', 'Note that since the measurement is in the standard basis, applying', 'the Z operator should not have an observable effect.', '#', 'c 0 3', 'c 3 0', '', 'c 3 6', 'c 3 9', 'h 3', 'c 3 4', 'c 3 5', 'h 6', 'c 6 7', 'c 6 8', 'h 9', 'c 9 10', 'c 9 11', '', 'h 3', 'h 4', 'h 5', 'h 6', 'h 7', 'h 8', 'h 9', 'h 10', 'h 11', 'c 1 3', 'c 1 4', 'c 1 5', 'c 1 6', 'c 1 7', 'c 1 8', 'c 1 9', 'c 1 10', 'c 1 11', 'h 3', 'h 4', 'h 5', 'h 6', 'h 7', 'h 8', 'h 9', 'h 10', 'h 11', '', 'c 2 3', 'c 2 4', 'c 2 5', 'c 2 6', 'c 2 7', 'c 2 8', 'c 2 9', 'c 2 10', 'c 2 11', '', 'c 9 11', 'c 9 10', 'h 9', 'c 6 8', 'c 6 7', 'h 6', 'c 3 5', 'c 3 4', 'h 3', 'c 3 9', 'c 3 6', 'm 3', ]; var prog_simon = [ 'Uses Simon\'s algorithm to learn about the "hidden', 'shift" of a function f (the string s such that', 'f(x)=f(y) if and only if y=x+s, where + denotes', 'bitwise XOR). The function is the following', 'linear map from 5 bits to 4 bits:', 'f(a,b,c,d,e)=(a+b,b+c,c+d,d+e)', 'Clearly s=11111 for this function.', 'The program first prepares a uniform superposition', 'over 5-bit strings in qubits 0 to 4. It then', 'computes f in qubits 5 to 8, and measures those', 'qubits "for pedagogical purposes." Finally it', 'performs a Fourier transform on qubits 0 to 4 and', 'measures them. The first round of measurements', 'should produce a random 4-bit string; the second', 'should produce a random 5-bit string y such that', 'y*s=0 (that is, y has even parity).', '#', 'h 0', 'h 1', 'h 2', 'h 3', 'h 4', '', 'c 0 5', 'c 1 5', 'c 1 6', 'c 2 6', 'c 2 7', 'c 3 7', 'c 3 8', 'c 4 8', '', 'm 5', 'm 6', 'm 7', 'm 8', '', 'h 0', 'h 1', 'h 2', 'h 3', 'h 4', '', 'm 0', 'm 1', 'm 2', 'm 3', 'm 4', ]; var prog_teleport = [ 'Runs the quantum teleportation protocol.', 'The state to be teleported is in qubit 0.', 'You can specify that state at the command line by typing', 'chp teleport z for \|0>', 'chp teleport Z for \|1>', 'chp teleport x for \|0>+\|1>', 'chp teleport X for \|0>-\|1>', 'chp teleport y for \|0>+i\|1>', 'chp teleport Y for \|0>-i\|1>', 'The program first prepares an EPR pair (\|00>+\|11>) across', 'qubits 1 and 2 (1 is Alice\'s half and 2 is Bob\'s half).', 'Alice then applies the teleportation circuit, and measures', 'qubits 0 and 1 to obtain the two-bit error syndrome. She', 'CNOT\'s this syndrome into qubits 3 and 4, representing', 'classical communication to Bob. Finally, Bob uses the', 'syndrome to correct the teleported state, and measures it', 'in the standard basis. When qubit 2 is measured, the', 'result should be 0 if the input was z, 1 if the input was', 'Z, and random if the input was x, X, y, or Y.', '#', 'h 1', 'c 1 2', '', 'c 0 1', 'h 0', 'm 0', 'm 1', '', 'c 0 3', 'c 1 4', '', 'c 4 2', 'h 2', 'c 3 2', 'h 2', 'm 2', ]; var prog_entangle = [ 'Performs a simple entanglement test.', '#', 'h 0', 'c 0 1', 'c 0 2', 'c 0 3', 'c 0 4', 'c 0 5', 'm 0', 'm 1', 'm 2', 'm 3', 'm 4', 'm 5', ]; main();	Ready.

5. Beam Splitters, Part 1
For basic single-qubit beamsplitters, there's just a simple command. Beamsplitters which mix qubit states will be shown later. Notice: At this stage, the dual-rail representation is cosmetic. Later it gets more serious. Notice: The first qubit here has a Hadamard made of beamsplitters.	qc.reset(2); qc.write(0); qc.beamsplitter(0.5, 1); qc.phase(90, 1); qc.beamsplitter(0.5, 1); qc.hadamard(1); qc.beamsplitter(0.33, 2); qc.phase(180, 2); qc.beamsplitter(0.33, 2);	Ready.

6. QKD
This program shows the basic quantum key distribution model, with quantum RNG for both Alice and Bob.	qc_options.circle_scale = 0.3; // Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.hadamard(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit alice_qb.write(0); alice_bits.push(qrng(alice_RNG)); alice_qb.cnot(alice_RNG); alice_bits.push(qrng(alice_RNG)); alice_qb.chadamard(alice_RNG); alice_qb.exchange(cable); } function bob_receive() { // Bob receives it bob_qb.exchange(cable); bob_bits.push(qrng(bob_RNG)); bob_qb.chadamard(bob_RNG); bob_bits.push(bob_qb.read()); } var num_packets = 5; // perform the QKD this many times qc.reset(5); var alice_RNG = qint.new(1, 'alice_RNG'); var alice_qb = qint.new(1, 'alice_qb'); var cable = qint.new(1, 'optical cable'); var bob_qb = qint.new(1, 'bob_qb'); var bob_RNG = qint.new(1, 'bob_RNG'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { qc.codeLabel('alice send bit ' + i); alice_send(); qc.codeLabel('bob receive bit ' + i); bob_receive(); } var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } }	Ready.

Here's the version with Eve being a sneaky spy.	qc_options.circle_scale = 0.3; // Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.hadamard(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit alice_qb.write(0); alice_bits.push(qrng(alice_RNG)); alice_qb.cnot(alice_RNG); alice_bits.push(qrng(alice_RNG)); alice_qb.chadamard(alice_RNG); alice_qb.exchange(cable); } function eve_listen() { // Eve tries to spy var eve_bit = cable.read(); cable.write(eve_bit); } function bob_receive() { // Bob receives it bob_qb.exchange(cable); bob_bits.push(qrng(bob_RNG)); bob_qb.chadamard(bob_RNG); bob_bits.push(bob_qb.read()); } var num_packets = 5; // perform the QKD this many times qc.reset(5); var alice_RNG = qint.new(1, 'alice_RNG'); var alice_qb = qint.new(1, 'alice_qb'); var cable = qint.new(1, 'optical cable'); var bob_qb = qint.new(1, 'bob_qb'); var bob_RNG = qint.new(1, 'bob_RNG'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { qc.codeLabel('alice send bit ' + i); alice_send(); qc.codeLabel('eve ' + i); eve_listen(); qc.codeLabel('bob receive bit ' + i); bob_receive(); } var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR Eve is busted.\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } }	Ready.

7. Integer Math
Using the qint type, math functions (add, subtract, multiply, etc) can be performed on sets of qubits, even in superposition, even if the number of bits isn't the same. Notice: When we read the register, a random equation is pulled from the superposition, but it's always self-consistent.	qc_options.circle_scale = 0.3; var bits_per_int = 3; qc.reset(4 * bits_per_int); var a = qint.new(bits_per_int, 'a'); var b = qint.new(bits_per_int, 'b'); var acc = qint.new(2 * bits_per_int, 'acc'); a.write(0); a.hadamard(3); b.write(5); b.hadamard(1); b.add(a); acc.write(0); acc.addSquared(b); var aa = a.read(); var bb = b.read(); var result = acc.read(); qc.print('(' + aa + '+(' + (bb-aa) + '))^2=' + result + '\n');	Ready.

8. Beam Splitters, Part 2
To use beam splitters more generally, we need to expand the Fock states to full dual-rail. This program implements the CNOT version of this QCloud Demo. (This part is under construction)
qc.reset(2); //var a = qint.new(1, 'a'); //var b = qint.new(1, 'b'); if (1) { qc.codeLabel('NOP'); qc.write(1); qc.peek(); qc.read(); } if (1) { qc.codeLabel('BS'); qc.write(1); // qc.hadamard(); qc.postselect_qubit_pair(1\|2); qc.start_photon_sim(); qc.dual_rail_beamsplitter(1/3, 1\|2); qc.stop_photon_sim(); qc.peek(); qc.read(); } if (1) { var acos13 = Math.acos(1/3) * 180 / Math.PI; qc.codeLabel('MZI'); qc.write(1); // qc.hadamard(); qc.postselect_qubit_pair(1\|2); qc.start_photon_sim(); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.phase(acos13, 2); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.stop_photon_sim(); qc.peek(); // qc.read(); }	Ready.

This builds an optical postselected CNOT gate.
qc.reset(6); if (1) { var aux1 = qint.new(1, 'aux1'); var ab = qint.new(2, 'a/b'); var cd = qint.new(2, 'c/d'); var aux2 = qint.new(1, 'aux2'); } qc.write(2\|16); //qc.hadamard(); qc.codeLabel('cnot'); qc.start_photon_sim(); qc.dual_rail_beamsplitter(0.5, 8\|16); qc.dual_rail_beamsplitter(1.0/3.0, 1\|2); qc.dual_rail_beamsplitter(1.0/3.0, 4\|8); qc.dual_rail_beamsplitter(1.0/3.0, 16\|32); qc.dual_rail_beamsplitter(0.5, 8\|16); aux1.postselect(0); aux2.postselect(0); ab.postselect_qubit_pair(); cd.postselect_qubit_pair(); qc.stop_photon_sim(); qc.codeLabel(''); //qc.postselect(0, 1\|32); qc.peek(); ab.read(); cd.read(); // Now check all of the values to make sure the gate works. qc.disableRecording(); qc.print('CNOT check:\n'); for (var ab_in = 1; ab_in <= 2; ++ab_in) { for (var cd_in = 1; cd_in <= 2; ++cd_in) { ab.write(ab_in); cd.write(cd_in); qc.runLabel('cnot'); var ab_out = ab.read(); var cd_out = cd.read(); qc.print('' + (ab_in >> 1) + (cd_in >> 1) + '->' + (ab_out >> 1) + (cd_out >> 1) + '\n'); } } qc.enableRecording();	Ready.

This builds an optical postselected CZ gate.
qc.reset(6); if (1) { var aux1 = qint.new(1, 'aux1'); var ab = qint.new(2, 'a/b'); var cd = qint.new(2, 'c/d'); var aux2 = qint.new(1, 'aux2'); } qc.write(0, 2\|4\|8\|16); qc.hadamard(2\|4\|8\|16); qc.postselect_qubit_pair(2\|4); qc.postselect_qubit_pair(8\|16); qc.start_photon_sim(); if (1) { qc.dual_rail_beamsplitter(1.0/3.0, 1\|2); qc.dual_rail_beamsplitter(1.0/3.0, 4\|8); qc.dual_rail_beamsplitter(1.0/3.0, 16\|32); } else { var acos13 = Math.acos(1/3) * 180 / Math.PI; qc.dual_rail_beamsplitter(0.5, 1\|2); qc.phase(acos13, 1); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.dual_rail_beamsplitter(0.5, 4\|8); qc.phase(acos13, 4); qc.dual_rail_beamsplitter(0.5, 4\|8); qc.dual_rail_beamsplitter(0.5, 16\|32); qc.phase(acos13, 16); qc.dual_rail_beamsplitter(0.5, 16\|32); } qc.postselect(0, 1\|32); qc.stop_photon_sim(); qc.postselect_qubit_pair(2\|4); qc.postselect_qubit_pair(8\|16); qc.peek(); var a; //a = qc.read(2\|4\|8\|16); var postselect_ok = true; if (a & 1) postselect_ok = false; else if (a & 32) postselect_ok = false; else if (((a ^ (a >> 1)) & (2+8)) != (2+8)) postselect_ok = false; if (postselect_ok) qc.print('result: ' + a + '\n'); else qc.print('.');	Ready.

This builds an optical postselected CZ gate with simple aux-bits.
qc.reset(4); if (1) { var ab = qint.new(2, 'a/b'); var cd = qint.new(2, 'c/d'); } qc.write(0); qc.hadamard(); qc.postselect_qubit_pair(1\|2); qc.postselect_qubit_pair(4\|8); qc.start_photon_sim(); qc.dual_rail_beamsplitter(1.0/3.0, 2\|4, 1\|8); qc.postselect_qubit_pair(1\|2); qc.postselect_qubit_pair(4\|8); qc.stop_photon_sim(); qc.peek(); var a; //a = qc.read(2\|4\|8\|16); var postselect_ok = true; if (a & 1) postselect_ok = false; else if (a & 32) postselect_ok = false; else if (((a ^ (a >> 1)) & (2+8)) != (2+8)) postselect_ok = false; if (postselect_ok) qc.print('result: ' + a + '\n'); else qc.print('.');	Ready.

(Under construction, Jeremy's device)
qc_options.color_by_phase = true; qc_options.circle_scale = 0.2; panel_chart.setSize(500, 500); var do_crossovers = false; var u1 = Math.acos(1.0/3.0); var u2 = Math.acos(1.0/3.0); var u3 = Math.acos(1.0/3.0); var z11 = 180; var y11 = 180; var y13 = 180; var z21 = 180; var y21 = 180; var y23 = 180; var z31 = 180; var y31 = 180; var y33 = 180; var z41 = 180; var y41 = 180; var y43 = 180; qc.reset(10); var aux1 = qint.new(1, 'aux1'); var as_bs = qint.new(2, 'as/bs'); var cs_ds = qint.new(2, 'cs/ds'); var aux = null; if (!do_crossovers) aux2 = qint.new(1, 'aux2'); var ai_bi = qint.new(2, 'ai/bi'); var ci_di = qint.new(2, 'ci/di'); if (do_crossovers) aux2 = qint.new(1, 'aux2'); qc.codeLabel(''); aux1.write(0); aux2.write(0); if (do_crossovers) { qc.codeLabel('crossover'); qc.exchange(4\|8); qc.exchange(16\|32); qc.exchange(64\|128); qc.exchange(256\|512); qc.exchange(8\|16); qc.exchange(32\|64); qc.exchange(128\|256); qc.exchange(16\|32); qc.exchange(64\|128); qc.exchange(32\|64); } as_bs.write(1); ai_bi.write(0); cs_ds.write(1); ci_di.write(0); //as_bs.hadamard(); //cs_ds.hadamard(); //ai_bi.cnot(as_bs, 1); //ci_di.cnot(cs_ds, 1); qc.codeLabel('source'); //as_bs.dual_rail_beamsplitter(0.5, 1\|2); //as_bs.phase(270, 1); //as_bs.dual_rail_beamsplitter(0.5, 1\|2); //as_bs.pair_source(ai_bi); qc.pair_source(64\|128, 2\|4); //qc.pair_source(256\|512, 8\|16); //cs_ds.dual_rail_beamsplitter(0.5, 1\|2); //cs_ds.phase(270, 1); //cs_ds.dual_rail_beamsplitter(0.5, 1\|2); //cs_ds.pair_source(ci_di); qc.start_photon_sim(); qc.codeLabel('entangle'); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.dual_rail_beamsplitter(0.5, 4\|8); qc.dual_rail_beamsplitter(0.5, 16\|32); qc.phase(u1, 1); qc.phase(u2, 4); qc.phase(u3, 16); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.dual_rail_beamsplitter(0.5, 4\|8); qc.dual_rail_beamsplitter(0.5, 16\|32); aux1.postselect(0); aux2.postselect(0); qc.codeLabel('unitary'); qc.phase(z11, 2); qc.dual_rail_beamsplitter(0.5, 2\|4); qc.phase(y11, 2); qc.dual_rail_beamsplitter(0.5, 2\|4); qc.phase(y13, 2); qc.phase(z21, 8); qc.dual_rail_beamsplitter(0.5, 8\|16); qc.phase(y21, 8); qc.dual_rail_beamsplitter(0.5, 8\|16); qc.phase(y23, 8); qc.phase(z31, 64); qc.dual_rail_beamsplitter(0.5, 64\|128); qc.phase(y31, 64); qc.dual_rail_beamsplitter(0.5, 64\|128); qc.phase(y33, 64); qc.phase(z41, 256); qc.dual_rail_beamsplitter(0.5, 256\|512); qc.phase(y41, 256); qc.dual_rail_beamsplitter(0.5, 256\|512); qc.phase(y43, 256); as_bs.postselect_qubit_pair(); cs_ds.postselect_qubit_pair(); ai_bi.postselect_qubit_pair(); ci_di.postselect_qubit_pair(); qc.stop_photon_sim(); panel_staff.staff.parallelize(false); qc.photonSimTest();	Ready.

(Under construction, Comms QKD 1)
// Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.beamsplitter(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit cable.write(1); alice_bits.push(qrng(rng)); cable.dual_rail_beamsplitter(); cable.phase(180, 2, rng); cable.dual_rail_beamsplitter(); alice_bits.push(qrng(rng)); cable.dual_rail_beamsplitter(); cable.phase(90, 2, rng); cable.dual_rail_beamsplitter(); } function eve_listen() { // Eve tries to spy var eve_bits = cable.read(); cable.write(eve_bits); } function bob_receive() { // Bob receives it //cable.write(1); //cable.dual_rail_beamsplitter(); detectors.write(0); cable.exchange(detectors); detectors.exchange(null, 2\|4); detectors.exchange(null, 4\|8); detectors.dual_rail_beamsplitter(0.5, 1\|2); detectors.dual_rail_beamsplitter(0.5, 8\|16); detectors.dual_rail_beamsplitter(0.5, 2\|4); detectors.dual_rail_beamsplitter(0.5, 16\|32); detectors.peek(); var result = detectors.read(); var basis = (result & 0x7) != 0; var val = (result & 0xc) != 0; if (basis) qc.print('basis:'); else qc.print('val:'); qc.print('' + val + '\n'); } var num_packets = 1; // perform the QKD this many times qc.reset(9); var cable = qint.new(2, 'optical cable'); var rng = qint.new(1, 'random gen'); var detectors = qint.new(6, 'detectors'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { qc.codeLabel('alice send bit ' + i); alice_send(); qc.codeLabel(''); cable.peek(); qc.nop(); qc.codeLabel('eve ' + i); if (0) eve_listen(); qc.codeLabel(''); qc.nop(); qc.nop(); qc.codeLabel('bob receive bit ' + i); if (1) bob_receive(); } /* var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR Eve is busted.\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } } */	Ready.

(Under construction, Comms QKD 2)
// Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.beamsplitter(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit cable.write(1); alice_bits.push(qrng(rng)); cable.beamsplitter(); cable.phase(180, 1, rng); cable.beamsplitter(); alice_bits.push(qrng(rng)); cable.beamsplitter(); cable.phase(90, 1, rng); cable.beamsplitter(); rng.write(0); rng.read();} function eve_listen() { // Eve tries to spy var eve_bits = cable.read(); cable.write(eve_bits); } function bob_receive() { // Bob receives it cable.beamsplitter(); bob_bits.push(qrng(rng)); bob_bits.push(cable.read()); } var num_packets = 1; // perform the QKD this many times qc.reset(2); var cable = qint.new(1, 'optical cable'); var rng = qint.new(1, 'random gen'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { qc.codeLabel('alice send bit ' + i); alice_send(); qc.codeLabel(''); cable.peek(); qc.nop(); qc.codeLabel('eve ' + i); if (0) eve_listen(); qc.codeLabel(''); qc.nop(); qc.nop(); qc.codeLabel('bob receive bit ' + i); if (0) bob_receive(); } var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR Eve is busted.\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } }	Ready.

(Under construction, Comms QKD 3)
// Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.beamsplitter(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit cable.write(1); alice_bits.push(qrng(rng)); cable.beamsplitter(); cable.phase(180, 1, rng); cable.beamsplitter(); alice_bits.push(qrng(rng)); cable.beamsplitter(); cable.phase(90, 1, rng); cable.beamsplitter(); rng.write(0); rng.read();} function eve_listen() { // Eve tries to spy var eve_bits = cable.read(); cable.write(eve_bits); } function bob_receive() { // Bob receives it cable.beamsplitter(); bob_bits.push(qrng(rng)); bob_bits.push(cable.read()); } var num_packets = 1; // perform the QKD this many times qc.reset(2); var cable = qint.new(1, 'optical cable'); var rng = qint.new(1, 'random gen'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { qc.codeLabel('alice send bit ' + i); alice_send(); qc.codeLabel(''); cable.peek(); qc.nop(); qc.codeLabel('eve ' + i); if (0) eve_listen(); qc.codeLabel(''); qc.nop(); qc.nop(); qc.codeLabel('bob receive bit ' + i); if (0) bob_receive(); } var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR Eve is busted.\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } }	Ready.

(Under construction, Comms Dave & Co)
qc_options.circle_scale = 0.3; // Implment the RNG as a function function qrng(rng_reg) { rng_reg.write(0); rng_reg.beamsplitter(); return rng_reg.read(); } function alice_send() { // Alice sends a qubit cable.write(0); qc.codeLabel('LED control') var rbits = (qrng(rng) << 1) \| qrng(rng); rbits \|= 2; leds.write(1 << rbits); qc.codeLabel('filter'); qc.cnot(32, 4); qc.cnot(32, 16); qc.roty(45, 32, 16); qc.roty(45, 32, 8); var led_val = leds.read(); if (led_val & 3) qc.print('alice basis: + '); else qc.print('alice basis: X '); if (led_val & 5) qc.print('alice val: 0\n'); else qc.print('alice val: 1\n'); } function alice_send_silicon() { var theta = [[180, 0], // \|0> \|1> [270, 90]]; // \|+> \|-> qc.codeLabel('Alice'); var basis = qrng(rng); var value = qrng(rng); alice_bits = [basis, value]; alice_device.write(1); alice_device.dual_rail_beamsplitter(0.5, 1\|2); alice_device.phase(theta[basis][value], 1); alice_device.dual_rail_beamsplitter(0.5, 1\|2); alice_device.polarization_grating_out(1\|2, -1); } function eve_listen() { // Eve tries to spy var eve_bits = cable.read(); cable.write(eve_bits); } function bob_receive_silicon() { qc.exchange(32\|8); qc.codeLabel('Bob'); bob_device.polarization_grating_in(2\|4); // bob_device.write(4, 4); // bob_device.cnot(null, 4, 2); bob_device.write(0, 1); bob_device.dual_rail_beamsplitter(0.5, 1\|2); bob_device.write(0, 8); bob_device.dual_rail_beamsplitter(0.5, 4\|8); qc.exchange(32\|64); // version 1 // version 2 if (0) { bob_device.cnot(null, 1, 16); qc.rotx(45, 16, 8); bob_device.cnot(null, 1, 16); bob_device.dual_rail_beamsplitter(0.5, 1\|2); } // version 3 bob_device.dual_rail_beamsplitter(0.5, 1\|2); result = bob_device.read(1\|2\|4\|8); basis = (result & 3) ? 1 : 0; value = (result & 6) ? 1 : 0; bob_bits = [basis, value]; } function bob_receive_simple() { cable.exchange(bob_device); qc.codeLabel('BS'); bob_device.write(0, 2); bob_device.beamsplitter(0.5, 2); qc.codeLabel('rot'); bob_device.rotx(45, 1, 2); result = bob_device.read(1\|2); } function bob_receive_4_detector() { cable.exchange(bob_device); qc.codeLabel('BS'); bob_device.write(0, 16); bob_device.beamsplitter(0.5, 16); qc.codeLabel('rot'); bob_device.rotx(45, 1, 16); qc.codeLabel('PBS'); bob_device.write(2, 2\|4\|8); bob_device.cnot(null, 2, 1); bob_device.exchange(null, 1\|4, 16); bob_device.exchange(null, 2\|8, 16); result = bob_device.read(1\|2\|4\|8); } var bob_receive = bob_receive_silicon; //var bob_receive = bob_receive_simple; //var bob_receive = bob_receive_4_detector; var num_packets = 1; // perform the QKD this many times qc.reset(9); var rng = qint.new(1, 'rng'); //var leds = qint.new(4, 'LEDs'); var alice_device = qint.new(2, 'alice device'); var cable = qint.new(1, 'cable'); var bob_device = qint.new(5, 'bob device'); var alice_bits = []; var bob_bits = []; for (var i = 0; i < num_packets; ++i) { alice_send_silicon(); //qc.write(0); //cable.write(1, 1); //cable.rotx(45, 1); qc.codeLabel(''); // leds.peek(); qc.nop(); if (0) eve_listen(); qc.codeLabel(''); qc.exchange(4\|8); qc.nop(); qc.nop(); if (1) bob_receive(); qc.print('alice sends ' + alice_bits[0] + ',' + alice_bits[1] + ' '); qc.print('bob receives ' + bob_bits[0] + ',' + bob_bits[1] + ' '); if (alice_bits[0] != bob_bits[0]) qc.print('discard.\n'); else if (alice_bits[1] != bob_bits[1]) qc.print('Error! Eve is busted!\n'); else qc.print('Success!\n'); } /* var errors = 0; for (var i = 0; i < num_packets; ++i) { var av = alice_bits[i * 2]; var ah = alice_bits[i * 2 + 1]; var bh = bob_bits[i * 2]; var bv = bob_bits[i * 2 + 1]; if (ah == bh) { var status = ' ok\n'; if (av != bv) { errors++; status = ' ERROR Eve is busted.\n'; } qc.print('Bit ' + i + ': ' + av + ' -> ' + bv + status); } else { qc.print('Bit ' + i + ' discard\n'); } } */	Ready.

9. Pair sources
	qc.reset(4); qc.pair_source(2, 1); qc.read();	Ready.

10. Distinguishability and Mixed States Although the sim normally operates on pure states, there's a very common case in photonics where you can't be sure the photons are 100% indistinguishable, which causes faults in the quantum behavior.
Two photons Here we build a simple photonic circuit in a classic HOM-dip test, and then add some code to handle distinguishability-related imperfections. Try this: Run the program, then change the distinguishability to a new value in [0, 1] and run it again.
var distinguishability = 0.0; qc.reset(2); qc.write(3); qc.codeLabel('BS'); qc.start_photon_sim(); qc.dual_rail_beamsplitter(0.5, 1\|2); qc.stop_photon_sim(); qc.codeLabel(''); qc.peek(); qc.disableRecording(); // Now run the program multiple times var inputs = [3, 1, 2]; var out_probs = []; for (var index = 0; index < inputs.length; ++index) { qc.write(inputs[index]); qc.runLabel('BS'); out_probs.push(qc.copyAllProbabilities()); } var final_prob = qc.copyAllProbabilities(); var count = final_prob.length; for (var i = 0; i < count; ++i) final_prob[i] = 0; var p1 = out_probs[1]; var p2 = out_probs[2]; for (var i = 0; i < count; ++i) { var v1 = p1[i]; if (v1) { for (var j = 0; j < count; ++j) { var v2 = p2[i]; if (v2) { var bits = i \| j; final_prob[bits] += 0.5 * v1 * v2; } } } } // Now we have two arrays, one 100% dist and ine 100% ind. // Combine them. var d0 = distinguishability; var d1 = 1.0 - d0; for (var i = 0; i < count; ++i) { final_prob[i] = d0 * final_prob[i] + d1 * out_probs[0][i]; } console.log(out_probs[0]); console.log(out_probs[1]); console.log(out_probs[2]); console.log(final_prob); for (var i = 0; i < count; ++i) qc.print('\|' + i + '\| = ' + final_prob[i].toFixed(3) + '\n'); qc.pokeAllProbabilities(final_prob); qc.qReg.need_photon_rerun = false; // inhibit the auto-rerun (TODO: fix this) qc.enableRecording(); qc.qReg.staff.advanceToEnd();	Ready.
(Under Construction) This is an experiment.
qc.reset(2); qc.write(0); qc.hadamard(1); qc.cnot(2, 1); var mix1 = qc.push_mixed_state(); qc.write(0); qc.noise() var mix2 = qc.push_mixed_state(); var purity = 0.7; qc.use_mixed_state([[purity, mix1], [1-purity, mix2]]); qc.not(1); qc.not(1); qc.hadamard(2); qc.hadamard(2); Export	Ready.

QCEngine Hands-On Introduction

Welcome to the intro!

Why does QCEngine exist?

1. Basic operation

2. Entanglement

3. Teleportation

4. Cluster States

4b. Stabilizer Sim

5. Beam Splitters, Part 1

6. QKD

7. Integer Math

8. Beam Splitters, Part 2

9. Pair sources

10. Distinguishability and Mixed States