@bgicli/bgicli 2.2.8 → 2.2.9

package/data/skills/qiskit/SKILL.md

@@ -0,0 +1,273 @@
+---
+name: qiskit
+description: IBM quantum computing framework. Use when targeting IBM Quantum hardware, working with Qiskit Runtime for production workloads, or needing IBM optimization tools. Best for IBM hardware execution, quantum error mitigation, and enterprise quantum computing. For Google hardware use cirq; for gradient-based quantum ML use pennylane; for open quantum system simulations use qutip.
+license: Apache-2.0 license
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# Qiskit
+
+## Overview
+
+Qiskit is the world's most popular open-source quantum computing framework with 13M+ downloads. Build quantum circuits, optimize for hardware, execute on simulators or real quantum computers, and analyze results. Supports IBM Quantum (100+ qubit systems), IonQ, Amazon Braket, and other providers.
+
+**Key Features:**
+- 83x faster transpilation than competitors
+- 29% fewer two-qubit gates in optimized circuits
+- Backend-agnostic execution (local simulators or cloud hardware)
+- Comprehensive algorithm libraries for optimization, chemistry, and ML
+
+## Quick Start
+
+### Installation
+
+```bash
+uv pip install qiskit
+uv pip install "qiskit[visualization]" matplotlib
+```
+
+### First Circuit
+
+```python
+from qiskit import QuantumCircuit
+from qiskit.primitives import StatevectorSampler
+
+# Create Bell state (entangled qubits)
+qc = QuantumCircuit(2)
+qc.h(0)           # Hadamard on qubit 0
+qc.cx(0, 1)       # CNOT from qubit 0 to 1
+qc.measure_all()  # Measure both qubits
+
+# Run locally
+sampler = StatevectorSampler()
+result = sampler.run([qc], shots=1024).result()
+counts = result[0].data.meas.get_counts()
+print(counts)  # {'00': ~512, '11': ~512}
+```
+
+### Visualization
+
+```python
+from qiskit.visualization import plot_histogram
+
+qc.draw('mpl')           # Circuit diagram
+plot_histogram(counts)   # Results histogram
+```
+
+## Core Capabilities
+
+### 1. Setup and Installation
+For detailed installation, authentication, and IBM Quantum account setup:
+- **See `references/setup.md`**
+
+Topics covered:
+- Installation with uv
+- Python environment setup
+- IBM Quantum account and API token configuration
+- Local vs. cloud execution
+
+### 2. Building Quantum Circuits
+For constructing quantum circuits with gates, measurements, and composition:
+- **See `references/circuits.md`**
+
+Topics covered:
+- Creating circuits with QuantumCircuit
+- Single-qubit gates (H, X, Y, Z, rotations, phase gates)
+- Multi-qubit gates (CNOT, SWAP, Toffoli)
+- Measurements and barriers
+- Circuit composition and properties
+- Parameterized circuits for variational algorithms
+
+### 3. Primitives (Sampler and Estimator)
+For executing quantum circuits and computing results:
+- **See `references/primitives.md`**
+
+Topics covered:
+- **Sampler**: Get bitstring measurements and probability distributions
+- **Estimator**: Compute expectation values of observables
+- V2 interface (StatevectorSampler, StatevectorEstimator)
+- IBM Quantum Runtime primitives for hardware
+- Sessions and Batch modes
+- Parameter binding
+
+### 4. Transpilation and Optimization
+For optimizing circuits and preparing for hardware execution:
+- **See `references/transpilation.md`**
+
+Topics covered:
+- Why transpilation is necessary
+- Optimization levels (0-3)
+- Six transpilation stages (init, layout, routing, translation, optimization, scheduling)
+- Advanced features (virtual permutation elision, gate cancellation)
+- Common parameters (initial_layout, approximation_degree, seed)
+- Best practices for efficient circuits
+
+### 5. Visualization
+For displaying circuits, results, and quantum states:
+- **See `references/visualization.md`**
+
+Topics covered:
+- Circuit drawings (text, matplotlib, LaTeX)
+- Result histograms
+- Quantum state visualization (Bloch sphere, state city, QSphere)
+- Backend topology and error maps
+- Customization and styling
+- Saving publication-quality figures
+
+### 6. Hardware Backends
+For running on simulators and real quantum computers:
+- **See `references/backends.md`**
+
+Topics covered:
+- IBM Quantum backends and authentication
+- Backend properties and status
+- Running on real hardware with Runtime primitives
+- Job management and queuing
+- Session mode (iterative algorithms)
+- Batch mode (parallel jobs)
+- Local simulators (StatevectorSampler, Aer)
+- Third-party providers (IonQ, Amazon Braket)
+- Error mitigation strategies
+
+### 7. Qiskit Patterns Workflow
+For implementing the four-step quantum computing workflow:
+- **See `references/patterns.md`**
+
+Topics covered:
+- **Map**: Translate problems to quantum circuits
+- **Optimize**: Transpile for hardware
+- **Execute**: Run with primitives
+- **Post-process**: Extract and analyze results
+- Complete VQE example
+- Session vs. Batch execution
+- Common workflow patterns
+
+### 8. Quantum Algorithms and Applications
+For implementing specific quantum algorithms:
+- **See `references/algorithms.md`**
+
+Topics covered:
+- **Optimization**: VQE, QAOA, Grover's algorithm
+- **Chemistry**: Molecular ground states, excited states, Hamiltonians
+- **Machine Learning**: Quantum kernels, VQC, QNN
+- **Algorithm libraries**: Qiskit Nature, Qiskit ML, Qiskit Optimization
+- Physics simulations and benchmarking
+
+## Workflow Decision Guide
+
+**If you need to:**
+
+- Install Qiskit or set up IBM Quantum account → `references/setup.md`
+- Build a new quantum circuit → `references/circuits.md`
+- Understand gates and circuit operations → `references/circuits.md`
+- Run circuits and get measurements → `references/primitives.md`
+- Compute expectation values → `references/primitives.md`
+- Optimize circuits for hardware → `references/transpilation.md`
+- Visualize circuits or results → `references/visualization.md`
+- Execute on IBM Quantum hardware → `references/backends.md`
+- Connect to third-party providers → `references/backends.md`
+- Implement end-to-end quantum workflow → `references/patterns.md`
+- Build specific algorithm (VQE, QAOA, etc.) → `references/algorithms.md`
+- Solve chemistry or optimization problems → `references/algorithms.md`
+
+## Best Practices
+
+### Development Workflow
+
+1. **Start with simulators**: Test locally before using hardware
+   ```python
+   from qiskit.primitives import StatevectorSampler
+   sampler = StatevectorSampler()
+   ```
+
+2. **Always transpile**: Optimize circuits before execution
+   ```python
+   from qiskit import transpile
+   qc_optimized = transpile(qc, backend=backend, optimization_level=3)
+   ```
+
+3. **Use appropriate primitives**:
+   - Sampler for bitstrings (optimization algorithms)
+   - Estimator for expectation values (chemistry, physics)
+
+4. **Choose execution mode**:
+   - Session: Iterative algorithms (VQE, QAOA)
+   - Batch: Independent parallel jobs
+   - Single job: One-off experiments
+
+### Performance Optimization
+
+- Use optimization_level=3 for production
+- Minimize two-qubit gates (major error source)
+- Test with noisy simulators before hardware
+- Save and reuse transpiled circuits
+- Monitor convergence in variational algorithms
+
+### Hardware Execution
+
+- Check backend status before submitting
+- Use least_busy() for testing
+- Save job IDs for later retrieval
+- Apply error mitigation (resilience_level)
+- Start with fewer shots, increase for final runs
+
+## Common Patterns
+
+### Pattern 1: Simple Circuit Execution
+
+```python
+from qiskit import QuantumCircuit, transpile
+from qiskit.primitives import StatevectorSampler
+
+qc = QuantumCircuit(2)
+qc.h(0)
+qc.cx(0, 1)
+qc.measure_all()
+
+sampler = StatevectorSampler()
+result = sampler.run([qc], shots=1024).result()
+counts = result[0].data.meas.get_counts()
+```
+
+### Pattern 2: Hardware Execution with Transpilation
+
+```python
+from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
+from qiskit import transpile
+
+service = QiskitRuntimeService()
+backend = service.backend("ibm_brisbane")
+
+qc_optimized = transpile(qc, backend=backend, optimization_level=3)
+
+sampler = Sampler(backend)
+job = sampler.run([qc_optimized], shots=1024)
+result = job.result()
+```
+
+### Pattern 3: Variational Algorithm (VQE)
+
+```python
+from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator
+from scipy.optimize import minimize
+
+with Session(backend=backend) as session:
+    estimator = Estimator(session=session)
+
+    def cost_function(params):
+        bound_qc = ansatz.assign_parameters(params)
+        qc_isa = transpile(bound_qc, backend=backend)
+        result = estimator.run([(qc_isa, hamiltonian)]).result()
+        return result[0].data.evs
+
+    result = minimize(cost_function, initial_params, method='COBYLA')
+```
+
+## Additional Resources
+
+- **Official Docs**: https://quantum.ibm.com/docs
+- **Qiskit Textbook**: https://qiskit.org/learn
+- **API Reference**: https://docs.quantum.ibm.com/api/qiskit
+- **Patterns Guide**: https://quantum.cloud.ibm.com/docs/en/guides/intro-to-patterns
+

