qiskit

Comprehensive guide for Qiskit - IBM's quantum computing framework. Use for quantum circuit design, quantum algorithms (VQE, QAOA, Grover, Shor), quantum simulation, noise modeling, quantum machine learning, and quantum chemistry calculations. Essential for quantum computing research and applications.

インストールへ移動

リポジトリ: tondevrel/scientific-agent-skills
ソースの最終更新活動: 2026年1月31日 18:18
検出された SKILL.md の言語: 英語
スター: 19
フォーク: 2

インストール方法

デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。

Codex または Claude でインストールこの Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。

直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。

npx skills add https://github.com/tondevrel/scientific-agent-skills --skill qiskit

コマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。

ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。

ソースファイルを確認

インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。

SKILL.md

ソースの指示 · 読み取り専用プレビュー

検索に戻るインストールに戻る

ase

Atomic Simulation Environment - a set of tools for setting up, manipulating, running, visualizing, and analyzing atomistic simulations. Acts as a universal interface between Python and numerous quantum chemical and molecular dynamics codes. Use for building atomic structures, geometry optimization, molecular dynamics simulations, transition state searches (NEB), file format conversion (CIF, XYZ, POSCAR, PDB), electronic property calculations (DOS, band structures), and automating simulation workflows with DFT/MD codes like VASP, GPAW, Quantum ESPRESSO, LAMMPS.

2026-02-01

astropy

The core library for Astronomy and Astrophysics in Python. Provides data structures for coordinates, time, units, FITS files, and cosmological models. Essential for observational data reduction and theoretical astrophysics. Use when working with astronomical coordinates (RA/Dec), physical units, FITS files, time scales, WCS, cosmology, or astronomical tables.

2026-02-01

chempy

A Python package useful for chemistry (mainly physical/analytical/inorganic chemistry). Features include balancing chemical reactions, chemical kinetics (ODE integration), chemical equilibria, ionic strength calculations, and unit handling. Use when working with chemical equations, reaction balancing, kinetic modeling, equilibrium calculations, speciation, pH calculations, ionic strength, activity coefficients, or chemical formula parsing.

2026-02-01

このリポジトリのすべてを見る

name	qiskit
description	Comprehensive guide for Qiskit - IBM's quantum computing framework. Use for quantum circuit design, quantum algorithms (VQE, QAOA, Grover, Shor), quantum simulation, noise modeling, quantum machine learning, and quantum chemistry calculations. Essential for quantum computing research and applications.
version	1
license	Apache-2.0

Qiskit - Quantum Computing Framework

Open-source quantum computing framework for building, simulating, and running quantum algorithms on quantum computers and simulators.

When to Use

Building quantum circuits and gates
Running quantum algorithms (VQE, QAOA, Grover, Shor)
Quantum chemistry calculations (integration with PySCF)
Quantum machine learning
Quantum simulation and noise modeling
Transpiling circuits for real quantum hardware
Quantum optimization problems
Quantum error correction
Quantum cryptography
Educational quantum computing demonstrations

Reference Documentation

Official docs: https://qiskit.org/documentation/
Search patterns: qiskit.circuit.QuantumCircuit, qiskit.algorithms.VQE, qiskit.quantum_info, qiskit_nature

Core Principles

Use Qiskit For

