Register

java.lang.Object
- org.mathIT.quantum.stabilizer.Register

```
public class Register
extends Object
```
This class represents the states of a quantum register. In general, a register state is given uniquely by a vector α ∈ ℂ^q-1 with its components α₀, α₁, ..., α_q-1 with respect to the q = 2ⁿ basis states |0>, |1>, ..., |q-1>, the computational basis. In other words,
α = (α₀, α₁, ..., α_q-1) = α₀ |0> + α₁ |1> + ... + α_q-1 |q-1>.
A qubit register as an object of this class then is given by the two arrays real[] and imaginary where real[j] = Re α_j and imaginary[j] = Im α_j for j = 0, 1, ..., q-1.

Version:

1.0

Author:

Andreas de Vries

Field Summary

Fields
Modifier and Type Field and Description

static double ACCURACY
The accuracy up to which calculations are done.

int size
The number of qubits of this register.

Fields
Modifier and Type	Field and Description
`static double`	`ACCURACY` The accuracy up to which calculations are done.
`int`	`size` The number of qubits of this register.

Constructor Summary

Constructors
Constructor and Description
`Register(int size)` Creates a register of n qubits, initialized to the state \|0>.
`Register(int size, boolean asGraphRegister)` Creates a register of n qubits, initialized to the state \|0>.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`cNOT(int j, int k)` Applies the c-NOT gate to this register, where j is the control qubit and k the target qubit.
`boolean`	`equals(Object o)` Returns true if and only if the specified object represents a quantum register which is physically equivalent to this register.
`Register`	`evaluateFunction(Register yRegister, FunctionParser function, int z)` Applies the function evaluation of a parsed function f(z) to the y-register.
`HashMap<Integer,ArrayList<Integer>>`	`getEntanglement()` Returns a map of a list containing the numbers of states being entangled with each other.
`GraphRegister`	`getGraphState()` Returns the graph register state representing this quantum register as long as it is a stabilizer state according to the Gottesman-Knill theorem.
`double[]`	`getImaginary()` Returns the array containing the imaginary parts of the qubit state components of this register.
`double[]`	`getReal()` Returns the array containing the real parts of the qubit state components of this register.
`int`	`getSize()` Returns the size of this quantum register.
`void`	`grover(int needle)` Performs a Grover operator, or Grover iteration step, on this quantum register.
`static int`	`groverSteps(int size)` The optimal number r of Grover iterations to successfully apply Grover's search algorithm.
`void`	`hadamard(int j)` Hadamard transformation of the j-th qubit.
`int`	`hashCode()` Returns the hash code of the current state of this quantum register.
`void`	`inverseGrover(int needle)` Applies the inverse of the Grover operator.
`void`	`inverseQft(int q, int size)` Applies the inverse quantum Fourier transform (QFT^-1) to this register.
`void`	`inverseSGate(int j)` Applies the inverse S gate to the j-th qubit.
`void`	`inverseSqrtX(int j)` Applies the inverse √X, or √NOT gate to the j-th qubit.
`void`	`inverseTGate(int j)` Applies the inverse T gate to the j-th qubit.
`boolean`	`isStabilizerState()` Indicates whether the current state of this quantum register is a stabilizer state.
`int`	`measure()` Returns the random value of a quantum measurement of this register.
`int`	`measure(int j)` Returns the random value of a quantum measurement of the j-th qubit of this register, j = 0, 1, ..., n - 1 where n is the size of this register.
`void`	`qft(int q, int size)` Applies the quantum Fourier transform (QFT) to this register.
`void`	`rotate(int[] cQubits, String axis, double phi)` Applies one of the three basic rotation operators R_x(φ), R_y(φ), or R_z(φ) to this register.
`void`	`setImaginary(double[] imaginary)` Returns the array containing the imaginary parts of the qubit state components of this register.
`void`	`setReal(double[] real)` Returns the array containing the real parts of the qubit state components of this register.
`void`	`sGate(int j)` Applies the S gate to the j-th qubit.
`String`	`show(int nMax)` Returns a string representation of the first `nMax` qubits of this register.
`void`	`sqrtX(int j)` Applies the √X, or √NOT gate to the j-th qubit.
`void`	`tGate(int j)` Applies the T gate to the j-th qubit.
`void`	`toffoli(int j1, int j2, int k)` Applies the Toffoli gate to this register.
`String`	`toString()` Returns a string representation of this register.
`String`	`toString(int nMax)` Returns a string representation of the first `nMax` qubits of this register.
`void`	`xPauli(int j)` Applies the Pauli-X gate to the j-th qubit; on a classical bit, the X gate acts equally to a a classical NOT.
`void`	`yPauli(int j)` Applies the Pauli-Y gate to the j-th qubit.
`void`	`zPauli(int j)` Applies the Pauli-Z gate to the j-th qubit.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail
- ACCURACY
```
public static final double ACCURACY
```
  The accuracy up to which calculations are done. Its actual value is 1.0E-12.
  
  See Also:
  
  Constant Field Values
