### Install Git (Ubuntu)

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the Git version control system on Ubuntu.

```bash
apt-get install git
```

--------------------------------

### Install OpenBLAS (Ubuntu)

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the OpenBLAS library, recommended for optimal performance, on Ubuntu.

```bash
sudo apt install libopenblas-dev
```

--------------------------------

### Install Development Tools (Ubuntu)

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs essential build tools on Ubuntu systems.

```bash
sudo apt install build-essential
```

--------------------------------

### Simulate Quantum Circuits with SamplerV2

Source: https://github.com/qiskit/qiskit-aer/blob/main/README.md

Example demonstrating the use of SamplerV2 for sampling quantum circuits. This includes sampling a Bell circuit and parameterized circuits with specified shots and parameters. Ensure qiskit-aer is installed.

```python
from qiskit import transpile
from qiskit.circuit.library import RealAmplitudes
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import SamplerV2
from qiskit import QuantumCircuit

sim = AerSimulator()

# create a Bell circuit
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()

# create two parameterized circuits
pqc = RealAmplitudes(num_qubits=2, reps=2)
pqc.measure_all()
pqc = transpile(pqc, sim, optimization_level=0)
pqc2 = RealAmplitudes(num_qubits=2, reps=3)
pqc2.measure_all()
pqc2 = transpile(pqc2, sim, optimization_level=0)

theta1 = [0, 1, 1, 2, 3, 5]
theta2 = [0, 1, 2, 3, 4, 5, 6, 7]

# initialization of the sampler
sampler = SamplerV2()

# collect 128 shots from the Bell circuit
job = sampler.run([bell], shots=128)
job_result = job.result()
print(f"counts for Bell circuit : {job_result[0].data.meas.get_counts()}")
 
# run a sampler job on the parameterized circuits
job2 = sampler.run([(pqc, theta1), (pqc2, theta2)])
job_result = job2.result()
print(f"counts for parameterized circuit : {job_result[0].data.meas.get_counts()}")
```

--------------------------------

### Install Qiskit Aer from Source

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Build and install Qiskit Aer from the source code using pip. This installs Aer with default options.

```sh
qiskit-aer$ pip install .
```

--------------------------------

### Simulate Quantum Circuits with EstimatorV2

Source: https://github.com/qiskit/qiskit-aer/blob/main/README.md

Example demonstrating the use of EstimatorV2 for calculating expectation values of quantum circuits with parameterized circuits and Pauli operators. Ensure qiskit-aer is installed.

```python
from qiskit import transpile
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import EstimatorV2

sim = AerSimulator()

psi1 = transpile(RealAmplitudes(num_qubits=2, reps=2), sim, optimization_level=0)
psi2 = transpile(RealAmplitudes(num_qubits=2, reps=3), sim, optimization_level=0)

H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
H2 = SparsePauliOp.from_list([("IZ", 1)])
H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)])

theta1 = [0, 1, 1, 2, 3, 5]
theta2 = [0, 1, 1, 2, 3, 5, 8, 13]
theta3 = [1, 2, 3, 4, 5, 6]

estimator = EstimatorV2()

# calculate [ [<psi1(theta1)|H1|psi1(theta1)ческой>, 
#              <psi1(theta3)|H3|psi1(theta3)>],
#             [<psi2(theta2)|H2|psi2(theta2)>] ]
job = estimator.run(
    [
        (psi1, [H1, H3], [theta1, theta3]),
        (psi2, H2, theta2)
    ],
    precision=0.01
)
result = job.result()
print(f"expectation values : psi1 = {result[0].data.evs}, psi2 = {result[1].data.evs}")
```

--------------------------------

### Install Qiskit Aer Wheel Package

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the Qiskit Aer wheel package after it has been built. Use the -U flag to upgrade if a previous version is installed.

```bash
qiskit-aer/dist$ pip install -U dist/qiskit_aer*.whl
```

--------------------------------

### Install and Run Qiskit Integration Tests

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Install the Qiskit Aer Python extension and run the integration tests using the stestr framework.

```bash
qiskit-aer$ pip install .
qiskit-aer$ stestr run
```