from qiskit import QuantumCircuit, transpile from qiskit.providers.aer import AerSimulator from qiskit.providers.aer.noise import NoiseModel, depolarizing_error import numpy as np from scipy.optimize import curve_fit def run_circuit_with_noise(circuit, noise_level, shots=1000): """Run circuit with scaled noise.""" # Create noise model noise_model = NoiseModel() error = depolarizing_error(noise_level, 1) noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3']) # Simulate simulator = AerSimulator(noise_model=noise_model) job = simulator.run(circuit, shots=shots) result = job.result() # Extract expectation value (simplified) counts = result.get_counts() expectation = sum(counts.get(bitstring, 0) * (-1)**bitstring.count('1') for bitstring in counts) / shots return expectation def zero_noise_extrapolation(circuit, noise_levels, shots=1000): """ Perform zero-noise extrapolation. Args: circuit: Quantum circuit noise_levels: List of noise scaling factors shots: Number of shots per simulation """ expectations = [] for noise in noise_levels: exp_val = run_circuit_with_noise(circuit, noise, shots) expectations.append(exp_val) print(f"Noise {noise:.4f}: Expectation = {exp_val:.4f}") # Fit exponential model: E(λ) = A + B * exp(-C * λ) def exp_model(x, a, b, c): return a + b * np.exp(-c * x) # Fit popt, _ = curve_fit(exp_model, noise_levels, expectations) # Extrapolate to zero noise zero_noise_value = exp_model(0, *popt) print(f"\nZero-noise extrapolated value: {zero_noise_value:.4f}") return zero_noise_value, expectations # Example circuit qc = QuantumCircuit(2, 2) qc.h(0) qc.cx(0, 1) qc.measure([0, 1], [0, 1]) # Run ZNE noise_levels = np.array([0.001, 0.005, 0.01, 0.02]) zne_value, measured_values = zero_noise_extrapolation(qc, noise_levels)

from qiskit.quantum_info import Statevector, DensityMatrix from qiskit import QuantumCircuit from qiskit.providers.aer import AerSimulator from qiskit.quantum_info.states import state_fidelity import numpy as np def perform_state_tomography(qc, shots=1000): """ Simplified quantum state tomography. Measures in X, Y, Z bases to reconstruct density matrix. """ simulator = AerSimulator() # Measurement circuits in different bases measurements = { 'Z': QuantumCircuit(qc.num_qubits, qc.num_qubits), 'X': QuantumCircuit(qc.num_qubits, qc.num_qubits), 'Y': QuantumCircuit(qc.num_qubits, qc.num_qubits) } # X basis: apply H before measurement measurements['X'].h(range(qc.num_qubits)) # Y basis: apply S†H before measurement measurements['Y'].sdg(range(qc.num_qubits)) measurements['Y'].h(range(qc.num_qubits)) # Measure all for basis_circ in measurements.values(): basis_circ.measure(range(qc.num_qubits), range(qc.num_qubits)) # Run measurements results = {} for basis, meas_circ in measurements.items(): full_circ = qc.copy() full_circ.compose(meas_circ, inplace=True) job = simulator.run(full_circ, shots=shots) results[basis] = job.result().get_counts() print(f"Z-basis measurements: {results['Z']}") print(f"X-basis measurements: {results['X']}") print(f"Y-basis measurements: {results['Y']}") # Simplified reconstruction (for single qubit) if qc.num_qubits == 1: # Extract Pauli expectation values z_exp = (results['Z'].get('0', 0) - results['Z'].get('1', 0)) / shots x_exp = (results['X'].get('0', 0) - results['X'].get('1', 0)) / shots y_exp = (results['Y'].get('0', 0) - results['Y'].get('1', 0)) / shots # Reconstruct density matrix: ρ = (I + x⟨X⟩ + y⟨Y⟩ + z⟨Z⟩)/2 rho = np.array([ [0.5 + 0.5*z_exp, 0.5*x_exp - 0.5j*y_exp], [0.5*x_exp + 0.5j*y_exp, 0.5 - 0.5*z_exp] ]) return DensityMatrix(rho) return None # Test on a known state qc = QuantumCircuit(1) qc.ry(np.pi/3, 0) # Rotate to create superposition # True state true_state = Statevector.from_instruction(qc) true_dm = DensityMatrix(true_state) # Tomography reconstructed_dm = perform_state_tomography(qc, shots=10000) if reconstructed_dm is not None: fidelity = state_fidelity(true_dm, reconstructed_dm) print(f"\nReconstruction fidelity: {fidelity:.6f}") print(f"\nTrue density matrix:\n{np.array(true_dm)}") print(f"\nReconstructed density matrix:\n{np.array(reconstructed_dm)}")