- size
```
public int size
```
  The number of qubits of this register.

Constructor Detail
- Register
```
public Register(int size)
```
  Creates a register of n qubits, initialized to the state |0>. A register of size n enables a total of q = 2ⁿ quantum states as the computational basis.
  
  Parameters:
  
  size - the number of qubits this register consists of
- Register
```
public Register(int size,
                boolean asGraphRegister)
```
  Creates a register of n qubits, initialized to the state |0>. A register of size n enables a total of q = 2ⁿ quantum states as the computational basis. If the specified argument asGraphRegister is set true, this register is represented efficiently as a graph state consisting of n vertices representing the n qubits. If asGraphRegister is set false, this register is represented by two double arrays of size 2ⁿ storing the complex amplitudes.
  
  Parameters:
  
  size - the number of qubits this register consists of
  
  asGraphRegister - indicates whether this register shall be represented as a graph state

Method Detail

getSize
```
public int getSize()
```
Returns the size of this quantum register. I.e., the number of its qubits.

Returns:

the size of this quantum register

setReal
```
public void setReal(double[] real)
```
Returns the array containing the real parts of the qubit state components of this register.

Parameters:

real - array of the real parts of this quantum register

Throws:

IllegalArgumentException - if real.length is not equal to 2ⁿ where n is the size of this register

getReal
```
public double[] getReal()
```
Returns the array containing the real parts of the qubit state components of this register.

Returns:

array of the real parts of this quantum register

setImaginary
```
public void setImaginary(double[] imaginary)
```
Returns the array containing the imaginary parts of the qubit state components of this register.

Parameters:

imaginary - array of the imaginary parts of this quantum register

Throws:

IllegalArgumentException - if imaginary.length is not equal to 2ⁿ where n is the size of this register

getImaginary
```
public double[] getImaginary()
```
Returns the array containing the imaginary parts of the qubit state components of this register.

Returns:

array of the imaginary parts of this quantum register

isStabilizerState
```
public boolean isStabilizerState()
```
Indicates whether the current state of this quantum register is a stabilizer state. Stabilizer states are a certain class of quantum register states which can be efficiently simulated by a classical computer according to the Gottesman-Knill theorem.

Returns:

true if and only if this quantum register is in a stabilizer state

getGraphState
```
public GraphRegister getGraphState()
```
Returns the graph register state representing this quantum register as long as it is a stabilizer state according to the Gottesman-Knill theorem. If this register is not a stabilizer state, the graph register state is null.

Returns:

the graph register state representing this quantum register

getEntanglement
```
public HashMap<Integer,ArrayList<Integer>> getEntanglement()
```
Returns a map of a list containing the numbers of states being entangled with each other.

Returns:

map of a list containing the numbers of states being entangled with each other

hadamard
```
public void hadamard(int j)
```
Hadamard transformation of the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

cNOT
```
public void cNOT(int j,
                 int k)
```
Applies the c-NOT gate to this register, where j is the control qubit and k the target qubit.

Parameters:

j - the control qubit

k - the target qubit

xPauli
```
public void xPauli(int j)
```
Applies the Pauli-X gate to the j-th qubit; on a classical bit, the X gate acts equally to a a classical NOT. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

yPauli
```
public void yPauli(int j)
```
Applies the Pauli-Y gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

zPauli
```
public void zPauli(int j)
```
Applies the Pauli-Z gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

sGate
```
public void sGate(int j)
```
Applies the S gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