--------------------------------

### Install Built Qiskit Aer Wheel

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the Qiskit Aer wheel package after it has been built.

```bash
pip install -U dist/qiskit_aer*.whl
```

--------------------------------

### Install Airspeed Velocity (ASV)

Source: https://github.com/qiskit/qiskit-aer/blob/main/BENCHMARKING.md

Install the Airspeed Velocity benchmarking tool using pip. This is a prerequisite for running the Qiskit Aer benchmarks.

```bash
$ pip install asv
```

--------------------------------

### Install Built Qiskit Aer Wheel

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the Qiskit Aer wheel package from the dist/ directory after it has been built. Use `-U` to upgrade if a previous version is installed.

```bash
(QiskitDevEnv) qiskit-aer\dist$ pip install -U dist\qiskit_aer*.whl
```

--------------------------------

### Basic Quantum Circuit Simulation Setup

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Set up a basic 3-qubit GHZ state quantum circuit and prepare it for measurement using Qiskit Aer's SamplerV2.

```python
import qiskit
from qiskit_aer.primitives import SamplerV2

# Generate 3-qubit GHZ state
circ = qiskit.QuantumCircuit(3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure_all()

```

--------------------------------

### Install OpenBLAS (macOS)

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the OpenBLAS library using Homebrew on macOS.

```bash
brew install openblas
```

--------------------------------

### Initialize AerSimulator Backends

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Initialize the AerSimulator with different methods and devices. Check available methods and devices for your installation.

```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

# Default automatic method on CPU
sim = AerSimulator()

# Statevector method on GPU (requires qiskit-aer-gpu)
sim_gpu = AerSimulator(method='statevector', device='GPU')

# Density matrix method with double precision
sim_dm = AerSimulator(method='density_matrix', precision='double')

# Matrix Product State for large circuits
sim_mps = AerSimulator(method='matrix_product_state')

# Check available methods and devices
print(AerSimulator.available_methods())
# ['automatic', 'statevector', 'density_matrix', 'stabilizer',
#  'extended_stabilizer', 'matrix_product_state', 'unitary', 'superop', 'tensor_network']
print(AerSimulator.available_devices())
# ['CPU'] or ['CPU', 'GPU'] if GPU support installed

# Build and run a Bell circuit
qc = QuantumCircuit(2)
nc.h(0)
nc.cx(0, 1)
nc.measure_all()

tqc = transpile(qc, sim)
result = sim.run(tqc, shots=1024).result()
print(result.get_counts())
# {'00': 512, '11': 512}  (approximately)
```

--------------------------------

### Run Simulation and Get Results

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/7_matrix_product_state_method.ipynb

This snippet demonstrates how to run a quantum circuit on a simulator, retrieve the results, and print the time taken for the simulation. It also shows how to obtain the measurement counts.

```python
circ.measure(range(num_qubits), range(num_qubits))
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
print("Time taken: {} sec".format(result.time_taken))
result.get_counts()
```

--------------------------------

### Install Xcode Command Line Tools (macOS)

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Installs the necessary Xcode command line tools on macOS.

```bash
xcode-select --install
```

--------------------------------

### Build Qiskit Aer Wheel from Source

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Build a wheel distributable file for Qiskit Aer from source. This is an alternative Pythonic approach to installation.

```sh
qiskit-aer$ pip install build
qiskit-aer$ python -I -m build --wheel
```

--------------------------------

### Build Documentation Locally with Tox

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Command to build the project's documentation locally, including the release notes. Requires pandoc to be installed. The rendered HTML output will be in 'docs/_build/html'.

```bash
tox -edocs
```

--------------------------------

### Install Development Requirements

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Install development dependencies for Qiskit Aer from source using the requirements-dev.txt file.

```sh
cd qiskit-aer
pip install -r requirements-dev.txt
```

--------------------------------

### Install Qiskit-Aer Development Requirements

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/release_notes.md

Install the necessary development modules for Qiskit-Aer. This is a prerequisite for building or contributing to the project.

```bash
cd <Qiskit-Aer source folder>
pip install -r requirements-dev.txt
```

