Statistical Operations#

Statistical operations are simulator specific mathematical operations allowing you to compute properties of the simulated quantum state without making it collapse. All statistical operations will result in a real or complex number that will be stored in the Z-Register, and can be accessed from the results of the simulation through the zstates option, see Circuits and cloud execution page.

On this page you will find all statistical operations available on MIMIQ with explanations and examples.

Contents#

Expectation value #

Mathematical definition #

An expectation value for a pure state $| ψ ⟩$ is defined as

⟨ O ⟩ = ⟨ ψ | O | ψ ⟩

where $O$ is an operator. With respect to a density matrix $ρ$ it’s given by

⟨ O ⟩ = Tr (ρ O) .

Usage on MIMIQ #

First we need to define the operator $O$ of which we will compute the expectation value

>>> op = SigmaPlus()

SigmaPlus is only one of the many operators available. Of course, every gate can be used as an operator, for example op = GateZ(). However, MIMIQ also supports many non-unitary operators such as SigmaPlus, more about this on the Operators page.

To ask MIMIQ to compute the expectation value for a circuit you can create an ExpectationValue object and push() it to the circuit like this:

>>> circuit = Circuit()
>>> circuit.push(GateH(), 0)
1-qubit circuit with 1 instructions:
└── H @ q[0]


>>> # Ask to compute the expectation value
>>> ev = ExpectationValue(op)
>>> circuit.push(ev, 0, 0)
1-qubit circuit with 2 instructions:
├── H @ q[0]
└── ⟨SigmaPlus(1)⟩ @ q[0], z[0]

As for all statistical operations, the arguments to give to the push() function always follow the order of quantum register index first, classical register second (none in this case), and Z-register index last.

In the example above, the first 0 is the index for the first qubit of the quantum register and the second 0 is the index of the Z-Register.

Notice that the expectation value will be computed with respect to the quantum state of the system at the point in the circuit where the ExpectationValue is added.

Entanglement #

MIMIQ supports statistical operations on entanglement for ordered bipartitions. For instance, for qubits [1...N] MIMIQ can compute the entanglement between the bipartitions [1...k-1] and [k...N].

For this reason when you push() an entanglement operation to a circuit, you need to give it the qubit index k that separates the two bipartitions, as well as the Z-register to store the result.

Warning

The following functions can only be used with the MPS backend.

Von Neumann Entropy #

Mathematical definition#

The entanglement entropy for a bipartition into subsystems A and B is defined for a pure state $ρ = | ψ ⟩ ⟨ ψ$ | as

S (ρ_{A}) = - Tr (ρ_{A} \log_{2} ρ_{A}) = - Tr (ρ_{B} \log_{2} ρ_{B}) = S (ρ_{B})

where $ρ_{A} = {Tr}_{B} (ρ)$ is the reduced density matrix. A product state has $S (ρ_{A}) = 0$ and a maximally entangled state between A and B gives $S (ρ_{A}) = 1$ .

We only consider bipartitions where $A = {1, \dots, k - 1}$ and $B = {k, \dots, N}$ , for some k and where N is the total number of qubits.

Usage on MIMIQ#

The entanglement entropy for a bipartition into subsystems A and B can be obtained using the VonNeumannEntropy function.

You do not need to provide any argument to VonNeumannEntropy. To indicate where to create the separation into two subsystems MIMIQ will use the first qubit index given to the push() function, here is an example:

>>> circuit = Circuit()
>>> # Asking to compute the Von Neumann entropy between the two subsystems separated between qubit 1 and 2
>>> circuit.push(VonNeumannEntropy(), 2, 0)
3-qubit circuit with 1 instructions:
└── VonNeumannEntropy @ q[2], z[1]

Here we compute the Von neumann entropy between the two subsystems [1,2] and [3...N] and write the results into the index 0 of the Z-register.

Note

For k=1, A is empty and the Von Neumann entropy will always return 1.

Bond Dimension #

Mathematical definition#

