or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

circuit-construction.mdcircuit-formats.mdgates-operations.mdindex.mdprimitives.mdproviders.mdquantum-information.mdsynthesis.mdtranspilation.mdvisualization.md
tile.json

tessl/pypi-qiskit

An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/qiskit@2.1.x

To install, run

npx @tessl/cli install tessl/pypi-qiskit@2.1.0

index.mddocs/

Qiskit

Qiskit is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives. It provides comprehensive quantum computing capabilities including circuit construction, quantum information processing, hardware-aware transpilation, and quantum algorithm development.

Package Information

  • Package Name: qiskit
  • Language: Python
  • Installation: pip install qiskit
  • Version: 2.1.2

Core Imports

import qiskit

Essential components:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import transpile
from qiskit.quantum_info import Statevector, Operator
from qiskit.primitives import Sampler, Estimator

Basic Usage

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.primitives import StatevectorSampler
import numpy as np

# Create quantum and classical registers
qreg = QuantumRegister(2, 'q')
creg = ClassicalRegister(2, 'c')

# Build a quantum circuit
circuit = QuantumCircuit(qreg, creg)
circuit.h(qreg[0])  # Hadamard gate on first qubit
circuit.cx(qreg[0], qreg[1])  # CNOT gate creating entanglement
circuit.measure(qreg, creg)  # Measure all qubits

# Transpile for optimization
transpiled_circuit = transpile(circuit, optimization_level=1)

# Execute using V2 primitives
sampler = StatevectorSampler()
job = sampler.run([transpiled_circuit], shots=1024)
result = job.result()
counts = result[0].data.c.get_counts()  # Access by register name
print(f"Measurement counts: {counts}")

Architecture

Qiskit's modular architecture enables quantum computing workflows from high-level algorithms to low-level hardware control:

  • Circuit Framework: Quantum circuit construction with registers, gates, and measurements
  • Quantum Information: Mathematical foundation with states, operators, and information measures
  • Primitives: Modern execution interface (Sampler for measurements, Estimator for expectation values)
  • Transpiler: Hardware-aware circuit optimization and mapping system
  • Providers: Hardware abstraction layer for various quantum backends
  • Synthesis: Advanced algorithm synthesis and decomposition techniques

This design supports the full quantum computing stack from research algorithms to production quantum applications.

Capabilities

Circuit Construction

Build and manipulate quantum circuits with comprehensive gate libraries, control flow, and parameterization support.

class QuantumCircuit:
    def __init__(self, *args, **kwargs): ...
    def h(self, qubit): ...
    def cx(self, control_qubit, target_qubit): ...
    def measure(self, qubit, clbit): ...
    def add_register(self, register): ...

class QuantumRegister:
    def __init__(self, size: int, name: str = None): ...

class ClassicalRegister:
    def __init__(self, size: int, name: str = None): ...

Circuit Construction

Quantum Information Processing

Work with quantum states, operators, channels and information-theoretic measures for quantum algorithm development.

class Statevector:
    def __init__(self, data, dims=None): ...
    def evolve(self, other): ...
    def expectation_value(self, oper): ...

class Operator:
    def __init__(self, data, input_dims=None, output_dims=None): ...
    def compose(self, other): ...
    def tensor(self, other): ...

def state_fidelity(state1, state2): ...
def process_fidelity(channel1, channel2): ...

Quantum Information

Quantum Primitives

Execute quantum circuits using modern V2 primitives interface with Primitive Unified Blocs (PUBs) for efficient vectorized computation.

class StatevectorSampler:
    def run(self, pubs, *, shots=None): ...

class StatevectorEstimator:  
    def run(self, pubs, *, precision=None): ...

class PrimitiveResult:
    def __getitem__(self, index): ...  # Access PubResults

class SamplerPubResult:
    data: DataBin  # Access via register names, e.g., data.c

class EstimatorPubResult:
    data: DataBin  # Access expectation values via data.evs

Primitives

Circuit Transpilation

Optimize and map quantum circuits for specific hardware backends with comprehensive pass management.

def transpile(circuits, backend=None, optimization_level=None, **kwargs): ...

def generate_preset_pass_manager(optimization_level, backend=None, **kwargs): ...

class PassManager:
    def run(self, circuits): ...
    def append(self, passes): ...

class CouplingMap:
    def __init__(self, couplinglist=None, description=None): ...

Transpilation

Quantum Gates and Operations

Comprehensive library of quantum gates from basic Pauli operations to advanced multi-qubit gates and composite operations.

# Single-qubit gates
class HGate(Gate): ...
class XGate(Gate): ...
class RZGate(Gate):
    def __init__(self, phi): ...

# Two-qubit gates  
class CXGate(Gate): ...
class CZGate(Gate): ...
class SwapGate(Gate): ...

# Multi-qubit gates
class CCXGate(Gate): ...
class MCXGate(Gate):
    def __init__(self, num_ctrl_qubits): ...

Gates and Operations

Hardware Providers

Abstract interface to quantum hardware backends with configuration, job management, and provider ecosystem.

class Backend:
    def run(self, circuits, **kwargs): ...
    @property 
    def target(self): ...

class Job:
    def result(self): ...
    def status(self): ...

class BackendConfiguration:
    n_qubits: int
    coupling_map: List[List[int]]

Providers

Algorithm Synthesis

Advanced synthesis techniques for Clifford circuits, permutations, linear functions, and quantum algorithm primitives.

def synth_clifford_full(clifford): ...
def synth_permutation_depth_lnn_kms(pattern): ...
def synth_cnot_count_full_pmh(state): ...

class LieTrotter:
    def __init__(self, reps=1): ...

class SuzukiTrotter:
    def __init__(self, order, reps=1): ...

Synthesis

Quantum Circuit Formats

Import/export quantum circuits in OpenQASM 2.0/3.0 and QPY binary formats for interoperability.

# QASM2
def load(filename): ...
def loads(qasm_str): ...
def dump(circuit, filename): ...
def dumps(circuit): ...

# QPY
def dump(circuits, file_obj): ...
def load(file_obj): ...

Circuit Formats

Visualization

Comprehensive visualization tools for quantum circuits, states, measurement results, and hardware topologies.

def circuit_drawer(circuit, output=None, **kwargs): ...
def plot_histogram(data, **kwargs): ...
def plot_bloch_vector(bloch, **kwargs): ...
def plot_state_qsphere(state, **kwargs): ...
def visualize_transition(circuit, **kwargs): ...

Visualization

Types

from typing import Union, List, Dict, Optional, Tuple, Any
import numpy as np

# Core types
Qubit = object  # Individual quantum bit
Clbit = object  # Individual classical bit

# Circuit types
ParameterExpression = object  # Mathematical expressions with parameters
Instruction = object  # Base quantum instruction
Gate = object  # Unitary quantum gate
ControlFlowOp = object  # Base control flow operation

# Quantum information types  
ArrayLike = Union[List, np.ndarray, 'Statevector', 'DensityMatrix']
OperatorLike = Union['Operator', 'Gate', np.ndarray, List]

# Provider types
BackendLike = Union['Backend', str]
JobLike = Union['Job', 'JobV1']

# Result types
CountsDict = Dict[str, int]  # Measurement counts
ProbsDict = Dict[str, float]  # Probability distributions
DataBin = object  # Primitive result data container
BitArray = object  # Measurement result bit array