--------------------------------

### Install Development Requirements

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Install common development dependencies, including Conan, using pip and the requirements-dev.txt file.

```bash
$ cd qiskit-aer
$ pip install -r requirements-dev.txt
```

--------------------------------

### Run multiple PUBs in a single job with SamplerV2

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Demonstrates running a Bell circuit and parameterized quantum circuits (PQCs) with different parameter sets in a single SamplerV2 job. Requires prior setup of a simulator or service.

```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import SamplerV2
from qiskit.circuit.library import RealAmplitudes

sim = AerSimulator()
sampler = SamplerV2(sim)

# Bell circuit (no parameters)
bell = QuantumCircuit(2)
bell.h(0); bell.cx(0, 1); bell.measure_all()

# Parameterized circuits
pqc = RealAmplitudes(num_qubits=2, reps=2)
pqc.measure_all()
pqc = transpile(pqc, sim, optimization_level=0)

pqc2 = RealAmplitudes(num_qubits=2, reps=3)
pqc2.measure_all()
pqc2 = transpile(pqc2, sim, optimization_level=0)

theta1 = [0, 1, 1, 2, 3, 5]
theta2 = [0, 1, 2, 3, 4, 5, 6, 7]

# Run multiple PUBs in a single job
job = sampler.run(
    [bell, (pqc, theta1), (pqc2, theta2)],
    shots=512
)
result = job.result()

print(result[0].data.meas.get_counts())   # Bell counts: {'00': ~256, '11': ~256}
print(result[1].data.meas.get_counts())   # pqc counts
print(result[2].data.meas.get_counts())   # pqc2 counts
```

--------------------------------

### Install cuQuantum Dependencies

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Install the necessary NVIDIA cuQuantum components via pip. Replace cu11 with cu12 if using CUDA 12.

```bash
qiskit-aer$ pip install nvidia-cuda-runtime-cu11 nvidia-cublas-cu11 nvidia-cusolver-cu11 nvidia-cusparse-cu11 cuquantum-cu11
```

--------------------------------

### Run ASV Benchmarks on Linux

Source: https://github.com/qiskit/qiskit-aer/blob/main/BENCHMARKING.md

Execute the Airspeed Velocity benchmarks on a Linux system using the specified configuration file. Ensure all prerequisites are installed.

```bash
$ asv run --config asv.linux.conf.json
```

--------------------------------

### Run ASV Benchmarks on MacOS

Source: https://github.com/qiskit/qiskit-aer/blob/main/BENCHMARKING.md

Execute the Airspeed Velocity benchmarks on a macOS system using the specified configuration file. Ensure all prerequisites are installed.

```bash
$ asv run --config asv.macos.conf.json
```

--------------------------------

### Install Qiskit Aer (CPU and GPU)

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Install Qiskit Aer with CPU-only support or with GPU support for CUDA 12 or CUDA 11. GPU support is limited to Linux x86_64.

```bash
# Standard CPU install
pip install qiskit-aer
```

```bash
# GPU support (CUDA 12, Linux x86_64 only)
pip install qiskit-aer-gpu
```

```bash
# GPU support (CUDA 11, Linux x86_64 only)
pip install qiskit-aer-gpu-cu11
```

--------------------------------

### Example: Threadpool Execution

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/howtos/parallel.md

Configure AerSimulator to use a ThreadPoolExecutor and set `max_job_size` to control circuit splitting for parallel execution.

```python
import qiskit
from concurrent.futures import ThreadPoolExecutor
from qiskit_aer import AerSimulator
from math import pi

# Generate circuit
circ = qiskit.QuantumCircuit(15, 15)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.p(pi/2, 2)
circ.measure([0, 1, 2], [0, 1 ,2])

circ2 = qiskit.QuantumCircuit(15, 15)
circ2.h(0)
circ2.cx(0, 1)
circ2.cx(1, 2)
circ2.p(pi/2, 2)
circ2.measure([0, 1, 2], [0, 1 ,2])
circ_list = [circ, circ2]

qbackend = AerSimulator()
# Set executor and max_job_size
exc = ThreadPoolExecutor(max_workers=2)
qbackend.set_options(executor=exc)
qbackend.set_options(max_job_size=1)
result = qbackend.run(circ_list).result()
```