package/data/skills/qutip/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: qutip
+description: Quantum physics simulation library for open quantum systems. Use when studying master equations, Lindblad dynamics, decoherence, quantum optics, or cavity QED. Best for physics research, open system dynamics, and educational simulations. NOT for circuit-based quantum computing—use qiskit, cirq, or pennylane for quantum algorithms and hardware execution.
+license: BSD-3-Clause license
+metadata:
+    skill-author: K-Dense Inc.
+---
+
+# QuTiP: Quantum Toolbox in Python
+
+## Overview
+
+QuTiP provides comprehensive tools for simulating and analyzing quantum mechanical systems. It handles both closed (unitary) and open (dissipative) quantum systems with multiple solvers optimized for different scenarios.
+
+## Installation
+
+```bash
+uv pip install qutip
+```
+
+Optional packages for additional functionality:
+
+```bash
+# Quantum information processing (circuits, gates)
+uv pip install qutip-qip
+
+# Quantum trajectory viewer
+uv pip install qutip-qtrl
+```
+
+## Quick Start
+
+```python
+from qutip import *
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Create quantum state
+psi = basis(2, 0)  # |0⟩ state
+
+# Create operator
+H = sigmaz()  # Hamiltonian
+
+# Time evolution
+tlist = np.linspace(0, 10, 100)
+result = sesolve(H, psi, tlist, e_ops=[sigmaz()])
+
+# Plot results
+plt.plot(tlist, result.expect[0])
+plt.xlabel('Time')
+plt.ylabel('⟨σz⟩')
+plt.show()
+```
+
+## Core Capabilities
+
+### 1. Quantum Objects and States
+
+Create and manipulate quantum states and operators:
+
+```python
+# States
+psi = basis(N, n)  # Fock state |n⟩
+psi = coherent(N, alpha)  # Coherent state |α⟩
+rho = thermal_dm(N, n_avg)  # Thermal density matrix
+
+# Operators
+a = destroy(N)  # Annihilation operator
+H = num(N)  # Number operator
+sx, sy, sz = sigmax(), sigmay(), sigmaz()  # Pauli matrices
+
+# Composite systems
+psi_AB = tensor(psi_A, psi_B)  # Tensor product
+```
+
+**See** `references/core_concepts.md` for comprehensive coverage of quantum objects, states, operators, and tensor products.
+
+### 2. Time Evolution and Dynamics
+
+Multiple solvers for different scenarios:
+
+```python
+# Closed systems (unitary evolution)
+result = sesolve(H, psi0, tlist, e_ops=[num(N)])
+
+# Open systems (dissipation)
+c_ops = [np.sqrt(0.1) * destroy(N)]  # Collapse operators
+result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
+
+# Quantum trajectories (Monte Carlo)
+result = mcsolve(H, psi0, tlist, c_ops, ntraj=500, e_ops=[num(N)])
+```
+
+**Solver selection guide:**
+- `sesolve`: Pure states, unitary evolution
+- `mesolve`: Mixed states, dissipation, general open systems
+- `mcsolve`: Quantum jumps, photon counting, individual trajectories
+- `brmesolve`: Weak system-bath coupling
+- `fmmesolve`: Time-periodic Hamiltonians (Floquet)
+
+**See** `references/time_evolution.md` for detailed solver documentation, time-dependent Hamiltonians, and advanced options.
+
+### 3. Analysis and Measurement
+
+Compute physical quantities:
+
+```python
+# Expectation values
+n_avg = expect(num(N), psi)
+
+# Entropy measures
+S = entropy_vn(rho)  # Von Neumann entropy
+C = concurrence(rho)  # Entanglement (two qubits)
+
+# Fidelity and distance
+F = fidelity(psi1, psi2)
+D = tracedist(rho1, rho2)
+
+# Correlation functions
+corr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)
+w, S = spectrum_correlation_fft(taulist, corr)
+
+# Steady states
+rho_ss = steadystate(H, c_ops)
+```
+
+**See** `references/analysis.md` for entropy, fidelity, measurements, correlation functions, and steady state calculations.
+
+### 4. Visualization
+
+Visualize quantum states and dynamics:
+
+```python
+# Bloch sphere
+b = Bloch()
+b.add_states(psi)
+b.show()
+
+# Wigner function (phase space)
+xvec = np.linspace(-5, 5, 200)
+W = wigner(psi, xvec, xvec)
+plt.contourf(xvec, xvec, W, 100, cmap='RdBu')
+
+# Fock distribution
+plot_fock_distribution(psi)
+
+# Matrix visualization
+hinton(rho)  # Hinton diagram
+matrix_histogram(H.full())  # 3D bars
+```
+
+**See** `references/visualization.md` for Bloch sphere animations, Wigner functions, Q-functions, and matrix visualizations.
+
+### 5. Advanced Methods
+
+Specialized techniques for complex scenarios:
+
+```python
+# Floquet theory (periodic Hamiltonians)
+T = 2 * np.pi / w_drive
+f_modes, f_energies = floquet_modes(H, T, args)
+result = fmmesolve(H, psi0, tlist, c_ops, T=T, args=args)
+
+# HEOM (non-Markovian, strong coupling)
+from qutip.nonmarkov.heom import HEOMSolver, BosonicBath
+bath = BosonicBath(Q, ck_real, vk_real)
+hsolver = HEOMSolver(H_sys, [bath], max_depth=5)
+result = hsolver.run(rho0, tlist)
+
+# Permutational invariance (identical particles)
+psi = dicke(N, j, m)  # Dicke states
+Jz = jspin(N, 'z')  # Collective operators
+```
+
+**See** `references/advanced.md` for Floquet theory, HEOM, permutational invariance, stochastic solvers, superoperators, and performance optimization.
+
+## Common Workflows
+
+### Simulating a Damped Harmonic Oscillator
+
+```python
+# System parameters
+N = 20  # Hilbert space dimension
+omega = 1.0  # Oscillator frequency
+kappa = 0.1  # Decay rate
+
+# Hamiltonian and collapse operators
+H = omega * num(N)
+c_ops = [np.sqrt(kappa) * destroy(N)]
+
+# Initial state
+psi0 = coherent(N, 3.0)
+
+# Time evolution
+tlist = np.linspace(0, 50, 200)
+result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
+
+# Visualize
+plt.plot(tlist, result.expect[0])
+plt.xlabel('Time')
+plt.ylabel('⟨n⟩')
+plt.title('Photon Number Decay')
+plt.show()
+```
+
+### Two-Qubit Entanglement Dynamics
+
+```python
+# Create Bell state
+psi0 = bell_state('00')
+
+# Local dephasing on each qubit
+gamma = 0.1
+c_ops = [
+    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),
+    np.sqrt(gamma) * tensor(qeye(2), sigmaz())
+]
+
+# Track entanglement
+def compute_concurrence(t, psi):
+    rho = ket2dm(psi) if psi.isket else psi
+    return concurrence(rho)
+
+tlist = np.linspace(0, 10, 100)
+result = mesolve(qeye([2, 2]), psi0, tlist, c_ops)
+
+# Compute concurrence for each state
+C_t = [concurrence(state.proj()) for state in result.states]
+
+plt.plot(tlist, C_t)
+plt.xlabel('Time')
+plt.ylabel('Concurrence')
+plt.title('Entanglement Decay')
+plt.show()
+```
+
+### Jaynes-Cummings Model
+
+```python
+# System parameters
+N = 10  # Cavity Fock space
+wc = 1.0  # Cavity frequency
+wa = 1.0  # Atom frequency
+g = 0.05  # Coupling strength
+
+# Operators
+a = tensor(destroy(N), qeye(2))  # Cavity
+sm = tensor(qeye(N), sigmam())  # Atom
+
+# Hamiltonian (RWA)
+H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
+
+# Initial state: cavity in coherent state, atom in ground state
+psi0 = tensor(coherent(N, 2), basis(2, 0))
+
+# Dissipation
+kappa = 0.1  # Cavity decay
+gamma = 0.05  # Atomic decay
+c_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]
+
+# Observables
+n_cav = a.dag() * a
+n_atom = sm.dag() * sm
+
+# Evolve
+tlist = np.linspace(0, 50, 200)
+result = mesolve(H, psi0, tlist, c_ops, e_ops=[n_cav, n_atom])
+
+# Plot
+fig, axes = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
+axes[0].plot(tlist, result.expect[0])
+axes[0].set_ylabel('⟨n_cavity⟩')
+axes[1].plot(tlist, result.expect[1])
+axes[1].set_ylabel('⟨n_atom⟩')
+axes[1].set_xlabel('Time')
+plt.tight_layout()
+plt.show()
+```
+
+## Tips for Efficient Simulations
+
+1. **Truncate Hilbert spaces**: Use smallest dimension that captures dynamics
+2. **Choose appropriate solver**: `sesolve` for pure states is faster than `mesolve`
+3. **Time-dependent terms**: String format (e.g., `'cos(w*t)'`) is fastest
+4. **Store only needed data**: Use `e_ops` instead of storing all states
+5. **Adjust tolerances**: Balance accuracy with computation time via `Options`
+6. **Parallel trajectories**: `mcsolve` automatically uses multiple CPUs
+7. **Check convergence**: Vary `ntraj`, Hilbert space size, and tolerances
+
+## Troubleshooting
+
+**Memory issues**: Reduce Hilbert space dimension, use `store_final_state` option, or consider Krylov methods
+
+**Slow simulations**: Use string-based time-dependence, increase tolerances slightly, or try `method='bdf'` for stiff problems
+
+**Numerical instabilities**: Decrease time steps (`nsteps` option), increase tolerances, or check Hamiltonian/operators are properly defined
+
+**Import errors**: Ensure QuTiP is installed correctly; quantum gates require `qutip-qip` package
+
+## References
+
+This skill includes detailed reference documentation:
+
+- **`references/core_concepts.md`**: Quantum objects, states, operators, tensor products, composite systems
+- **`references/time_evolution.md`**: All solvers (sesolve, mesolve, mcsolve, brmesolve, etc.), time-dependent Hamiltonians, solver options
+- **`references/visualization.md`**: Bloch sphere, Wigner functions, Q-functions, Fock distributions, matrix plots
+- **`references/analysis.md`**: Expectation values, entropy, fidelity, entanglement measures, correlation functions, steady states
+- **`references/advanced.md`**: Floquet theory, HEOM, permutational invariance, stochastic methods, superoperators, performance tips
+
+## External Resources
+
+- Documentation: https://qutip.readthedocs.io/
+- Tutorials: https://qutip.org/qutip-tutorials/
+- API Reference: https://qutip.readthedocs.io/en/stable/apidoc/apidoc.html
+- GitHub: https://github.com/qutip/qutip
+