# QWave Controlled Gates

A QWave controlled gate encodes a wave function from an outside (real world) quantum state from some quantum system to one or more target qubits. For example, uranium ore emits a radioactive ion (which is a quantum event) at a rate shown in the graph below. The y axis is the probability, and the x axis is the time between emissions. There is a higher probability of emissions occurring rapidly and subsequently a lower probability that there is a significant long (in milliseconds) gap between emissions.

## Encoding A Wave Equation To Multiple Qubits

One way (hereby referred to as `ManyBits`

) we could encode the wave equation to multiple bits is to simply create a bit representation of the scaled emission time (the x axis above). For example, if we have a four qubit register and we want to apply an emission of 3 milliseconds, we would convert the 3 to binary 1100 (leftmost least significant bit), then apply a chosen gate to the first two qubits in the register. This is what that would look like in a circuit where X is the gate being applied:

```
{
"qubit_count" : 4,
"gates": [
{
"gate_type": "X",
"target_qubits": [0,1,2,3],
"qwave_control": "UraniumOre1:ManyBits"
}
]
}
```

Another way (hereby referred to as `OneBit`

) we could encode the wave equation to multiple bits is to scale the number of bits to the x axis of the graph above and chose only a single bit based upon where the emission time landed. Considering a four qubit register again, a 3-millisecond emission time would convert to binary 1000 - the first bit is the only bit set because this is where a 3 would end up if the graph x axis were divided into four. This is what the same circuit would look like with `OneBit`

set:

```
{
"qubit_count" : 4,
"gates": [
{
"gate_type": "X",
"target_qubits": [0,1,2,3],
"qwave_control": "UraniumOre1:OneBit"
}
]
}
```

To better illustrate the difference between encoding using `ManyBits`

vs. `OneBit`

, here is how the above wave equation would be encoded on a ten qubit register with these two encoding methods:

With the `OneBit`

setting, one can see the probability of the given qubit (shown in the x axis) having the chosen gate applied to just it. With `ManyBits`

, one can see the probability of any qubit having the chosen gate applied - the first qubit for example would have approximately a 50/50 probability.

## Encoding A Wave Equation to An R-Value

To encode the wave equation into the phase of a single qubit, then the emission event can simply be encoded into the `rvalue`

of the appropriate gate. In this case, the emission time is converted to a percentage (the x axis becomse a decimal number from 0 to 1) and then multiplied by the given rvalue. According to the graph above, this would mean a very low probability of the `rvalue`

being multiplied by 1.0. This is what a `rvalue`

encoded wave equation would look like:

```
{
"qubit_count" : 2,
"gates": [
{
"gate_type": "Rx",
"target_qubits": [0],
"rvalue": 6.2831853,
"qwave_control": "UraniumOre1:RValue"
},
{
"gate_type": "Ry",
"target_qubits": [1],
"rvalue": 6.2831853,
"qwave_control": "UraniumOre1:RValue"
}
]
}
```

## Entanglement?

Note that the next two sections are purely theoretical and should be prefaced with "arguably"...

### ManyBits Entanglement

When a qubit register is encoded using the `ManyBits`

method, then the entire register is immediately entangled since a single quantum state was used to set every qubit. Any (or all) qubits measured would have to collapse in a way that yields the bits within the original quantum state.

### Temporal Entanglement

In the last example above showing `rvalue`

encoding, notice that two quantum states are used one after another. This directly corresponds to two emissions and given the quantum state source (`UraniumOre1`

) is the same, then these emissions are potentially entangled across time.