--------------------------------

### Initialize NoiseModel with Custom Basis Gates

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/release_notes.md

To use basis gates different from the default, initialize `NoiseModel` with the `basis_gates` argument. This example shows how to revert to the older basis gate set.

```python
NoiseModel(basis_gates=["id", "u3", "cx"])
```

--------------------------------

### Check Qiskit version

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Verify the installed Qiskit version. This is a common step to ensure compatibility with other libraries or specific features.

```python
import qiskit
qiskit.__version__
```

--------------------------------

### GPU Simulation Initialization (Tensor Network)

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/1_aersimulator.ipynb

Demonstrates initializing an AerSimulator for GPU acceleration using the 'tensor_network' method. This code is intended for systems with NVIDIA GPUs and CUDA installed. It includes error handling for environments without a GPU.

```python
from qiskit_aer import AerError

# Initialize a GPU backend
# Note that the cloud instance for tutorials does not have a GPU
# so this will raise an exception.
try:
    simulator_gpu = AerSimulator(method='tensor_network', device='GPU')

except AerError as e:
    print(e)
```

--------------------------------

### Build Qiskit-Aer with ROCm Support (Standalone)

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/release_notes.md

Use this command to build the standalone version of Qiskit-Aer with ROCm support for AMD GPUs. Ensure ROCm is installed and ROCM_PATH is set if not using the default location.

```bash
cmake <Qiskit-Aer source folder> -G Ninja \
  -DCMAKE_INSTALL_PREFIX=<Qiskit-Aer target instalation folder> \
  -DSKBUILD=FALSE \
  -DAER_THRUST_BACKEND=ROCM \
  -DAER_MPI=<set to ON or OFF depending on whether to activate MPI support> \
  -DAER_ROCM_ARCH=<target AMD GPU list, white-space separated, e.g. 'gfx90a gfx908'> \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_TESTS=True
ninja install
```

--------------------------------

### Install Qiskit Aer

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Install the Qiskit Aer package using pip. This is the standard way to add Aer to your Qiskit installation.

```sh
pip install qiskit-aer
```

--------------------------------

### Passing CMake Flags via setup.py

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Shows how to pass CMake flags when building the Qiskit Python extension using setup.py.

```bash
qiskit-aer$ python ./setup.py bdist_wheel -- -DUSEFUL_FLAG=Value
```

--------------------------------

### Create a noisy simulator from a device backend

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Instantiate an AerSimulator that mimics a specific IBM Quantum device by loading its properties and noise model.

```python
sim_vigo = AerSimulator.from_backend(device_backend)
```

--------------------------------

### Configure AerSimulator with different methods

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/1_aersimulator.ipynb

Demonstrates initializing the AerSimulator with specific simulation methods ('statevector', 'stabilizer', 'extended_stabilizer') and running a circuit with a high number of shots for each method.

```python
# Increase shots to reduce sampling variance
shots = 10000



# Statevector simulation method
sim_statevector = AerSimulator(method='statevector')
job_statevector = sim_statevector.run(circ, shots=shots)
counts_statevector = job_statevector.result().get_counts(0)

# Stabilizer simulation method
sim_stabilizer = AerSimulator(method='stabilizer')
job_stabilizer = sim_stabilizer.run(circ, shots=shots)
counts_stabilizer = job_stabilizer.result().get_counts(0)


# Extended Stabilizer method
sim_extstabilizer = AerSimulator(method='extended_stabilizer')
job_extstabilizer = sim_extstabilizer.run(circ, shots=shots)
counts_extstabilizer = job_extstabilizer.result().get_counts(0)
```

--------------------------------

### Construct and Run Ideal Simulator with SamplerV2

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Instantiate an ideal simulator using SamplerV2 and run a quantum circuit. This is useful for obtaining simulation results without noise models.

