Quantum Error Correction: Bit flip code in Qiskit

Interested in learning how to program quantum computers? Then check out our Qiskit textbook Introduction to Quantum Computing with Qiskit.

Updated: 18/11/25

Introduction

Qubits are very fragile and are prone to errors due to decoherence and other quantum noise. However using quantum error correction qubit errors can be corrected.

In this tutorial you will see how a specific type of error called a bit flip error can be corrected using a quantum circuit known as the bit flip code.

What is a Bit Flip error?

A bit flip error is specific type of error where the qubits computational state flips from 1 to 0 or vice versa.

However a bit flip can be corrected using the bit flip code. This is a 3 qubit circuit that makes use of 2 ancillary qubits to correct 1 qubit.

Circuit diagram of the bit flip code

The code works by first using CNOT gates to transfer the computational state of the main qubit to the other ancillary qubits. Then if an error occurs the first qubits state will be flipped. To correct the bit flip CNOT gates are applied to the ancillary qubits again and then a toffoli gate is applied to the first qubit which will correct its state.

For example let’s say the main qubits state was 0. CNOT gates will be applied to the ancillary qubits which will leave them unchanged since the main qubits state was 0.

Next a bit flip occurs which flips the main qubits state to 1. After the bit flip CNOT gates are applied to the ancillary qubits which will flip their states to 1 since the main qubits state is 1.

Then a toffoli gate is applied to the main qubit which will flip the state of the qubit since the ancillary qubits states are 1. This flips the state of the main qubit to 0 thus correcting the error.

Implementation

Circuit diagram of bit flip code with simulated error using a NOT gate

Step 1: Initialise the quantum and classical registers

The first step is to initialise a 3 qubit register . This is done by the following code:

q = QuantumRegister(3,'q')

Next we initialise the 1 bit classical register with the following code:

c = ClassicalRegister(1,'c')

Step 2: Create the circuit

Next we create quantum circuit using the following code:

circuit = QuantumCircuit(q,c)

Step 3: Apply a CNOT gate to ancillary qubits

Next we will need to transfer the state of the first qubit to the ancillary qubits. This is done using CNOT gates where the ancillary qubits are the targets and the first qubit is the control qubit.

This is done using the following code:

circuit.cx(q[0],q[1]) 
circuit.cx(q[0],q[2])

Step 4: Simulate a bit flip

To show that the circuit corrects bit flips lets simulate a bit flip error. This can be done by applying a NOT gate to the first qubit:

circuit.x(q[0]) #Add this to simulate a bit flip error 

Step 5: Again apply CNOT gates to ancillary qubits

This is done using the following code:

circuit.cx(q[0],q[1]) 
circuit.cx(q[0],q[2])

Step 6: Apply a Toffoli gate to the main qubit

This is done using the following code:

circuit.ccx(q[2],q[1],q[0])

Step 7: Measure the qubits

After this we measure the qubits.

This is done with the following code:

circuit.measure(q,c) 

Device used

This tutorial uses the Qiskit Aer simulator in order to run the circuit. Note that results from this simulator contain no errors unlike on real quantum devices which are prone to noise.

More information on Qiskit Aer can be found here: https://qiskit.github.io/qiskit-aer/tutorials/1_aersimulator.html

In order to use to a real quantum device follow the steps here: https://quantum.cloud.ibm.com/docs/en/guides/initialize-account

Note: This program requires that you have an API token. To get one sign up to IBM Q Experience and get your token here: https://quantum-computing.ibm.com/account

Code

from qiskit import QuantumCircuit, transpile, ClassicalRegister, QuantumRegister
from qiskit_aer import AerSimulator

print('\nBit Flip Code')
print('----------------')


backend = AerSimulator() # Using local Aer simulator  

q = QuantumRegister(3,'q')
c = ClassicalRegister(1,'c')

circuit = QuantumCircuit(q,c)

circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.x(q[0]) #Add this to simulate a bit flip error
circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.ccx(q[2],q[1],q[0])
circuit.measure(q[0],c[0])

result = backend.run(circuit,shots=1024).result()
counts = result.get_counts(circuit)
print('RESULT: ',counts) # Print result

Output

Output showing the main qubit has been corrected to 0