# StabilizerState

*class *`qiskit.quantum_info.StabilizerState(data, validate=True)`

Bases: `QuantumState`

StabilizerState class. Stabilizer simulator using the convention from reference [1]. Based on the internal class `Clifford`

.

```
from qiskit import QuantumCircuit
from qiskit.quantum_info import StabilizerState, Pauli
# Bell state generation circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
stab = StabilizerState(qc)
# Print the StabilizerState
print(stab)
# Calculate the StabilizerState measurement probabilities dictionary
print (stab.probabilities_dict())
# Calculate expectation value of the StabilizerState
print (stab.expectation_value(Pauli('ZZ')))
```

```
StabilizerState(StabilizerTable: ['+XX', '+ZZ'])
{'00': 0.5, '11': 0.5}
1
```

Given a list of stabilizers, `qiskit.quantum_info.StabilizerState.from_stabilizer_list()`

returns a state stabilized by the list

```
from qiskit.quantum_info import StabilizerState
stabilizer_list = ["ZXX", "-XYX", "+ZYY"]
stab = StabilizerState.from_stabilizer_list(stabilizer_list)
```

**References**

- S. Aaronson, D. Gottesman,
*Improved Simulation of Stabilizer Circuits*, Phys. Rev. A 70, 052328 (2004). arXiv:quant-ph/0406196

Initialize a StabilizerState object.

**Parameters**

**or**(*data (**StabilizerState**or**Clifford**or**Pauli**or**QuantumCircuit*) – qiskit.circuit.Instruction): Data from which the stabilizer state can be constructed.**validate**(*boolean*) – validate that the stabilizer state data is a valid Clifford.

## Attributes

### clifford

Return StabilizerState Clifford data

### dim

Return total state dimension.

### num_qubits

Return the number of qubits if a N-qubit state or None otherwise.

## Methods

### conjugate

### copy

### dims

### equiv

`equiv(other)`

Return True if the two generating sets generate the same stabilizer group.

**Parameters**

**other** (*StabilizerState*) – another StabilizerState.

**Returns**

True if other has a generating set that generates the same StabilizerState.

**Return type**

### evolve

`evolve(other, qargs=None)`

Evolve a stabilizer state by a Clifford operator.

**Parameters**

**other**(*Clifford**or**QuantumCircuit**or**qiskit.circuit.Instruction*) – The Clifford operator to evolve by.**qargs**(*list*) – a list of stabilizer subsystem positions to apply the operator on.

**Returns**

the output stabilizer state.

**Return type**

**Raises**

**QiskitError**– if other is not a StabilizerState.**QiskitError**– if the operator dimension does not match the specified StabilizerState subsystem dimensions.

### expand

`expand(other)`

Return the tensor product stabilizer state other ⊗ self.

**Parameters**

**other** (*StabilizerState*) – a stabilizer state object.

**Returns**

the tensor product operator other ⊗ self.

**Return type**

**Raises**

**QiskitError** – if other is not a StabilizerState.

### expectation_value

`expectation_value(oper, qargs=None)`

Compute the expectation value of a Pauli operator.

**Parameters**

**oper**(*Pauli*) – a Pauli operator to evaluate expval.**qargs**(*None or**list*) – subsystems to apply the operator on.

**Returns**

the expectation value (only 0 or 1 or -1 or i or -i).

**Return type**

**Raises**

**QiskitError** – if oper is not a Pauli operator.

### from_stabilizer_list

*classmethod *`from_stabilizer_list(stabilizers, allow_redundant=False, allow_underconstrained=False)`

Create a stabilizer state from the collection of stabilizers.

**Parameters**

**stabilizers**(*Collection[**str**]*) – list of stabilizer strings**allow_redundant**(*bool*) – allow redundant stabilizers (i.e., some stabilizers can be products of the others)**allow_underconstrained**(*bool*) – allow underconstrained set of stabilizers (i.e., the stabilizers do not specify a unique state)

**Returns**

a state stabilized by stabilizers.

**Return type**

### is_valid

### measure

`measure(qargs=None)`

Measure subsystems and return outcome and post-measure state.

Note that this function uses the QuantumStates internal random number generator for sampling the measurement outcome. The RNG seed can be set using the `seed()`

method.

**Parameters**

**qargs** (*list* *or None*) – subsystems to sample measurements for, if None sample measurement of all subsystems (Default: None).

**Returns**

**the pair (outcome, state) where outcome is the**

measurement outcome string label, and `state`

is the collapsed post-measurement stabilizer state for the corresponding outcome.

**Return type**

### probabilities

`probabilities(qargs=None, decimals=None)`

Return the subsystem measurement probability vector.