```python
sampler = SamplerV2()
job = sampler.run([circ], shots=128)

# Perform an ideal simulation
result_ideal = job.result()
counts_ideal = result_ideal[0].data.meas.get_counts()
print('Counts(ideal):', counts_ideal)
```

--------------------------------

### SamplerV2.from_backend

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Construct a SamplerV2 that simulates a real backend's noise model automatically. This allows for simulations that mimic the behavior of actual quantum hardware.

```APIDOC
## SamplerV2.from_backend — Noisy Sampling from Real Backend

### Description
Construct a `SamplerV2` that simulates a real backend's noise model automatically.

### Method
`SamplerV2.from_backend(backend)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import SamplerV2
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel='ibm_quantum', token='YOUR_TOKEN')
real_backend = service.get_backend('ibm_kyoto')

# SamplerV2 backed by a noise model matching ibm_kyoto
sampler = SamplerV2.from_backend(real_backend)

bell = QuantumCircuit(2)
bell.h(0); bell.cx(0, 1); bell.measure_all()
bell_t = transpile(bell, AerSimulator(basis_gates=["ecr", "id", "rz", "sx"]),
 optimization_level=0)

job = sampler.run([bell_t], shots=128)
result = job.result()
print(result[0].data.meas.get_counts())
# Noisy: {'00': 60, '11': 58, '01': 5, '10': 5}
```

### Response
#### Success Response (200)
None explicitly defined in the source.

#### Response Example
None explicitly defined in the source.
```

--------------------------------

### Install Aer Development Requirements

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Install the necessary development modules for Aer, which may be required for building with ROCm support.

```bash
cd <qiskit-aer source folder>
pip install -r requirements-dev.txt
```

--------------------------------

### Create a New Release Note with Reno

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Use this command to create a new release note file. The 'short-description-string' will be the prefix for the generated YAML file.

```bash
reno new short-description-string
```

--------------------------------

### AerSimulator.from_backend

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Create an AerSimulator instance that mirrors a real IBM Quantum backend, inheriting its noise model and configuration.

```APIDOC
## AerSimulator.from_backend

### Description
Instantiate `AerSimulator` to replicate the characteristics of a specified real IBM Quantum backend. This includes inheriting the backend's noise model, coupling map, and basis gates, allowing for realistic simulations of hardware behavior.

### Method
`AerSimulator.from_backend(backend)`

### Parameters
- **backend** (Backend) - The real IBM Quantum backend instance to mirror.

### Request Example
```python
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel='ibm_quantum', token='YOUR_TOKEN')
real_backend = service.get_backend('ibm_kyoto')

# Create a noisy simulator matching ibm_kyoto's characteristics
noisy_sim = AerSimulator.from_backend(real_backend)
```

### Response
#### Success Response (Initialization)
An instance of `AerSimulator` configured to match the provided `backend`.
```

--------------------------------

### Install Qiskit Aer with GPU Support

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Install the GPU-enabled version of Qiskit Aer. Requires CUDA 10.1 or newer and is only available on x86_64 Linux.

```sh
pip install qiskit-aer-gpu
```

--------------------------------

### Install Conan Package Manager

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Install the Conan Python package, which is required as a build dependency even if Conan's C/C++ package management is disabled.

```bash
$ pip install conan
```

--------------------------------

### Install qiskit-aer with GPU support (CUDA 11)

Source: https://github.com/qiskit/qiskit-aer/blob/main/README.md

Install the GPU-supported version of Aer for CUDA 11. This package provides the same functionality as the standard Aer package plus GPU acceleration.

```bash
pip install qiskit-aer-gpu-cu11
```

--------------------------------

### Create Noisy Simulator from Real Backend

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Configure AerSimulator to mimic a real IBM Quantum backend, inheriting its noise model, coupling map, and basis gates.

```python
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel='ibm_quantum', token='YOUR_TOKEN')
real_backend = service.get_backend('ibm_kyoto')

# Create a noisy simulator matching ibm_kyoto's characteristics
noisy_sim = AerSimulator.from_backend(real_backend)

from qiskit import QuantumCircuit, transpile
qc = QuantumCircuit(2)
nc.h(0)
nc.cx(0, 1)
nc.measure_all()

tqc = transpile(qc, noisy_sim)
result = noisy_sim.run(tqc, shots=1024).result()
print(result.get_counts())
# Noisy counts, e.g.: {'00': 498, '11': 490, '01': 18, '10': 18}
```