from qiskit_nature.second_q.drivers import PySCFDriver from qiskit_nature.second_q.mappers import JordanWignerMapper from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock from qiskit.algorithms import VQE from qiskit.algorithms.optimizers import SLSQP from qiskit.primitives import Estimator import numpy as np def calculate_molecule_energy(atom_string, basis='sto3g', charge=0, spin=0): """ Complete workflow for molecular energy calculation. Args: atom_string: Atomic coordinates (e.g., 'H 0 0 0; H 0 0 0.735') basis: Basis set charge: Molecular charge spin: Spin multiplicity """ print(f"Calculating energy for: {atom_string}") print(f"Basis: {basis}, Charge: {charge}, Spin: {spin}\n") # 1. Setup driver driver = PySCFDriver( atom=atom_string, basis=basis, charge=charge, spin=spin ) # 2. Get electronic structure problem problem = driver.run() # 3. Setup mapper mapper = JordanWignerMapper() # 4. Get Hamiltonian hamiltonian = problem.hamiltonian.second_q_op() qubit_op = mapper.map(hamiltonian) print(f"Number of qubits: {qubit_op.num_qubits}") print(f"Number of Hamiltonian terms: {len(qubit_op)}") # 5. Setup initial state and ansatz num_particles = problem.num_particles num_spatial_orbitals = problem.num_spatial_orbitals init_state = HartreeFock( num_spatial_orbitals=num_spatial_orbitals, num_particles=num_particles, qubit_mapper=mapper ) ansatz = UCCSD( num_spatial_orbitals=num_spatial_orbitals, num_particles=num_particles, qubit_mapper=mapper, initial_state=init_state ) print(f"Ansatz circuit depth: {ansatz.depth()}") print(f"Number of parameters: {ansatz.num_parameters}\n") # 6. Run VQE optimizer = SLSQP(maxiter=100) estimator = Estimator() vqe = VQE(estimator, ansatz, optimizer) result = vqe.compute_minimum_eigenvalue(qubit_op) # 7. Extract results vqe_energy = result.eigenvalue hf_energy = problem.reference_energy print(f"Hartree-Fock energy: {hf_energy:.6f} Ha") print(f"VQE energy: {vqe_energy:.6f} Ha") print(f"Correlation energy: {vqe_energy - hf_energy:.6f} Ha") print(f"Optimizer evaluations: {result.cost_function_evals}") return { 'vqe_energy': vqe_energy, 'hf_energy': hf_energy, 'correlation': vqe_energy - hf_energy, 'optimal_parameters': result.optimal_parameters, 'num_qubits': qubit_op.num_qubits } # Example: H2 molecule results = calculate_molecule_energy('H 0 0 0; H 0 0 0.735')

from qiskit import QuantumCircuit, transpile from qiskit.providers.fake_provider import FakeMontreal from qiskit.transpiler import PassManager, CouplingMap from qiskit.transpiler.passes import * import matplotlib.pyplot as plt def optimize_circuit_for_hardware(qc, backend=None, optimization_level=3): """ Complete circuit optimization pipeline. Args: qc: Input quantum circuit backend: Target backend (or None for generic optimization) optimization_level: 0-3 """ print(f"Original circuit:") print(f" Qubits: {qc.num_qubits}") print(f" Depth: {qc.depth()}") print(f" Gate count: {len(qc.data)}") print(f" Operations: {qc.count_ops()}\n") if backend is None: backend = FakeMontreal() # Standard transpilation transpiled = transpile( qc, backend=backend, optimization_level=optimization_level, seed_transpiler=42 ) print(f"After transpilation (level {optimization_level}):") print(f" Depth: {transpiled.depth()}") print(f" Gate count: {len(transpiled.data)}") print(f" Operations: {transpiled.count_ops()}") print(f" SWAP gates: {transpiled.count_ops().get('swap', 0)}\n") # Custom optimization passes pm = PassManager() # Add passes pm.append(Optimize1qGates()) pm.append(CommutativeCancellation()) pm.append(CXCancellation()) further_optimized = pm.run(transpiled) print(f"After custom optimization:") print(f" Depth: {further_optimized.depth()}") print(f" Gate count: {len(further_optimized.data)}") print(f" Operations: {further_optimized.count_ops()}\n") # Calculate reduction depth_reduction = (1 - further_optimized.depth() / qc.depth()) * 100 gate_reduction = (1 - len(further_optimized.data) / len(qc.data)) * 100 print(f"Optimization results:") print(f" Depth reduction: {depth_reduction:.1f}%") print(f" Gate count reduction: {gate_reduction:.1f}%") return further_optimized # Example: Complex circuit qc = QuantumCircuit(4) qc.h(range(4)) for i in range(3): qc.cx(i, i+1) qc.barrier() for i in range(4): qc.ry(np.pi/4, i) qc.barrier() for i in range(2): qc.cx(i, i+2) optimized = optimize_circuit_for_hardware(qc)

