Operations

MimiqCircuits provides a rich set of operations to build your quantum circuits. From standard unitary gates to advanced noise channels and classical control flow, explore the available tools below.

Unitary Gates

Standard single and multi-qubit gates (X, H, CX, etc.).

Unitary Gates

Classical Operations

Manipulate classical bits logic (AND, XOR) and registers.

Classical Operations

Non-Unitary Ops

Measurements, resets, and conditional logic.

Non-unitary Operations

Noise Models

Define custom noise models and apply them to your circuits.

Noisy simulations on MIMIQ

Symbolic Ops

Work with parameterized circuits using symbolic variables.

Symbolic Operations in MIMIQ

Statistical Ops

Operations for extracting statistical properties.

Statistical Operations

Special Ops

Specialized operations and structures.

Special Operations

Z-Operations

Operations on the Z-register.

Z-register Operations

Reference

class mimiqcircuits.Operation

Bases: ABC

Abstract base class for quantum operations.

property num_qubits

property num_qregs

property num_bits

property num_zvars

property num_cregs

property qregsizes

property cregsizes

property zregsizes

property name

property parnames

getparams()

is_symbolic()

getparam(pn)

copy()

Creates a shallow copy of the operation.

To create a full copy use deepcopy() instead.

Returns:

A new Operation object containing references to the same attributes as the original circuit

Return type:

Operation

deepcopy()

Creates a copy of the object and for all its attributes

Returns:

A new Operation object fully identical the original circuit

Return type:

Operation

abstract iswrapper()

isopalias()

numparams()

decompose()

evaluate(d)

isidentity()

classmethod isunitary()

Check if the class represents a unitary operator.

By default, this method returns False unless explicitly overridden in a subclass.

asciiwidth(qubits, bits, zvars)

get_operation()

listvars()

class mimiqcircuits.Gate

Bases: AbstractOperator

iswrapper()

Check if the operator is a wrapper around another operator.

This method should be overridden in subclasses to return True if the operator is acting as a wrapper around another operation or object, and False otherwise.

Returns:

Always returns False in the base class. Subclasses should override this method to provide the appropriate logic.

Return type:

bool

inverse()

Raise an error, as non-unitary operators cannot be inverted.

This method is not implemented for non-unitary operators and will raise a NotImplementedError if called.

Raises:

NotImplementedError – If the method is called.

power(*args)

Raise an error, as powers of non-unitary operators are not supported.

This method is not implemented for non-unitary operators and will raise a NotImplementedError if called.

Parameters:

n (int) – The exponent to which the operator would be raised.

Raises:

NotImplementedError – If the method is called.

control(*args)

parallel(*args)

repeat(*args)

evaluate(d)

Substitute the symbolic parameters of the operator with numerical values.

This method evaluates the operator’s symbolic parameters using the values provided in the dictionary d. If the operator has no parameters, it returns the same instance. Otherwise, it creates a new instance of the operator with updated numerical parameters.

Parameters:

d (dict) – A dictionary where keys are symbolic parameter names and values are values for substitution.

Example

>>> from symengine import *
>>> from mimiqcircuits import *
>>> theta = symbols('theta')
>>> op = GateRX(theta)
>>> evaluated_op = op.evaluate({'theta': 0.5})
>>> print(evaluated_op)
RX(0.5)

gettypekey()

static isunitary()

Check if the object is unitary.

By default, this method returns False unless explicitly overridden in a subclass.