--------------------------------

### Install CUDA 11 Compatible Qiskit Aer GPU Package

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/release_notes.md

If you are running CUDA 11 locally and previously used the CUDA 10.x compatible qiskit-aer-gpu package, uninstall it and install the new CUDA 11 compatible package.

```default
pip uninstall qiskit-aer-gpu && pip install -U qiskit-aer-gpu-cu11
```

--------------------------------

### Build Noise Model from Fake Backend Calibration Data

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Constructs a noise model using calibration data from a fake backend and simulates a quantum circuit with this noise model.

```python
from qiskit_aer.noise import NoiseModel
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeVigo

backend = FakeVigo()
noise_model = NoiseModel.from_backend(backend)
coupling_map = backend.configuration().coupling_map
basis_gates = noise_model.basis_gates

nc = QuantumCircuit(3, 3)
nc.h(0); qc.cx(0, 1); qc.cx(1, 2)
nc.measure([0, 1, 2], [0, 1, 2])

sim = AerSimulator(noise_model=noise_model,
 coupling_map=coupling_map,
 basis_gates=basis_gates)
tqc = transpile(qc, sim)
result = sim.run(tqc, shots=1024).result()
print(result.get_counts())
# {'000': 480, '111': 490, '001': 20, '110': 18, ...}
```

--------------------------------

### SamplerV2 from_backend for noisy simulation

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Constructs a SamplerV2 instance that simulates a real backend, automatically incorporating its noise model. Useful for testing circuit performance under realistic noise conditions.

```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.primitives import SamplerV2
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel='ibm_quantum', token='YOUR_TOKEN')
real_backend = service.get_backend('ibm_kyoto')

# SamplerV2 backed by a noise model matching ibm_kyoto
sampler = SamplerV2.from_backend(real_backend)

bell = QuantumCircuit(2)
bell.h(0); bell.cx(0, 1); bell.measure_all()
bell_t = transpile(bell, AerSimulator(basis_gates=["ecr", "id", "rz", "sx"]),
                   optimization_level=0)

job = sampler.run([bell_t], shots=128)
result = job.result()
print(result[0].data.meas.get_counts())
# Noisy: {'00': 60, '11': 58, '01': 5, '10': 5}
```

--------------------------------

### Load fake IBM Quantum device backend

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Load calibration data from a fake IBM Quantum device backend to mimic real hardware properties.

```python
from qiskit_ibm_runtime.fake_provider import FakeVigo
device_backend = FakeVigo()
```

--------------------------------

### Density Matrix and Matrix Product State Simulation

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/1_aersimulator.ipynb

Demonstrates initializing AerSimulator with 'density_matrix' and 'matrix_product_state' methods and running simulations. Use these methods for circuits where density matrix or MPS representations are beneficial.

```python
sim_density = AerSimulator(method='density_matrix')
job_density = sim_density.run(circ, shots=shots)
counts_density = job_density.result().get_counts(0)

# Matrix Product State simulation method
sim_mps = AerSimulator(method='matrix_product_state')
job_mps = sim_mps.run(circ, shots=shots)
counts_mps = job_mps.result().get_counts(0)
```

--------------------------------

### Clone Qiskit Aer Repository

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/getting_started.md

Clone the Qiskit Aer GitHub repository to install from source. This allows access to the latest development version.

```sh
git clone https://github.com/Qiskit/qiskit-aer
```

--------------------------------

### AerSimulator Initialization

Source: https://context7.com/qiskit/qiskit-aer/llms.txt

Initialize the AerSimulator with different methods and device options. Demonstrates default, GPU, density matrix, and MPS methods.

