Craig Gidney

That's not correct; you cannot use a double-slit test to check for entanglement. Running a photon through a double-slit setup always just produces a single dot, not a any sort of pattern. To get a pattern, you need to run a bunch of photons through it and see if a fringe pattern appears [1].

(BTW, you never get a two-line pattern in a decent setup. This is an incredibly common mistake, but it's simply wrong. The interference (which produces fringes) only happens where the separate patterns from the two slits overlap, so if you want a lot of interference, you need them to overlap a lot. So in the no-interference case, you won't get two separate lines with a gap between, you'll get a single merged wash (with probably some fine structure due to diffraction within each of the slits, but that'll also be there when there is interference, on top of the two-slit interference fringes).)

You might think "ok, I'll do this with a bunch of photons, measure/not measure all of their twins, and see if the bunch of them show fringes." This is more-or-less what's done in the delayed-choice quantum eraser experiment, but it doesn't work out in a way that allows communication. What happens is that you always get the no-interference pattern. In order to see interference fringes, you need to split the individual photons' dots up based on the result of the measurement you made on their twins. Based on those measurements (if you made them), you can split the photons up into two groups, which'll…

Well, we'll see how small the elaboration is... :)

A brief review of how quantum teleportation works. (I have a diagram in quirk that might help with the explanation

https://algassert.com/quirk#circuit=%7B%22cols%22:%5B%5B1,%22H%22%5D,%5B1,%22%E2%80%A2%22,%22X%22%5D,%5B%22%E2%80%A6%22,%22%E2%80%A6%22,%22%E2%80%A6%22%5D,%5B%22X%5Et%22%5D,%5B%22%E2%80%A6%22,%22%E2%80%A6%22,%22%E2%80%A6%22%5D,%5B%22Bloch%22%5D,%5B%22%E2%80%A2%22,%22X%22%5D,%5B%22H%22%5D,%5B%22Measure%22,%22Measure%22%5D,%5B%22%E2%80%A2%22,1,%22Z%22%5D,%5B1,%22%E2%80%A2%22,%22X%22%5D,%5B1,1,%22Bloch%22%5D%5D%7D)

You start off with two qubits in a known state, say |0>. You then shift one of the qubits (using a Hadamard gate) into a equally mixed state of

qubit_1 = k(|0>+|1>)

and then use a controlled NOT gate to put the entire system in the state of

qubit_2 = k(|00>+|11>)

(where k = 1/sqrt(2)).

So you then ship one of the qubits off to your friend in Antarctica (say, qubit_1). You then pull out qubit_3. Now, let's say it's also in some known state |0> to begin with, and then you apply a bunch of gate operations to it, resulting in it being in the following state:

qubit_3 = a|0> + b|1>

Where a and b are two complex numbers whose magnitude sums to one.

You use another controlled not gate, this time, qubit_3 will act on qubit_2. This now has entangled qubit_3 into the qubit_1 and qubit_2 system. Finally, you apply another Hadamard gate to qubit_3. The system is now in the following state

|Psi> = …

Hi,

I personally have a similar background to you, with ~15 years of software engineering.

I second some of the comments: I really started understanding quantum computing much better when I sat down and worked through the problems of the Nielsen and Chuang book ("Mike & Ike") - the first 4 chapters should give you a solid start. It starts from theoretical base and does cover some of the applications of QCs as well, though from that perspective there are a bunch of newer results that are not represented in it yet (e.g. QAOA/VQE, NISQ era algorithms, etc.). Some basic linear algebra is definitely needed though, it takes effort and practice to build up familiarity there if you are rusty on it (I was).

Also, I would like to plug open source contribution as a vehicle / forcing function for learning. I started contributing to Cirq (https://github.com/quantumlib/Cirq) starting last year in my free time (as well as some of my work time at Google) and I learned a ton through that. I now work on Cirq full time. OpenFermion, qsim, Tensorflow Quantum are all projects that are excited to have new contributors.

The reason I mention my journey because it shows that you don't need formal training in quantum physics to become productive in the quantum computing community (it can definitely help though). However, the field is very deep and is moving very fast, I very much consider myself a noob and rely heavily on the expertise of others for contributions, and I spend a lot of time…

> But there is more to try–the Beginner’s Guide has a number of different experiments available—from Bit-flip encoders, to Grover’s and Shor’s algorithms. Am I ready to understand a quantum score like this? Well, maybe not just yet. Some day though…

The enthusiasm! I love it. However...

I remember reading a post from Algorithmic Assertions[1] which gave a wonderful example of the use of intuition in designing/transforming a quantum circuit. He walks through every step, starting with a simple swap circuit and ending with a proof of quantum teleportation. It was kind of magical to see all the tricks used. Inserting CNOTS in order to optimize out certain gates? Knowing that controlled-Z gates are equivalent if flipped around? Transposing H gates with X or Z gates to turn an X into a Z and vice versa?

I stress the importance of the steps here, because if your goal is to be able to build fancy quantum scores, it isn't enough, most likely, to just read the Beginner's guide and grok Shor's algorithm -- it's really important to have the intuition needed to write your own algorithms. It is exactly like learning how to code again.

[1]: http://algassert.com/post/1628

QC simulation (qubits only, no dedicated vis) is much easier. You just make a vector, and multiply it by matrices. Here for Python interface I like QuTiP even more than Qiskit (though, I might be biased, as I contributed to the former). For interactive, IBM Quantum Computing Experience and Quirk (https://algassert.com/quirk).

As "easier" I mean that 2^10 is still managable, as you can use dense vectors and operators. For, say, this quantum optics simulation you get roughly 1000 dimensions per particle. For 3 particles it is 10^9. Don't even think about dense vectors, let alot - dense operators. Sparse operators are not enough, as even identity is big; so for any real-time-ish simulation there are considerably more tricks and methods.

Simulting QFT you need to deal with much more complexity (including continuous dimensions). Instead of numerically pretty much you need to solve some intergrals. (Side note: I wanted at some point to write an interactive editor of Feynman diagrams, turning it into formulae and integrating.)

Somewhat related is the work done in "Falling with Style: Factoring up to 255 “with” a Quantum Computer" published in the proceedings of SIGBOVIK 2025 [1]. The author, Craig Gidney [2], successfully factored all odd composite numbers up to 255 using Shor's algorithm, even though the quantum circuits involved were such that any meaningful output would be overwhelmed by noise (and indeed, performance was maintained when the circuits were replaced by a random number generator).

> To my knowledge, no one has cheated at factoring in this way before. Given the shenanigans pulled by past factoring experiments, that’s remarkable.

[1] https://sigbovik.org/2025/; standalone paper is also available in the code repository https://github.com/strilanc/falling-with-style

[2] Who has previous experience in cheating at quantum factoring: see "Factoring the largest number ever with a quantum computer", posted April Fools' Day 2020 at https://algassert.com/post/2000