## Question:

A bit can only have two states: true and false. In quantum computing, the qubit , or quantum bit, was introduced, which can assume both **true and false simultaneously** . How is this represented in Boolean form?

Or rather, is it possible to represent a Boolean value with quantum programming?

```
operation boolParaQubit (q : bool) (Qubit) {
body {
let valorBooleano = q;
using (registrador = Qubit[1]) {
X(registrador(valorBooleano));
return M(registrador[0]);
}
}
}
```

When calling this procedure, the output is: `boolParaQubit(true) -> One`

. How would it look if this `Qubit`

didn't assume `Zero`

or `One`

?

## Answer:

While electrons or photons are often used to represent qubits, I prefer to use another fundamental particle of nature. The cat.

So, let's take a 3 qubit system of cats. Each cat, in order to function correctly as a qubit, must be isolated from the world. If it is somehow perceptible around the world, every exchange of quantum information (through bosons) will cause the cat's wavefunction to collapse and it will no longer behave like a qubit to behave like a bit. So we need to put it inside an electromagnetically opaque box.

Now, how do I read the 1 or 0 of the qubit? Well, we need to have two distinct cat states. With electrons, this measure can be the *spin* direction. But cats have a very difficult spin to measure, so we need another state.

**Alive** and **dead** , however, is easier to measure. But how to do this? Putting in some enriched uranium, a Geiger counter and a vial of cyanide; if the Geiger counter senses the radioactive emission from this uranium source, it will trigger a system that will release the cyanide and the cat will die immediately. We're going to put in enough uranium that, given the one hour gap, the chance of radioactive decay is 50%. Therefore, every hour, our cat will have the same possibility of being dead or of being alive.

According to the Copenhagen interpretation, this means that, to the outside world, our cat's qubit will be in an overlapping state of **living** and **dead** at the same time. In the pilot wave interpretation (defended by de Broglie), however, it is impossible to determine externally whether the cat is alive or dead, but it will be, deterministically, through some hidden variable, just alive or just dead.

The pilot wave theory has supposedly been falsified, but I don't have the reference. However, several experiments that demonstrate the inexistence of hidden variables were carried out, and there is also an experiment carried out that only makes sense in the Copenhagen interpretation.

So let's create our random number generation algorithm using 3 qubits of live cats. We will take `1`

as the **dead** cat and `0`

as the **live** cat. By measuring exactly one hour after starting the algorithm, each cat will have a 50% chance of being dead.

Initially we are in the following state:

```
q0 ; q1 ; q2
1|0> + 0|1> ; 1|0> + 0|1> ; 1|0> + 0|1>
```

To, after one hour, be in the following state:

```
q0 ; q1 ; q2
sqrt(2)/2|0> + sqrt(2)/2|1> ; sqrt(2)/2|0> + sqrt(2)/2|1> ; sqrt(2)/2|0> + sqrt(2)/2|1>
```

And, after another hour, it would be in the following state:

```
q0 ; q1 ; q2
1/2|0> + sqrt(3)/2|1> ; 1/2|0> + sqrt(3)/2|1> ; 1/2|0> + sqrt(3)/2|1>
```

What we just put together was a quantum random number generation algorithm. When, by chance, a classical system is to measure the state of the system, the function will collapse and it will only be in a deterministic state. For example, if after 1 step of quantum processing, we take the 3 qubits, we could take the number `010`

with the same probability of finding `001`

or `000`

. However, after 2 steps of quantum processing, the chance of finding `001`

is much smaller than `111`

.

Each quantum "step" is usually given another name: quantum gate (in the same sense as gates in logic circuits such as the AND gate or the OR gate). The function of a quantum gate, just like the traditional logic gate, is to take several inputs and return outputs that depend on those inputs. The difference between a classical and a quantum gate is that the classical one will do deterministic processing, while the quantum gate will take overlapping inputs (recall that `1|0> + 0|1>`

is a valid overlap, where you can only observe `0`

when measuring the qubit value) and will return outputs also overlapping.

Our quantum gate, in this case of random number generation, was the passage of time. Not that it's very helpful, but it's what I've been able to do using cats, uranium, and cyanide. In the case of quantum systems where you need to retrieve this information and use it in another calculation (whether quantum or classical), these gates usually involve things that interact with photons/electrons.

Can the qubit be represented in boolean?

According to the Copenhagen interpretation, what we know as a Boolean is a qubit that is constantly collapsing to the `1>`

or `0>`

. When we manage to stop observing this variable and place it in a quantum stochastic environment, it starts to assume the multiple values of the overlap until it is observed again.

So a boolean is a specific case of a qubit. And a qubit is an overlap of necessarily Boolean.

You can see more of quantum states/quantum computation in the following videos:

- The Quantum Experiment that Broke Reality – PBS Space Time
- Why Quantum Computing Requires Quantum Cryptography – PBS Space Time
- The Quantum Internet – PBS Space Time
- Hacking at Quantum Speed with Shor's Algorithm – PBS Infinite Series
- The Mathematics of Quantum Computers – PBS Infinite Series
- How Quantum Computers Break Encryption | Shor's Algorithm Explained – minutephysics
- How to Teleport Schrödinger's Cat – minutephysics
- Hardy's Paradox | Quantum Double Double Slit Experiment – minutephysics
- The No Cloning Theorem – minutephysics
- Bell's Theorem: The Quantum Venn Diagram Paradox – minutephysics
- Some light quantum mechanics (with minutephysics) – 3Blue1Brown
- Quantum Cryptography in 6 Minutes – Up and Atom
- Superposition of Quantum States – Up and Atom
- How Does a Quantum Computer Work? – Veritasium
- How To Make a Quantum Bit – Veritasium
- Single Photon Interference – Veritasium