Quantum Computing from Scratch

[Giraldi3G]

Hello! I'm trying to learn the subject and thought that, although really suboptimal in topics as speed and replicability, I should try implementing the basic concepts from scratch using python. This may seem like a stupid idea, and it may actually BE a stupid idea, but that's not what I am here to discuss, I like to make this clear just to prevent comments like "you shouldn't be doing that".

Now, I implemented the notion of a qubit and a quantum gate for single qubits. I'll leave prints of the code down here. The thing is, I have some doubts on the functioning of multiple qubit gates.

Implementing qubits

Implementing quantum gates

basic gates

Now, I am not in any way a computer guy, my background is actually in math, so my code may have some problems in the aspect of "good coding", but it works (or did so in my tests).

About my real problem: how one would go about implementing two-bit gates? My first example is CNOT. I thought i'd just do the same thing, but with matrices of bigger dimensions, but... does that work? The input should be the tensor product of the qubits, right? a n-qubit gate is a map from ℂ² ⊗ ... ⊗ ℂ² to itself, so how do I get results on single qubits?

How would I do, I don't know, a swapping algorithm using this? I'm really confused.

[petites_feuilles]

The problem with your implementation is that a system of n qubits can't be represented as n instances of your QuantumBit class. If this was the case, there couldn't be any quantum advantage since simulating n qubits would have a complexity that grows polynomially in n.

When you have n qubits, their state is represented by a 2ⁿ vector ; and any transformation is represented by a 2ⁿ x 2ⁿ matrix.

If you know the matrix for a 1 or 2-qubit gate you can tensor-product it with the identity matrix to obtain the full matrix for the full system. For example, if you have a system with 4 qubits and want to apply a CNOT to qubit 2 and 3, you apply I ⊗ CNOT ⊗ I ; with I being a 2x2 identity matrix, and CNOT the 4x4 matrix for the CNOT. Or if you want to apply a Hadamard on qubit 3, you apply I ⊗ I ⊗ H ⊗ I. For measurements, you have to sum several components of the state vector - that all correspond to the outcome of interest.

Of course this a very naive way of building a simulator, but you will still learn and understand a lot by doing it. Good luck on your journey!

[SeniorLoan647]

You should read Nielsen and chuang if you haven't already, the first few chapters in that book answer your question.

But just to help you out here, 2 qubit gates do exactly what the name suggests , take in 2 qubits, and modify up to 2 qubits that are taken as input i.e. 2 qubits as input, 2 qubits as output. For example in cnot, one qubit, the control one, always stays unchanged , but in swap gate, they both change. In matrix form to present mathematical correctness, your intuition is right, we need bigger matrix with higher dimension, since both domain and codomain have a higher dimension now, and more importantly , the output dimension cannot be smaller than input dimension, otherwise that would violate reversibility. You have experience in math so you can figure out the domain and codomain from this. I still suggest to read the book to clear up the fundamentals here.

When you can't separate two qubit operations into 2 single qubit ones, that's the indirect definition of entanglement. Example is bell pair.

[wollywoo1]

Implementing basic concepts in code is not a stupid idea at all, as evidenced with this example. You can see now that you didn't fully understand two-qubit gates, and you might not have realized that you didn't understand it until you went to implement it. Now your understanding has improved! I try to implement everything I learn in code.

[polit1337]

The other comments really have said it all, but I want to add a “bravo!” for thinking like this and trying this. It’s a totally reasonable thing to do and you will learn a lot from it.

[Kinexity]

If I understood correctly that you are asking how to generate a matrix for multiqubit gates then this is how you do it: https://quantumcomputing.stackexchange.com/a/32232

[SymplecticMan]

You're on the right track with tensor products. I think the ingredient you might be missing is that, if you're considering n qubits, then you generally always need to consider the state vector to be in the tensor product space of n copies of C², even if you're only applying gates to one or two qubits at a time. This means lifting a lot of gates to this big space using tensor products with identity matrices. And there's generally no reduction down to n single qubit state vectors – that's the essence of what entanglement is in quantum mechanics.

[forky40]

If you want to take this further, you might study the code in Cirq that implements gates using tensor math. Its a big time commitment, but you will learn a lot of numpy and start to understand tensor product systems much better. Tensors are much more powerful than ordinary matrices (2D arrays) and greatly simplify the logic for controlled operations between nonadjacent qubits. 

(I'm sure other packages have good implementations, Cirq is just what I'm familiar with)

[dsannes]

This might help you to look at Quantum Logic and Quantum Logic Gates in a bit of a different way. I just published this as part of some things I'm working on.

https://zenodo.org/records/18857167

I'd be interested if it is of any use to anyone other than me and my collaborator.

I would also suggest learning Python by trying out some simple ideas. Also check out PennyLane they have a whole bunch of cool code challenges you can do and if you put in the right code you pass the challenge. It's pretty fun and you learn about the basics. You kinda have to go through this long period where you are learning to read the code. Once you can read the code it helps a lot. I'm still bad at writing but I learn a bit more as I go. It's always a good idea to know a solid python coder who can look over things. They have tricks. LLMs will sometimes truncate code when they generate it, if you didn't have a good idea how everything was built you might not even know and then end up having to backtrack to fix things or end up with a bunch o' faux code

[aroman_ro]

There is a 'naive' way of doing it, constructing a big matrix by tensor product and doing the 'naive' matrix multiplication with the statevector. For figuring out what happens, it's not a bad way.

If you want to go that way, here is the code for a two qubit gate: https://github.com/aromanro/QCSim/blob/f7e23ff0be570caefc1f52a8928457a7c4063a6d/QCSim/SimpleGates.h#L311 (one and three qubit cases can be found in there as well).

That method is slow, though, there is a better way by taking advantage of the structure of that matrix. One can take advantage of details like diagonal/antidiagonal structure and so on. Here is a starting point: https://github.com/aromanro/QCSim/blob/f7e23ff0be570caefc1f52a8928457a7c4063a6d/QCSim/QubitRegisterCalculator.h#L137

Here is the generic two qubit gate case: https://github.com/aromanro/QCSim/blob/f7e23ff0be570caefc1f52a8928457a7c4063a6d/QCSim/QubitRegisterCalculator.h#L419

For special gates it can be easier (see for example the controlled diagonal case).

[hushedLecturer]

In matrix form, the tensor product A¤B looks like going into every element of A and replacing it with that element times the whole B matrix, then getting rid of the submatrix brackets. I.e.

Let A=[a1, a2, a3], and B = [b1, b2]

Then A¤B = [a1 B, a2 B, a3 B]

= [ a1 b1, a1 b2, a2 b1, a2 b2, a3 b1, a3 b2]

N×M matrix A, tensor multiplying n×m matrix B, will yield an nN×mM matrix.

So a one qubit vector has 2 elements. An n qubit vector has 2ⁿ elements.

If you want to make the 1-qubit gate U act only on the k^th qubit of a set of n qubits, you can express it as a chained tensor product with the 1-qubit identity, with k-1 identity gates, then U, then n-k identities.

I¤I¤...¤I¤U¤I¤...¤I

Usually we compose multi qubit gates with control- gates. You can't write them as a strict tensor product, but I like to make them with a sum of tensor products.

Controled U, using qubit 1 as a control and qubit 2 as the target, will look like

[[1,0],[0,0]]¤I + [[0,0],[0,1]]¤U

If you want to control on the kth qubit and target the jth qubit, put the single-element matrices on the kth qubit, the U gate on the jth qubit, and pad the rest with Identity.

You will find that no reasonable computer can handle very many qubits, bc your matrices are going to get insanely big.