```APIDOC
## AerSimulator Initialization

### Description
Initialize the `AerSimulator` with various simulation methods and device configurations. This includes setting the simulation method (e.g., 'statevector', 'density_matrix', 'matrix_product_state') and specifying the execution device ('CPU' or 'GPU').

### Method
`AerSimulator(method='automatic', device='CPU', precision='single', **kwargs)`

### Parameters
- **method** (str) - The simulation method to use. Defaults to 'automatic'. Available methods: ['automatic', 'statevector', 'density_matrix', 'stabilizer', 'extended_stabilizer', 'matrix_product_state', 'unitary', 'superop', 'tensor_network'].
- **device** (str) - The device to run the simulation on. Defaults to 'CPU'. Can be 'CPU' or 'GPU' if supported.
- **precision** (str) - The floating point precision to use for simulation. Defaults to 'single'. Can be 'single' or 'double'.

### Request Example
```python
from qiskit_aer import AerSimulator

# Default automatic method on CPU
sim = AerSimulator()

# Statevector method on GPU (requires qiskit-aer-gpu)
sim_gpu = AerSimulator(method='statevector', device='GPU')

# Density matrix method with double precision
sim_dm = AerSimulator(method='density_matrix', precision='double')

# Matrix Product State for large circuits
sim_mps = AerSimulator(method='matrix_product_state')
```

### Response
#### Success Response (Initialization)
An instance of `AerSimulator` configured with the specified options.

### Additional Information
- `AerSimulator.available_methods()`: Returns a list of available simulation methods.
- `AerSimulator.available_devices()`: Returns a list of available devices (e.g., ['CPU'], ['CPU', 'GPU']).
```

--------------------------------

### Get Circuits from AerJob

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/release_notes.md

The `AerJob` class now includes a `circuits()` method that returns a list of `QuantumCircuit` objects. This method returns `None` if the simulation used Qobj.

```python
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

circuit = QuantumCircuit(1)
circuit.h(0)

simulator = AerSimulator()
job = simulator.run(circuit)

circuits = job.circuits()
# circuits will be [QuantumCircuit(...)] if not using Qobj internally
```

--------------------------------

### Initialize AerSimulator

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/1_aersimulator.ipynb

Initializes the AerSimulator backend. This backend can be used to run quantum circuits.

```python
simulator = AerSimulator()
```

--------------------------------

### Create and simulate an ideal GHZ state circuit

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Construct a 3-qubit GHZ state circuit and simulate it using an ideal AerSimulator to get baseline counts.

```python
# Construct quantum circuit
circ = QuantumCircuit(3, 3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure([0, 1, 2], [0, 1, 2])

sim_ideal = AerSimulator()

# Execute and get counts
result = sim_ideal.run(transpile(circ, sim_ideal)).result()
counts = result.get_counts(0)
plot_histogram(counts, title='Ideal counts for 3-qubit GHZ state')
```

--------------------------------

### Execute noisy simulation and get counts

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Run a simulation with a noise model and retrieve the resulting counts. This is useful for analyzing the impact of device noise on quantum computations.

```python
result_noise = sim_vigo.run(tcirc).result()
counts_noise = result_noise.get_counts(0)
plot_histogram(counts_noise,
               title="Counts for 3-qubit GHZ state with device noise model")
```

--------------------------------

### Create and Activate Conda Environment

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Creates and activates a Conda virtual environment for Qiskit development on Windows. Ensure Anaconda3 and Visual Studio are installed prior to running these commands.

```bash
> conda create -y -n QiskitDevEnv python=3
> conda activate QiskitDevEnv
(QiskitDevEnv) >_
```

--------------------------------

### Initializing with a Custom Statevector using initialize

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/1_aersimulator.ipynb

The `initialize` instruction can also set a custom statevector. Unlike `set_statevector`, this instruction is compatible with real device backends after unrolling.

```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import qiskit.quantum_info as qi

# Use initilize instruction to set initial state
num_qubits = 2
psi = qi.random_statevector(2 ** num_qubits, seed=100)
circ = QuantumCircuit(num_qubits)
circ.initialize(psi, range(num_qubits))
circ.save_state()

# Transpile for simulator
simulator = AerSimulator(method= 'statevector')
circ = transpile(circ, simulator)

# Run and get result data
result = simulator.run(circ).result()
result.data(0)
```