inverseSGate
```
public void inverseSGate(int j)
```
Applies the inverse S gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

tGate
```
public void tGate(int j)
```
Applies the T gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

inverseTGate
```
public void inverseTGate(int j)
```
Applies the inverse T gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

sqrtX
```
public void sqrtX(int j)
```
Applies the √X, or √NOT gate to the j-th qubit. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

inverseSqrtX
```
public void inverseSqrtX(int j)
```
Applies the inverse √X, or √NOT gate to the j-th qubit. We have √X^-1 = √X³. Note that 1 ≤ j ≤ n, where n is the quantum register size. The register is transformed directly.

Parameters:

j - the number of the qubit (1 ≤ j ≤ qubit size).

toffoli
```
public void toffoli(int j1,
                    int j2,
                    int k)
```
Applies the Toffoli gate to this register. Here j₁ and j₂ are the control qubits and k is the target qubit.

Parameters:

j1 - the first control qubit

j2 - the second control qubit

k - the target qubit

qft

public void qft(int q,
                int size)

Applies the quantum Fourier transform (QFT) to this register. For each computational basis state |j> it is defined as:

QFT( |j> )

√q

q - 1

k = 0

e^2πijk/q |k>.

Here q denotes the total number of different basis states of the register. If q = 2ⁿ where n is the number of qubits of this register, then the fast Fourier transform is applied. Otherwise, a new quantum register with size basis states is created from this register where only the first q register states are transformed. Note that both q and size must be less than or equal 2ⁿ where n is the qubit size of this register.

Parameters:: q - the total number of register basis states |0>, |1>, ..., |q - 1> to be transformed; size - the number of register basis states of the transformed register
See Also:: inverseQft(int,int)

inverseQft

public void inverseQft(int q,
                       int size)

Applies the inverse quantum Fourier transform (QFT^-1) to this register. For each computational basis state |j> it is defined as:

QFT^-1( |j> )

√q

q - 1

k = 0

e^2πijk/q |k>.

Here q denotes the total number of different basis states of the register. If q = 2ⁿ where n is the number of qubits of this register, then the inverse fast Fourier transform is applied. Otherwise, a new quantum register with size basis states is created from this register where only the first q register states are transformed. Note that both q and size must be less than or equal 2ⁿ where n is the qubit size of this register.

Parameters:: q - the total number of register basis states |0>, |1>, ..., |q - 1> to be transformed; size - the number of register basis states of the transformed register
See Also:: qft(int,int)

rotate
```
public void rotate(int[] cQubits,
                   String axis,
                   double phi)
```
Applies one of the three basic rotation operators R_x(φ), R_y(φ), or R_z(φ) to this register. Here a basic rotation operator represents a rotation with an angle φ about the axis x, y, or z, respectively.

Parameters:

cQubits - an array containing the control qubits and, as its last entry, the target qubit

axis - a string representing the axis, i.e., either "x", "y", or "z"

phi - the rotation angle in radians

evaluateFunction
```
public Register evaluateFunction(Register yRegister,
                                 FunctionParser function,
                                 int z)
```
Applies the function evaluation of a parsed function f(z) to the y-register. This method modifies the input y-register.

Parameters:

yRegister - the y-register where the function values are stored

function - the parsed function f(z)

z - the value at which f(z) is to be evaluated

Returns:

the y-register after the evaluation of f(z), regarding entanglement

Throws:

BufferOverflowException - if y-register is too small to store all function values

grover
```
public void grover(int needle)
```
Performs a Grover operator, or Grover iteration step, on this quantum register. A Grover iteration consists of the following steps:
1. Apply an oracle query which assigns +1 to each value which is different from the searched for value (the "needle"), and -1 to the value which is searched for;
2. Apply an n-fold Hadamard on the entire register
3. Apply the conditional phase shift of -1, -I₀, defined by -I₀(|0>) = |0> and
  -I₀(|x>) = -|x> if x ≠ 0.
4. Apply an n-fold Hadamard on the entire register
The iteration step is described in M.A. Nielsen & I.L. Chuang: Quantum Computation and Quantum Information. Cambridge University Press, Cambridge, 2000, §6.1.2.
In practice, an oracle could be a cryptologic algorithm in a known-plaintext attack which applies a secret key to a given ciphertext and yields -1 if the deciphered text equals the known plaintex, and +1 otherwise.
Parameters:

needle - the value to be searched for

Throws:

IllegalArgumentException - if the needle value is out of register range

inverseGrover
```
public void inverseGrover(int needle)
```
Applies the inverse of the Grover operator.

Parameters:

needle - the value to be searched for

See Also:

grover(int)

groverSteps

public static int groverSteps(int size)

The optimal number r of Grover iterations to successfully apply Grover's search algorithm. It is given by

r ≈

4 arcsin(2^-n/2)

≈

2^n/2 π

= 2^{(n - 4)/2} π

where n ≥ 2 is the size of the register, i.e., the number of its qubits.

Parameters:: size - the size of the register
Returns:: the optimal number of Grover iterations

measure
```
public int measure()
```
Returns the random value of a quantum measurement of this register. A quantum measurement makes the register collapse randomly to one of the qubits |j>. Here the probability for a collapse to qubit |j> is determined by the squared absolute value of the probability amplitudes α_j, i.e. of the array values real[j]² + imaginary[j]².
To implement the random collapse, a random number f with 0 ≤ f < 1 is chosen. Then successively the probabilities of the single qubits are subtracted, starting with the first qubit state |0>, until f gets negative. The last qubit |j> that caused the sign change is the measured qubit state.

Returns:

the measured (random) value

See Also:

measure(int)

measure
```
public int measure(int j)
```
Returns the random value of a quantum measurement of the j-th qubit of this register, j = 0, 1, ..., n - 1 where n is the size of this register. Such a quantum measurement makes the measured qubit collapse randomly to 0 or 1, determined by the probability amplitudes of all states |m> where m contains either a 0 or a 1 at position j. Here the probability for a collapse to the value "0" is determined by the squared absolute values of the probability amplitudes α_m, i.e., of the array values real[m]² + imaginary[m]², where |m> has a 0 at position j.
All qubits in the register vanish if they are entangled with the qubit state corresponding to the value not measured: if "0" is measured, these are the states |m> with m & 2^j-1 = 0, if "1" is measured, these are |m> with m & 2^j-1 > 0. The probability amplitudes of the remaining states must be normalized such that the whole register is in a unit state.
To implement the random collapse, a random number f with 0 ≤ f < 1 is chosen. If f < Σ |α_m|², where m & 2^j-1 = 0, the measured value is "0", otherwise it is "1".

Parameters:

j - the qubit to be measured

Returns:

the measured (random) value

See Also:

measure()

equals
```
public boolean equals(Object o)
```
Returns true if and only if the specified object represents a quantum register which is physically equivalent to this register. Two quantum registers are physically equivalent if their qubit amplitudes only differ by an overall phase. Amplitudes are compared up to the accuracy specified by ACCURACY.

Overrides:

equals in class Object

Parameters:

o - the specified reference with which to compare

Returns:

true if the object is a quantum register physically equivalent to this register

hashCode
```
public int hashCode()
```
Returns the hash code of the current state of this quantum register.

Overrides:

hashCode in class Object

Returns:

the hash code of the current state of this quantum register

show
```
public String show(int nMax)
```
Returns a string representation of the first nMax qubits of this register.

Parameters:

nMax - specifies the maximum number of considered qubits

Returns:

a string representation of the first nMax qubits of this register

toString
```
public String toString(int nMax)
```
Returns a string representation of the first nMax qubits of this register.

Parameters:

nMax - specifies the maximum number of considered qubits

Returns:

a string representation of the first nMax qubits of this register

toString
```
public String toString()
```
Returns a string representation of this register.

Overrides:

toString in class Object

Returns:

a string representation of this register

Class Register

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ACCURACY

size

Constructor Detail

Register

Register

Method Detail

getSize

setReal

getReal

setImaginary

getImaginary

isStabilizerState

getGraphState

getEntanglement

hadamard

cNOT

xPauli

yPauli

zPauli

sGate

inverseSGate

tGate

inverseTGate

sqrtX

inverseSqrtX

toffoli

qft

inverseQft

rotate

evaluateFunction

grover

inverseGrover

groverSteps

measure

measure

equals

hashCode

show

toString

toString