from qiskit import QuantumCircuit from qiskit.algorithms import VQE, QAOA from qiskit.algorithms.optimizers import SLSQP, COBYLA, SPSA from qiskit.circuit.library import RealAmplitudes from qiskit.primitives import Estimator from qiskit.quantum_info import SparsePauliOp import time import numpy as np def benchmark_vqe_optimizers(hamiltonian, ansatz, optimizers_dict, trials=3): """ Benchmark different optimizers for VQE. Args: hamiltonian: Problem Hamiltonian ansatz: Variational ansatz optimizers_dict: Dict of optimizer name -> optimizer instance trials: Number of trials per optimizer """ results = {} for opt_name, optimizer in optimizers_dict.items(): print(f"\nBenchmarking {opt_name}...") trial_results = [] for trial in range(trials): estimator = Estimator() vqe = VQE(estimator, ansatz, optimizer) start_time = time.time() result = vqe.compute_minimum_eigenvalue(hamiltonian) elapsed_time = time.time() - start_time trial_results.append({ 'energy': result.eigenvalue, 'time': elapsed_time, 'evals': result.cost_function_evals }) print(f" Trial {trial + 1}: E = {result.eigenvalue:.6f}, " f"Time = {elapsed_time:.2f}s, Evals = {result.cost_function_evals}") # Aggregate results energies = [r['energy'] for r in trial_results] times = [r['time'] for r in trial_results] evals = [r['evals'] for r in trial_results] results[opt_name] = { 'mean_energy': np.mean(energies), 'std_energy': np.std(energies), 'mean_time': np.mean(times), 'mean_evals': np.mean(evals), 'best_energy': min(energies) } # Print summary print("\n" + "="*60) print("BENCHMARK SUMMARY") print("="*60) print(f"{'Optimizer':<15} {'Best Energy':>12} {'Mean Time':>12} {'Mean Evals':>12}") print("-"*60) for opt_name, res in results.items(): print(f"{opt_name:<15} {res['best_energy']:>12.6f} " f"{res['mean_time']:>12.2f}s {res['mean_evals']:>12.0f}") return results # Example: Benchmark for simple Hamiltonian hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5]) ansatz = RealAmplitudes(num_qubits=2, reps=2) optimizers = { 'SLSQP': SLSQP(maxiter=100), 'COBYLA': COBYLA(maxiter=100), 'SPSA': SPSA(maxiter=100) } benchmark_results = benchmark_vqe_optimizers(hamiltonian, ansatz, optimizers, trials=3)

