# Wolfram Language Paclet Repository

Community-contributed installable additions to the Wolfram Language

Perform analytic and numeric quantum computations

Contributed By: Wolfram Research, Quantum Computation Framework team

The Wolfram Quantum Framework brings a broad, coherent design for quantum computation, together with a host of leading-edge capabilities, and full integration into Mathematica and Wolfram Language. Starting from discrete quantum mechanics, the Framework provides a high-level symbolic representation of quantum bases, states, and operators. The Framework can perform measurements and is equipped with various well-known states and operators, such as Bell states and Pauli operators. Using such simulation capabilities as a foundation, one can use the Framework to model and simulate quantum circuits and algorithms.

All functions and objects in the Wolfram Quantum Framework work seamlessly with the 5,000+ built-in made available through Wolfram Language. The immediate availability of such functions allows one to study a full range of questions around quantum computation, and can serve as a helpful resource for teaching.

To install this paclet in your Wolfram Language environment,
evaluate this code:

`PacletInstall["Wolfram/QuantumFramework"]`

This paclet works with version 13.0 and higher of the Wolfram Language.

In order to use QuantumBasis, one gives dimension information as arguments, which will be interpreted as the computational basis. Alternatively, an association can be given with the basis name as the key and the corresponding basis elements as the values.

Define a 2D quantum basis (computational):

In[1]:= |

Out[1]= |

Given a basis of dimension n, the basis elements will be indexed by the key with :

In[2]:= |

Out[2]= |

Use QuantumBasis[n,m] to define a basis for qudits of dimension* * (for which the overall dimension will be ). For example, define a 2–2–2 dimensional quantum basis (with three qubits):

In[3]:= |

Out[3]= |

In[4]:= |

Out[4]= |

Use QuantumBasis[{*n _{1},n_{2},…,n_{m}*}] to define an -dimensional Hilbert space of qudits as a list. For example, define a 3×5 dimensional quantum basis (with two qudits):

In[5]:= |

Out[5]= |

A basis can also be defined as an association with the basis element names as keys and the corresponding vectors as values:

In[6]:= |

Out[6]= |

In[7]:= |

Out[7]= |

There are many 'named' bases built into the quantum framework, including "Computational", "PauliX", "PauliY", "PauliZ", "Fourier", "Identity", "Schwinger", "Pauli", "Dirac" and "Wigner" bases:

In[8]:= |

Out[8]= |

After a basis object has been defined, it is straightforward to construct quantum states and operators. A quantum state is represented by a QuantumState object and a quantum operator is represented by QuantumOperator.

A pure quantum state is represented as a vector for which the elements are amplitudes. The corresponding basis should be given in this format: QuantumState[arg_{1},arg_{2}], where arg_{1} specifies amplitudes or the density matrix, and arg_{2} specifies the basis. With no basis specified, the default basis will be the computational basis, the dimension of which depends on the amplitude vector given in arg1.

Note that we use the big endian convention, such that qubits are labelled left-to-right, starting with one. For example, the decimal representation of (which means _{}⊗_{}⊗_{3}) is . Additionally, for the eigenvalues of Pauli-Z, we have:

In[9]:= |

Out[9]= |

We shall denote the eigenstate {1,0} by (which corresponds to +1 eigenvalue), and {0,1} by (corresponding to the eigenvalue -1)

Define a pure 2-dimensional quantum state (qubit) in the Pauli-X basis:

In[10]:= |

Out[10]= |

In[11]:= |

Out[11]= |

If the basis is not specified, the default is the computational basis of dimensions ( qubits):

In[12]:= |

Out[12]= |

In[13]:= |

Out[13]= |

If the vector has more than 2 elements, it is interpreted as an -qubit state, unless the dimension is specified. If fewer than amplitudes are specified, right-padding is applied to reach the 'ceiling':

In[14]:= |

Out[14]= |

In[15]:= |

Out[15]= |

Here is the same amplitude vector, but this time with the dimension specified:

In[16]:= |

Out[17]= |

Binary strings can be also used as inputs:

In[18]:= |

Out[18]= |

Many 'named' states are available through the framework:

In[19]:= |

Out[19]= |

Using associations, one can create a superposition of states, where the keys are lists of corresponding indexes and the values are amplitudes.

Create a superposition of 3 qubits (i.e., QuantumBasis[2,3]) as :

In[20]:= |

Out[20]= |

In[21]:= |

Out[21]= |

In[22]:= |

Out[22]= |

A superposition can also be created by simply adding two quantum state objects. For example, the previous state can also be constructed as follows:

In[23]:= |

Out[24]= |

With a built-in basis specified, amplitudes correspond to the basis elements. For example, use the Bell basis:

In[25]:= |

Out[25]= |

In[26]:= |

Out[26]= |

In[27]:= |

Out[27]= |

A state can also be defined by inputting a density matrix:

In[28]:= |

Out[28]= |

For pure states, one can get the corresponding normalized state vector:

In[29]:= |

Out[29]= |

Define a generic Bloch vector:

In[30]:= |

In[31]:= |

Out[27]= |

Test to see if it is a mixed state:

In[32]:= |

Out[32]= |

Calculate its Von Neumann entropy:

In[33]:= |

Out[33]= |

Compute its purity:

In[34]:= |

Out[34]= |

Note that one can directly use a Bloch vector as an input:

In[35]:= |

Out[35]= |

In[36]:= |

Out[36]= |

Test to see if a matrix is positive semidefinite:

In[37]:= |

Out[37]= |

A matrix that is not positive semidefinite cannot be a density matrix in standard quantum mechanics (with some exceptional cases, such as ZX formalism). Here is the result when we attempt to define a state using such a matrix:

In[38]:= |

Out[38]= |

When a matrix is given as input, but no basis is given, the default basis will be computational:

In[39]:= |

Out[27]= |

In[40]:= |

Out[40]= |

Using , define a quantum state in a 2–4 dimensional basis (and note the number of qudits):

In[41]:= |

Out[41]= |

In[42]:= |

Out[42]= |

Define a quantum state in 8D Hilbert space (with one 8-dimensional qudit only):

In[43]:= |

Out[43]= |

In[44]:= |

Out[44]= |

One can also define a state in a given basis, and then transform it into a new basis. For example, transform , the computational basis, into the Pauli-X basis {,}:

In[45]:= |

Out[38]= |

Return the amplitudes:

In[46]:= |

Out[46]= |

In[47]:= |

Out[47]= |

Note that the states are the same, but defined in different bases:

In[48]:= |

Out[48]= |

One can use QuantumTensorProduct to construct different states or operators. Create a tensor product of a + state with three qubits :

In[49]:= |

Out[38]= |

Another way of defining is to first define a basis and then assign amplitudes:

In[50]:= |

In[51]:= |

Out[48]= |

In[52]:= |

Out[52]= |

Quantum operators can be defined by a matrix or by specifying eigenvalues with respect to a QuantumBasis. Additionally, there are many built-in named operators that can be used.

Define a Pauli-X operator:

In[53]:= |

Out[53]= |

Apply a Pauli-X operator to a symbolic state :

In[54]:= |

Out[54]= |

Test to see if the application of the Pauli-X operator yields the correct state:

In[55]:= |

Out[55]= |

Apply the Hadamard operator :

In[56]:= |

Out[56]= |

Test to see if the application of the Hadamard operator yields the correct state:

In[57]:= |

Out[57]= |

One can also compose operators. Here's a composition of two Hadamard operators and one Pauli-Z operator:

In[58]:= |

Out[58]= |

Check the relation :

In[59]:= |