The bond dimension is only defined for a matrix-product state (MPS), which can be written as (with $i_{1} = i_{N + 1} = 1$ )

| ψ ⟩ = \sum_{s_{1}, s_{2}, \dots = 1}^{2} \sum_{i_{2}}^{χ_{2}} \sum_{i_{3}}^{χ_{3}} \dots \sum_{i_{N}}^{χ_{N}} A_{i_{1} i_{2}}^{(s_{1})} A_{i_{2} i_{3}}^{(s_{2})} A_{i_{3} i_{4}}^{(s_{3})} \dots A_{i_{N} i_{N + 1}}^{(s_{N})} | s_{1}, s_{2}, s_{3}, \dots, s_{N} ⟩ .

Here, $χ_{k} ‘$ is the bond dimension, i.e. the dimension of the index $i_{k}$ . The first and last bond dimensions are dummies, $c h i_{1} = c h i_{N + 1} = 1$ . A bond dimension of 1 means there is no entanglement between the two halves of the system.

Usage on MIMIQ#

To compute the bond dimension between two halves of a system you can use the BondDim operator and push() to the circuit like any entanglement measure:

>>> circuit = Circuit()
>>> # Asking to compute the BondDim between the second and third qubits
>>> circuit.push(BondDim(), 2, 0)
3-qubit circuit with 1 instructions:
└── BondDim @ q[2], z[0]

Here we compute the bond dimension between the two subsystems [1,2] and [3...N] and write the results into index 0 of the Z-Register.

Note

For k=1 the bond dimension returned will always be 1.

Schmidt Rank #

Mathematical definition#

A Schmidt decomposition for a bipartition into subsystems A and B is defined for a pure state as

| ψ ⟩ = \sum_{i = 1}^{r} s_{i} | α_{i} ⟩ \otimes | β_{i} ⟩,

where $| α_{i} ⟩ (| β_{i} ⟩)$ are orthonormal states acting on A (B). The Schmidt rank is the number of terms r in the sum. A product state gives r=1 and r>1 signals entanglement.

We only consider bipartitions where $A = {1, \dots, k - 1}$ and $B = {k, \dots, N}$ , for some k and where N is the total number of qubits.

Usage on MIMIQ#

To compute the Schmidt rank of a bipartition you can use the SchmidtRank operator and push() like all entanglement measures:

>>> circuit = Circuit()
>>> # Asking to compute the Schmidt rank between the two subsystems separated between qubits 1 and 2
>>> circuit.push(SchmidtRank(), 2, 0)
3-qubit circuit with 1 instructions:
└── SchmidtRank @ q[2], z[0]

Here we compute the Schmidt rank between the two subsystems [1,2] and [3...N] and write the results into index 0 of the Z-Register.

Note

For k=1, A is empty and the Schmidt rank will always return 1.

Amplitude #

With MIMIQ you can extract quantum state amplitudes in the computational basis at any point in the circuit using Amplitude.
You will need to give the Amplitude function the BitString matching the state for which you want the amplitude.
For more information on BitString check the BitString documentation page.

You can add the Amplitude object to the circuit exactly like any other gate:

>>> mystery_circuit = Circuit()
>>> mystery_circuit.push(GateH(), range(0, 3))
3-qubit circuit with 3 instructions:
├── H @ q[0]
├── H @ q[1]
└── H @ q[2]


>>> # Define the Amplitude operator
>>> amp = Amplitude(BitString("101"))

>>> # Add the amplitude operator to the circuit and write the result in the first complex number of the Z-Register
>>> mystery_circuit.push(amp, 0)
3-qubit circuit with 4 instructions:
├── H @ q[0]
├── H @ q[1]
├── H @ q[2]
└── Amplitude(bs"101") @ z[0]

This will extract the amplitude of the basis state $| 101 ⟩$ . When adding the amplitude operation you do not need to give it any specific qubit target, the only index needed is for the Z-register to use for storing the result.