from qiskit.algorithms import VQE from qiskit.algorithms.optimizers import SLSQP, COBYLA from qiskit.circuit.library import RealAmplitudes from qiskit.primitives import Estimator from qiskit.quantum_info import SparsePauliOp import numpy as np def robust_vqe(hamiltonian, n_qubits, max_attempts=5): """ VQE with multiple restart attempts and parameter initialization. Args: hamiltonian: Problem Hamiltonian n_qubits: Number of qubits max_attempts: Maximum restart attempts """ best_result = None best_energy = float('inf') for attempt in range(max_attempts): print(f"\nAttempt {attempt + 1}/{max_attempts}") # Create fresh ansatz ansatz = RealAmplitudes(num_qubits=n_qubits, reps=2) # Initialize parameters randomly (but bounded) initial_point = np.random.uniform(-np.pi, np.pi, ansatz.num_parameters) # Try different optimizers if attempt < max_attempts // 2: optimizer = COBYLA(maxiter=200) else: optimizer = SLSQP(maxiter=200) estimator = Estimator() vqe = VQE(estimator, ansatz, optimizer, initial_point=initial_point) try: result = vqe.compute_minimum_eigenvalue(hamiltonian) print(f" Energy: {result.eigenvalue:.6f}") print(f" Evaluations: {result.cost_function_evals}") if result.eigenvalue < best_energy: best_energy = result.eigenvalue best_result = result print(f" ✓ New best energy!") except Exception as e: print(f" ✗ Failed: {e}") continue if best_result is None: raise RuntimeError("All VQE attempts failed") print(f"\nBest energy found: {best_energy:.6f}") return best_result # Example usage hamiltonian = SparsePauliOp(['ZZ', 'XI', 'IX'], coeffs=[1.0, -0.5, -0.5]) result = robust_vqe(hamiltonian, n_qubits=2, max_attempts=3)

Task	Module	Example
Circuit building	`qiskit`	`QuantumCircuit(2, 2)`
Quantum algorithms	`qiskit.algorithms`	`VQE(ansatz, optimizer)`
Quantum simulation	`qiskit.providers.aer`	`AerSimulator()`
Quantum chemistry	`qiskit_nature`	`GroundStateEigensolver()`
Noise modeling	`qiskit.providers.aer.noise`	`NoiseModel()`
Transpilation	`qiskit.transpiler`	`transpile(circuit, backend)`
Quantum ML	`qiskit_machine_learning`	`VQC(feature_map, ansatz)`
Visualization	`qiskit.visualization`	`plot_histogram(counts)`

qiskit

ソース情報

インストール方法

ソースファイルを確認

このリポジトリの他の Skills

このリポジトリの他の Skills

Qiskit - Quantum Computing Framework

When to Use

Reference Documentation

Core Principles

Use Qiskit For

Qiskit - Quantum Computing Framework

When to Use

Reference Documentation

Core Principles

Use Qiskit For

Do NOT Use For

Quick Reference

Installation

Standard Imports

Basic Pattern - Circuit Building

Basic Pattern - Quantum Algorithm

Critical Rules

✅ DO

❌ DON'T

Anti-Patterns (NEVER)

Quantum Circuits (qiskit.QuantumCircuit)

Basic Circuit Construction

Single-Qubit Gates

Two-Qubit Gates

Creating Entanglement

Parameterized Circuits

Quantum Algorithms

Variational Quantum Eigensolver (VQE)

QAOA (Quantum Approximate Optimization Algorithm)

Grover's Algorithm (Quantum Search)

Quantum Phase Estimation (QPE)

Quantum Chemistry with Qiskit Nature

Molecular Ground State Calculation

Excited States Calculation

Molecular Potential Energy Surface

Quantum Simulation

Hamiltonian Simulation with Trotter

Variational Quantum Simulation

Quantum Machine Learning

Quantum Kernel Method

Variational Quantum Classifier (VQC)

Quantum Neural Network (QNN)

Noise Modeling and Error Mitigation

Noise Models

Zero-Noise Extrapolation (ZNE)

Measurement Error Mitigation

Transpilation and Optimization

Basic Transpilation

Custom Transpilation Pass

Layout and Routing

Quantum Information Theory

Entanglement Measures

Quantum Channels and Process Tomography

Quantum State Tomography

Visualization

Circuit Visualization

Result Visualization

State Visualization

Practical Workflows

Complete VQE Workflow for Molecule

Quantum Circuit Optimization Pipeline

Quantum Algorithm Benchmarking

Common Pitfalls and Solutions

Memory Management for Large Circuits

Handling Convergence Issues in VQE