--------------------------------

### Create and simulate a small circuit with extended stabilizer

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/6_extended_stabilizer_tutorial.ipynb

Defines a small quantum circuit and simulates it using the extended stabilizer method to observe its output and timing. This demonstrates the approximate nature of the results compared to exact simulators.

```python
small_circ = QuantumCircuit(2, 2)
small_circ.h(0)
small_circ.cx(0, 1)
small_circ.t(0)
small_circ.measure([0, 1], [0, 1])
# This circuit should give 00 or 11 with equal probability...
expected_results ={'00': 50, '11': 50)
```

```python
tsmall_circ = transpile(small_circ, extended_stabilizer_simulator)
result = extended_stabilizer_simulator.run(
    tsmall_circ, shots=100).result()
counts = result.get_counts(0)
print('100 shots in {}s'.format(result.time_taken))
```

--------------------------------

### Release Note YAML Structure

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Example of a release note file in YAML format. It includes sections for features, deprecations, and fixes, using restructured text for detailed descriptions.

```yaml
features:
  - | 
    Introduced a new feature ``foo``, that adds support for doing something to
    ``AerProvider`` objects. It can be used by using the ``foo`` function,
    for example::

      from qiskit_aer import foo
      from qiskit_aer import AerProvider
      foo(AerProvider())

  - | 
    The ``qiskit_aer.AerProvider`` module has a new method ``foo()``. This is
    the equivalent of calling the ``qiskit_aer.foo()`` to do something to your
    ``AerProvider``. This is the equivalent of running ``qiskit_aer.foo()`` on
    your provider, but it has the convenience of running it natively on
    an object. For example::

      from qiskit_aer import AerProvider

      provider = AerProvider()
      provider.foo()

deprecations:
  - | 
    The ``qiskit_aer.bar`` module has been deprecated and will be removed in a
    future release. Its sole function, ``foobar()`` has been superseded by the
    ``qiskit_aer.foo()`` function which provides similar functionality but with
    more accurate results and better performance. You should update your calls
    ``qiskit_aer.bar.foobar()`` calls to ``qiskit_aer.foo()``.
```

--------------------------------

### Initialize AerSimulator with Matrix Product State Method

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/7_matrix_product_state_method.ipynb

Use the AerSimulator by setting the simulation method to 'matrix_product_state'. This configures the simulator to use the MPS representation for quantum states. All subsequent operations are controlled by the AerSimulator instance.

```python
import numpy as np

# Import Qiskit
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

# Construct quantum circuit
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0, 1)
circ.measure([0,1], [0,1])

# Select the AerSimulator from the Aer provider
simulator = AerSimulator(method='matrix_product_state')

# Run and get counts, using the matrix_product_state method
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
counts = result.get_counts(0)
counts
```

--------------------------------

### Get MPI Rank in Qiskit Aer

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/howtos/running_gpu.md

Access metadata from the simulation result to retrieve the current MPI process ID (`mpi_rank`) and the total number of MPI processes (`num_mpi_processes`).

```python
sim = AerSimulator(method='statevector', device='GPU')
result = execute(circuit, sim, blocking_enable=True, blocking_qubits=23).result()
dict = result.to_dict()
meta = dict['metadata']
myrank = meta['mpi_rank']
```

--------------------------------

### Import necessary Qiskit modules

Source: https://github.com/qiskit/qiskit-aer/blob/main/docs/tutorials/2_device_noise_simulation.ipynb

Import the required classes for building circuits, simulators, and visualizing results.

```python
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
```

--------------------------------

### Release Note YAML with Issue Linking

Source: https://github.com/qiskit/qiskit-aer/blob/main/CONTRIBUTING.md

Example of a release note entry that links to a GitHub issue. The issue number is used as the link text, pointing to the specific issue on GitHub.

```yaml
fixes:
  - | 
    Fixes a race condition in the function ``foo()``. Refer to
    `#12345 <https://github.com/Qiskit/qiskit-aer/issues/12345>` for more
    details.
```