Measurement probabilities are with respect to measurement in the computation (diagonal) basis.

**Parameters**

**qargs**(*None or**list*) – subsystems to return probabilities for, if None return for all subsystems (Default: None).**decimals**(*None or**int*) – the number of decimal places to round values. If None no rounding is done (Default: None).

**Returns**

The Numpy vector array of probabilities.

**Return type**

np.array

### probabilities_dict

`probabilities_dict(qargs=None, decimals=None)`

Return the subsystem measurement probability dictionary.

Measurement probabilities are with respect to measurement in the computation (diagonal) basis.

This dictionary representation uses a Ket-like notation where the dictionary keys are qudit strings for the subsystem basis vectors. If any subsystem has a dimension greater than 10 comma delimiters are inserted between integers so that subsystems can be distinguished.

**Parameters**

**qargs**(*None or**list*) – subsystems to return probabilities for, if None return for all subsystems (Default: None).**decimals**(*None or**int*) – the number of decimal places to round values. If None no rounding is done (Default: None).

**Returns**

The measurement probabilities in dict (key) form.

**Return type**

### probabilities_dict_from_bitstring

`probabilities_dict_from_bitstring(outcome_bitstring, qargs=None, decimals=None)`

Return the subsystem measurement probability dictionary utilizing a targeted outcome_bitstring to perform the measurement for. This will calculate a probability for only a single targeted outcome_bitstring value, giving a performance boost over calculating all possible outcomes.

Measurement probabilities are with respect to measurement in the computation (diagonal) basis.

This dictionary representation uses a Ket-like notation where the dictionary keys are qudit strings for the subsystem basis vectors. If any subsystem has a dimension greater than 10 comma delimiters are inserted between integers so that subsystems can be distinguished.

**Parameters**

**outcome_bitstring**(*None or**str*) – targeted outcome bitstring to perform a measurement calculation for, this will significantly reduce the number of calculation performed (Default: None)**qargs**(*None or**list*) – subsystems to return probabilities for, if None return for all subsystems (Default: None).**decimals**(*None or**int*) – the number of decimal places to round values. If None no rounding is done (Default: None)

**Returns**

The measurement probabilities in dict (ket) form.

**Return type**

### purity

`purity()`

Return the purity of the quantum state, which equals to 1, since it is always a pure state.

**Returns**

the purity (should equal 1).

**Return type**

**Raises**

**QiskitError** – if input is not a StabilizerState.

### reset

`reset(qargs=None)`

Reset state or subsystems to the 0-state.

**Parameters**

**qargs** (*list* *or None*) – subsystems to reset, if None all subsystems will be reset to their 0-state (Default: None).

**Returns**

the reset state.

**Return type**

**Additional Information:**

If all subsystems are reset this will return the ground state on all subsystems. If only some subsystems are reset this function will perform a measurement on those subsystems and evolve the subsystems so that the collapsed post-measurement states are rotated to the 0-state. The RNG seed for this sampling can be set using the `seed()`

method.

### sample_counts

`sample_counts(shots, qargs=None)`

Sample a dict of qubit measurement outcomes in the computational basis.

**Parameters**

**shots**(*int*) – number of samples to generate.**qargs**(*None or**list*) – subsystems to sample measurements for, if None sample measurement of all subsystems (Default: None).

**Returns**

sampled counts dictionary.

**Return type**

Additional Information:

This function

samplesmeasurement outcomes using the measure`probabilities()`

for the current state and qargs. It does not actually implement the measurement so the current state is not modified.The seed for random number generator used for sampling can be set to a fixed value by using the stats

`seed()`

method.

### sample_memory

`sample_memory(shots, qargs=None)`

Sample a list of qubit measurement outcomes in the computational basis.

**Parameters**

**shots**(*int*) – number of samples to generate.**qargs**(*None or**list*) – subsystems to sample measurements for, if None sample measurement of all subsystems (Default: None).

**Returns**

list of sampled counts if the order sampled.

**Return type**

np.array

Additional Information:

This function implements the measurement

`measure()`

method.The seed for random number generator used for sampling can be set to a fixed value by using the stats

`seed()`

method.

### seed

### tensor

`tensor(other)`

Return the tensor product stabilizer state self ⊗ other.

**Parameters**

**other** (*StabilizerState*) – a stabilizer state object.

**Returns**

the tensor product operator self ⊗ other.

**Return type**

**Raises**

**QiskitError** – if other is not a StabilizerState.

### to_operator

### trace

`trace()`

Return the trace of the stabilizer state as a density matrix, which equals to 1, since it is always a pure state.

**Returns**

the trace (should equal 1).

**Return type**

**Raises**

**QiskitError** – if input is not a StabilizerState.