February 2025
Contribution from Dr. Vase Moeini
Software Engineer at QPerfect

Quantum computing is evolving at an unprecedented pace, and the need for robust, realistic, and user-friendly simulation tools has never been greater. At QPerfect, we are committed to equipping researchers, developers, and industry leaders with the resources they need to push the boundaries of quantum technology. The latest MIMIQ upgrade introduces a host of groundbreaking features designed to bridge the gap between theoretical advancements and practical applications.

✅ Revamped documentation with examples and expert tips
✅ Non-unitary operators for advanced features
✅ Noise channels for realistic quantum noise simulation
✅ Expectation value calculations
✅ Entanglement measures
✅ Amplitude operations for full state extraction
✅ Batch execution for efficient quantum workflows
✅ Stim file support for quantum error correction research
✅ Additional measurement & reset operations
✅ Performance upgrades for MPS & StateVector backends

We’ve completely revamped our documentation to make it easier than ever to explore MIMIQ’s full potential. Our new manual is packed with step-by-step guides, detailed explanations, and expert insights to help you hit the ground running. You can find the new documentation, for both Julia and Python APIs at Documentation. If you already have access to MIMIQ, we encourage you to try running the Quickstart code yourself!

While gates in quantum computing must be unitary, it is common to use more general operators that don't fulfill unitarity in order to model more general operations such as noise, or to extract information about the quantum state through, e.g., expectation values (see below).

With MIMIQ, you can now define custom operators (through Operator) or leverage pre-built ones from our extensive library (e.g. SigmaPlus and Projector0). See below for examples, or check our Operator documentation (Operators in Python, Operators in Julia).

Real quantum computers are not perfect—they interact with their environment, inevitably leading to noise. To build robust quantum algorithms for real-world hardware, it’s thus crucial to model these imperfections. MIMIQ now supports simulations with noise.

Noise in quantum systems is modeled using the density matrix formalism, which provides a comprehensive way to describe mixed quantum states. In quantum computing, noise is usually modeled using noisy quantum channels, which in the Kraus representation act as follows:

$$ \mathcal{E}(\rho) = \sum_k E_k \rho E_k^\dagger $$

Here, $\rho$ is the density matrix, and $E_k$ are the Kraus operators that represent specific noise processes.

With MIMIQ, you can now create custom noise channels (using Kraus or MixedUnitary) or use a pre-defined channel from our library (e.g. AmplitudeDamping, PhaseAmplitudeDamping, or Depolarizing).

To add noise channels to your circuit you can simply add them like gates, or use add_noise to add it globally to all gates of a certain type:

# Add noise one by one
c.push(AmplitudeDamping(0.1), 0)

# Add noise to all CX gates in the circuit
c.add_noise(GateCX(), Depolarizing2(0.05))

For more examples and a description of all the noise functionality, check out the Noise section of the Documentation (Noise in Python, Noise in Julia).

While a quantum computer needs to collect thousands of samples to estimate the value of an observable, with a simulator such as MIMIQ we can compute expectation values directly from the quantum state (mathematically, $\langle A \rangle = \langle \psi | A | \psi \rangle$). This constitutes a fundamental tool of researchers to deeper understand the behavior of quantum circuits.

With MIMIQ you can now efficiently compute expectation values of arbitrary operators (see above) at any point in the circuit. The results are stored in and can be easily retrieved from the newly introduced Z-register, which is basically a vector of complex numbers.

The ExpectationValue operation in MIMIQ supports arbitrary single-qubit and two-qubit operators, as well as multi-qubit Pauli strings (PauliString). The latter can be useful to compute expectation values of Hamiltonians, e.g. for variational algorithms. To compute an ExpectationValue we add it to the circuit the same way as gates:

# Compute 1-qubit expectation value and store in Z-register 0
c.push(ExpectationValue(SigmaPlus()), 1, 0)

# Compute 4-qubit expectation value and store in Z-register 1
c.push(ExpectationValue(PauliString("IXYZ")),0,1,2,3,1)

We refer to the corresponding page in the documentation for more information (Expectation Value in Python, Expectation Value in Julia).

Entanglement is a cornerstone of quantum mechanics, and now, MIMIQ provides dedicated tools to measure and analyze it. To gain insight into the intricate correlations of qubits, MIMIQ now allows to compute different forms of bipartite entanglement such as:

✅ Bond Dimension
✅ Schmidt Rank
✅ Von Neumann Entropy

These entanglement measures helps researchers understand the complexity of quantum circuits.

Entanglement can be computed at any point in the circuit by adding the corresponding operation as we do with gates, and the results are stored in the Z-register.

# Compute entanglement and store in Z-register 0
c.push(VonNeumannEntropy(), 2, 0)
c.push(BondDim(), 1, 0)
c.push(SchmidtRank(), 0, 0)

For more information please check out the documentation (Entanglement in Python, Entanglement in Julia).

Need to extract full quantum state information? MIMIQ now allows you to access state amplitudes at any point in the circuit. This means that if we represent the state as $|\psi\rangle = \sum_{x} c_x |x\rangle$ using the computational basis $|x\rangle$, with MIMIQ, you now have direct access to the complex-valued amplitudes $c_x$. Importantly, you can extract this information for both the StateVector and the MPS engines.

To obtain an amplitude, we simply specify the basis state we're interested in (using BitString) and then add the operation to the circuit just like a gate. The result will be stored in the Z-register.

basis_state = BitString("000")
c.push(Amplitude(basis_state), 0)

Find out more about this operation in the documentation (Amplitude in Python, Amplitude in Julia).

MIMIQ now supports batch execution of circuits, which enables users to execute multiple quantum circuits in a single job. This feature significantly enhances efficiency by reducing overhead associated with cloud service execution.

# Sends circuits c1, c2, c3... for execution
conn = MimiqConnection()
job = conn.execute([c1, c2, c3, ...])

For more information, please refer to the Execution (Python, Julia) section of the documentation

MIMIQ now supports importing and simulating circuits in Stim format. Stim is a widely used framework for simulating Clifford circuits with applications in quantum error correction research.

For this purpose, MIMIQ now contains a suite of new operations inspired by Stim such as annotations, which allow users to tag specific instructions or circuit sections. We have also introduced set of new measurement-type operations such as:

✅ Pair Measurements: Measure correlations between qubits with MeasureZZ, MeasureXX, MeasureYY
✅ Rotated Measurements: Measure in X, Y, or Z basis with MeasureX, MeasureY, MeasureZ, ResetX, ResetY, or ResetZ.
✅ Measure & Reset in One Step: MeasureResetX, MeasureResetY, MeasureResetZ streamline operations

While the existing Measure and Reset operations in MIMIQ already allowed to perform all necessary measurement-like operations, the new features simplify the process and save the user time and effort.

Contact us to learn how MIMIQ can accelerate your quantum journey!