@pikaa-ai/pikaa 0.3.22 → 0.3.24

package/skills/qiskit/SKILL.md

@@ -1,259 +0,0 @@
----
-name: qiskit
-description: Build, simulate, transpile, and execute quantum circuits with Qiskit and IBM Quantum Runtime. Use for Qiskit 2.x circuits and operators, V2 Sampler or Estimator primitives, target-aware transpilation, local or noisy simulation, IBM QPU execution, Runtime sessions or batches, error mitigation, and Qiskit ecosystem packages.
-license: Apache-2.0
-compatibility: Python 3.10+ on a supported 64-bit platform. Local SDK workflows need qiskit; noisy simulation needs qiskit-aer; IBM QPU access needs qiskit-ibm-runtime, network access, an IBM Quantum Platform account, and an API key.
-metadata:
-  version: "2.0"
-  skill-author: K-Dense Inc.
----
-
-# Qiskit
-
-Use current Qiskit 2.x APIs to build circuits, prepare hardware-compatible instruction set architecture (ISA) circuits, and execute them through V2 primitives.
-
-This skill was verified on **2026-07-23** against the PyPI releases `qiskit==2.5.0`, `qiskit-ibm-runtime==0.48.0`, and `qiskit-aer==0.17.2`. Check [references/sources.md](references/sources.md) before changing pins or documenting newly released behavior.
-
-## Choose the Right Path
-
-| Goal | Recommended interface |
-|---|---|
-| Exact local sampling | `qiskit.primitives.StatevectorSampler` |
-| Exact local expectation values | `qiskit.primitives.StatevectorEstimator` |
-| High-performance or noisy simulation | Qiskit Aer |
-| IBM QPU sampling | `qiskit_ibm_runtime.SamplerV2` |
-| IBM QPU expectation values and mitigation | `qiskit_ibm_runtime.EstimatorV2` |
-| Backend without native primitives | `BackendSamplerV2` or `BackendEstimatorV2` |
-| Open-system or master-equation dynamics | Prefer QuTiP |
-| Differentiable quantum machine learning | Prefer PennyLane unless Qiskit integration is required |
-
-## Installation
-
-Create an isolated environment and install only the components needed:
-
-```bash
-uv venv --python 3.13
-source .venv/bin/activate
-
-# Core SDK plus plotting support
-uv pip install "qiskit[visualization]==2.5.0"
-
-# Add only when needed
-uv pip install "qiskit-ibm-runtime==0.48.0"
-uv pip install "qiskit-aer==0.17.2"
-```
-
-Do not install `qiskit-terra`; it was superseded by the `qiskit` distribution. Qiskit Runtime, Aer, Nature, Machine Learning, Optimization, and Algorithms are separate distributions.
-
-For IBM account setup, CI-safe credential handling, optional packages, and environment repair, read [references/setup.md](references/setup.md).
-
-## Core Workflow
-
-Follow this sequence for every hardware-oriented workload:
-
-1. **Map** the problem to a circuit and, for Estimator, one or more observables.
-2. **Optimize** the parameterized circuit once for the selected backend.
-3. **Apply the layout** to every observable.
-4. **Execute** ISA circuits through a V2 primitive using Primitive Unified Blocs (PUBs).
-5. **Analyze** register-aware results, metadata, uncertainty, and resource usage.
-
-Do not bind and retranspile a parameterized circuit inside every optimizer iteration. Transpile the parameterized circuit once, then pass parameter arrays in PUBs.
-
-## Quick Local Sampling
-
-```python
-from qiskit import QuantumCircuit
-from qiskit.primitives import StatevectorSampler
-
-circuit = QuantumCircuit(2)
-circuit.h(0)
-circuit.cx(0, 1)
-circuit.measure_all()  # creates the classical register named "meas"
-
-sampler = StatevectorSampler(seed=7)
-pub_result = sampler.run([circuit], shots=1024).result()[0]
-counts = pub_result.data.meas.get_counts()
-print(counts)
-```
-
-Sampler V2 preserves shots and classical-register structure. Access the register by its actual name; `measure_all()` uses `meas`.
-
-## Quick Local Estimation
-
-```python
-import numpy as np
-from qiskit import QuantumCircuit
-from qiskit.circuit import Parameter
-from qiskit.primitives import StatevectorEstimator
-from qiskit.quantum_info import SparsePauliOp
-
-theta = Parameter("theta")
-circuit = QuantumCircuit(2)
-circuit.ry(theta, 0)
-circuit.cx(0, 1)
-
-observable = SparsePauliOp.from_list([("ZZ", 1.0), ("XX", 0.5)])
-parameter_values = [[0.0], [np.pi / 4], [np.pi / 2]]
-
-estimator = StatevectorEstimator(seed=7)
-pub = (circuit, observable, parameter_values)
-pub_result = estimator.run([pub]).result()[0]
-print(pub_result.data.evs)
-```
-
-Estimator circuits should not contain final measurements. PUB arrays broadcast; verify circuit parameter order before constructing large sweeps.
-
-## IBM QPU Sampling
-
-This example assumes credentials were saved securely as described in [references/setup.md](references/setup.md). It never embeds or prints an API key.
-
-```python
-from qiskit import QuantumCircuit
-from qiskit.transpiler import generate_preset_pass_manager
-from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
-
-service = QiskitRuntimeService()
-backend = service.least_busy(
-    operational=True,
-    simulator=False,
-    min_num_qubits=2,
-)
-
-circuit = QuantumCircuit(2)
-circuit.h(0)
-circuit.cx(0, 1)
-circuit.measure_all()
-
-pass_manager = generate_preset_pass_manager(
-    backend=backend,
-    optimization_level=1,
-    seed_transpiler=7,
-)
-isa_circuit = pass_manager.run(circuit)
-
-sampler = Sampler(mode=backend)
-job = sampler.run([isa_circuit], shots=1024)
-print("job_id:", job.job_id())
-counts = job.result()[0].data.meas.get_counts()
-```
-
-Save the job ID before waiting for results so the job can be retrieved later.
-
-## IBM QPU Estimation
-
-Runtime Estimator requires both an ISA circuit and observables mapped through the transpiler layout:
-
-```python
-from qiskit import QuantumCircuit
-from qiskit.quantum_info import SparsePauliOp
-from qiskit.transpiler import generate_preset_pass_manager
-from qiskit_ibm_runtime import EstimatorV2 as Estimator
-
-circuit = QuantumCircuit(2)
-circuit.h(0)
-circuit.cx(0, 1)
-observable = SparsePauliOp.from_list([("ZZ", 1.0)])
-
-pass_manager = generate_preset_pass_manager(
-    backend=backend,
-    optimization_level=1,
-    seed_transpiler=7,
-)
-isa_circuit = pass_manager.run(circuit)
-isa_observable = observable.apply_layout(isa_circuit.layout)
-
-estimator = Estimator(
-    mode=backend,
-    options={"resilience_level": 1},
-)
-pub_result = estimator.run(
-    [(isa_circuit, isa_observable)],
-    precision=0.02,
-).result()[0]
-print(pub_result.data.evs, pub_result.data.stds)
-```
-
-Error mitigation is not guaranteed to improve every workload and increases cost. Record the complete options and result metadata.
-
-## Non-Negotiable Qiskit 2.x Rules
-
-- Use V2 primitive interfaces and PUB inputs. Do not write new V1 `Sampler`, `Estimator`, or `QuantumInstance` code.
-- Runtime primitives accept ISA circuits; they do not perform layout, routing, and basis translation for you.
-- Apply the transpiler layout to Estimator observables with `observable.apply_layout(isa_circuit.layout)`.
-- Use `mode=backend`, `mode=session`, or `mode=batch` for Runtime primitives.
-- Use `EstimatorV2` for resilience levels and expectation-value mitigation. Sampler has different noise-management options and no Estimator-style resilience levels.
-- Treat `BackendV2.target`, `backend.operation_names`, `backend.coupling_map`, and direct backend attributes as the source of hardware constraints. Do not use `backend.configuration()` or `BackendProperties`.
-- Read Sampler output by classical register name. Bitstrings are displayed most-significant bit first; Qiskit qubit 0 is conventionally the least-significant bit.
-- Use a fixed `seed_transpiler` when comparing compilation settings. A simulator seed does not make QPU results deterministic.
-- `qiskit.pulse` was removed in Qiskit 2.0. Use supported fractional gates for IBM hardware or Qiskit Dynamics for pulse-model research.
-- QPY is the Qiskit-native circuit serialization format. Do not use Python pickle for untrusted circuit artifacts.
-
-See [references/migration.md](references/migration.md) for a detailed old-to-current API map.
-
-## Execution Modes
-
-Choose based on workload shape and account plan:
-
-- **Job mode**: one-off work; instantiate a primitive with `mode=backend`.
-- **Batch mode**: independent jobs submitted together; available on the Open Plan.
-- **Session mode**: iterative jobs that benefit from prioritized follow-on execution; unavailable on the Open Plan.
-
-```python
-from qiskit_ibm_runtime import Batch, SamplerV2 as Sampler
-
-with Batch(backend=backend, max_time="10m") as batch:
-    sampler = Sampler(mode=batch)
-    jobs = [sampler.run([circuit], shots=1024) for circuit in isa_circuits]
-
-results = [job.result() for job in jobs]
-```
-
-Close sessions and batches after submission. Exiting their context stops new submissions but allows accepted jobs to finish, subject to service limits.
-
-## Reference Map
-
-Read only the files needed for the current task:
-
-| Topic | Reference |
-|---|---|
-| Versions, installation, authentication, CI | [references/setup.md](references/setup.md) |
-| Circuits, parameters, control flow, QPY | [references/circuits.md](references/circuits.md) |
-| V2 PUBs, broadcasting, local and Runtime results | [references/primitives.md](references/primitives.md) |
-| Targets, ISA circuits, layouts, pass managers | [references/transpilation.md](references/transpilation.md) |
-| IBM backends, modes, jobs, Aer, mitigation | [references/backends.md](references/backends.md) |
-| End-to-end map/optimize/execute/analyze patterns | [references/patterns.md](references/patterns.md) |
-| Algorithms, addons, Nature, ML, Optimization | [references/algorithms.md](references/algorithms.md) |
-| Circuit, result, state, and backend plots | [references/visualization.md](references/visualization.md) |
-| Qiskit 0.x/1.x and Runtime migration | [references/migration.md](references/migration.md) |
-| Testing, reproducibility, and troubleshooting | [references/testing.md](references/testing.md) |
-| Upstream docs, release notes, and version baseline | [references/sources.md](references/sources.md) |
-
-## Bundled Scripts
-
-Run from the skill directory:
-
-```bash
-# Installed-package and legacy-environment checks; no network or credential reads
-python scripts/check_environment.py
-
-# Runnable V2 local Sampler and Estimator example
-python scripts/run_local_primitives.py --shots 1024 --seed 7
-
-# Read-only IBM backend capability inspection; uses saved credentials
-python scripts/inspect_runtime.py --min-qubits 5
-```
-
-The Runtime inspection script selects or inspects a backend but never submits a quantum job.
-
-## Final Checklist
-
-Before returning Qiskit code:
-
-1. Confirm package versions and Python compatibility.
-2. Run locally with statevector primitives or Aer.
-3. Verify parameter order, observable qubit count, and classical-register names.
-4. Transpile against the exact `BackendV2` target and inspect depth and two-qubit operations.
-5. Apply the final layout to every observable.
-6. Estimate QPU cost and choose job, batch, or session mode.
-7. Save job IDs, package versions, seeds, backend name, primitive options, and result metadata.
-8. Never expose API keys in source, logs, notebooks, or version control.

package/skills/qutip/SKILL.md

@@ -1,317 +0,0 @@
----
-name: qutip
-description: Simulate and audit closed and open quantum-system models with QuTiP 5, including deterministic, trajectory, steady-state, spectral, and phase-space workflows. Use for local quantum-dynamics work where physical assumptions, dimensions, and numerical convergence must be explicit.
-license: MIT
-compatibility: Requires Python 3.11+, uv, and qutip==5.3.0 for executable simulations. Bundled planners and all script help run with the Python standard library; plotting requires the pinned graphics extra. No network service or credentials are used.
-metadata:
-  version: "1.1"
-  skill-author: K-Dense Inc.
-  last-reviewed: "2026-07-23"
----
-
-# QuTiP 5
-
-## Scope
-
-Use QuTiP for finite-dimensional quantum mechanics, quantum optics, Lindblad
-dynamics, trajectories, weak-coupling Bloch-Redfield models, and specialized
-Floquet, HEOM, and permutational-invariance methods. It is not a hardware
-execution SDK. Circuit and control functionality moved to separate QuTiP family
-packages.
-
-This skill targets **QuTiP 5.3.0**, released 2026-05-22. QuTiP 5.3 requires
-Python 3.11 or newer. Its required distributions are NumPy (`>=1.23.2`), SciPy
-(`>=1.9.2`, excluding `1.16.0` and `1.17.0`), and `packaging`.
-
-## Reproducible uv snapshot
-
-Create a dedicated environment and pin every direct distribution:
-
-```bash
-uv venv --python 3.11
-uv pip install "qutip==5.3.0"
-```
-
-For plots:
-
-```bash
-uv pip install "qutip[graphics]==5.3.0"
-```
-
-Optional QuTiP family packages are independently versioned:
-
-```bash
-uv pip install "qutip-qip==0.4.2"
-uv pip install "qutip-qtrl==0.2.0"
-uv pip install "qutip-jax==0.1.1"
-```
-
-- `qutip-qip` 0.4.2 (2026-06-23) is the production/stable circuit, gate, and
-  noisy-device simulation package. Import from `qutip_qip`, not `qutip.qip`.
-- `qutip-qtrl` 0.2.0 (2026-06-23) provides GRAPE and CRAB **quantum optimal
-  control**. It is not a trajectory viewer. Import from `qutip_qtrl`, not
-  `qutip.control`; PyPI still classifies it pre-alpha.
-- `qutip-jax` 0.1.1 (2025-05-29) is the official JAX data backend for GPU and
-  automatic-differentiation experiments. It is explicitly pre-alpha.
-- `qutip-cupy` is an official QuTiP-organization repository, but it has no PyPI
-  release and its own README says it is not officially released. Do not put an
-  unreleased Git install into a reproducible workflow.
-
-Use a project lockfile or a hash-generating `uv pip compile` workflow when
-transitive dependency identity must also be frozen.
-
-## Non-negotiable model contract
-
-Before solving, record:
-
-1. **Units and convention.** QuTiP equations normally set \(\hbar=1\).
-   Hamiltonian entries are angular frequencies and rates have reciprocal-time
-   units. Convert cyclic frequency with \(2\pi f\); never mix Hz and rad/s.
-2. **Subsystem order.** `tensor(A, B, C)` fixes subsystem indices `0, 1, 2`.
-   Preserve that order in every state, operator, collapse channel, and partial
-   trace. `obj.ptrace([0, 2])` keeps those subsystems; it does not trace them.
-3. **State validity.** Check ket norm or density-matrix Hermiticity, unit trace,
-   and eigenvalues above a stated negative tolerance. Tiny negative values may
-   be numerical; material negativity invalidates a claimed state.
-4. **Generator meaning.** A Lindblad channel with rate `gamma` is represented
-   by `sqrt(gamma) * A`, not `gamma * A`. Define what each rate measures. For
-   example, `sqrt(gamma_phi / 2) * sigmaz()` gives coherence decay
-   `exp(-gamma_phi * t)`.
-5. **Approximations.** State rotating-wave, Born-Markov, secular, weak-coupling,
-   bath-equilibrium, truncation, symmetry, and initial-factorization assumptions
-   wherever used.
-6. **Numerics.** Justify Hilbert truncation, output grid, integration method,
-   tolerances, trajectory count, and random seeds. Report `result.stats`.
-7. **Convergence.** Sweep every artificial cutoff: Fock dimension, time/frequency
-   window and spacing, ODE tolerances, trajectories, Floquet harmonics, HEOM
-   depth and bath exponents, or PIQS representation as applicable.
-
-## Qobj, dimensions, and tensor order
-
-Prefer explicit imports and inspect both shape and structured dimensions:
-
-```python
-from qutip import basis, qeye, sigmaz, tensor
-
-psi = tensor(basis(2, 0), basis(3, 1))
-z_on_first = tensor(sigmaz(), qeye(3))
-
-assert psi.shape == (6, 1)
-assert psi.dims == [[2, 3], [1]]
-assert z_on_first.dims == [[2, 3], [2, 3]]
-rho_first = psi.proj().ptrace(0)  # keep subsystem 0
-```
-
-Matrix shape alone is insufficient: two objects can both be 6-by-6 but encode
-different tensor factorizations. Read `references/core_concepts.md` before
-building composite, superoperator, or channel models.
-
-## Choose the solver by physics
-
-| Model | Current API | Required justification |
-|---|---|---|
-| Closed, pure, unitary | `sesolve` | Hermitian Hamiltonian; no dissipation |
-| Lindblad/open or mixed | `mesolve` | Markovian completely positive model and channel rates |
-| Quantum jumps | `mcsolve` | Unravelling, trajectory convergence, seeds |
-| Microscopic weak bath | `brmesolve` | Born-Markov/weak coupling, spectra, secular choice |
-| Diffusive measurement | `ssesolve`, `smesolve` | monitored versus unmonitored channels |
-| Periodic drive | `FloquetBasis`, `fsesolve`, `fmmesolve` | verified period and Floquet convergence |
-| Structured non-Markovian bath | `qutip.solver.heom` | bath expansion and hierarchy convergence |
-| Symmetric spin ensemble | `qutip.piqs` | permutation symmetry and basis choice |
-
-Do not select a more specialized solver merely because it exists.
-
-## Deterministic open-system example
-
-QuTiP 5.3 uses ordinary option dictionaries. Solver controls, `e_ops`, and
-`args` are keyword-only; the old mutable options object is gone.
-
-```python
-import numpy as np
-from qutip import basis, mesolve, sigmam, sigmaz
-
-omega = 2.0
-gamma = 0.15
-tlist = np.linspace(0.0, 20.0, 401)
-excited = basis(2, 0)
-
-result = mesolve(
-    0.5 * omega * sigmaz(),
-    excited,
-    tlist,
-    c_ops=[np.sqrt(gamma) * sigmam()],
-    e_ops={"sigma_z": sigmaz(), "excited": excited.proj()},
-    options={
-        "method": "adams",
-        "atol": 1e-10,
-        "rtol": 1e-8,
-        "store_final_state": True,
-        "progress_bar": "",
-    },
-)
-
-population = np.asarray(result.e_data["excited"])
-assert np.max(np.abs(population - np.exp(-gamma * tlist))) < 2e-6
-assert isinstance(result.stats, dict)
-```
-
-If the problem is stiff, compare `bdf` or `lsoda`; do not change an integrator
-without rerunning tolerance and invariant checks. QuTiP 5.3 also supports
-`options={"matrix_form": True}` in `mesolve`; benchmark and validate it before
-using it as a default.
-
-## Time-dependent systems
-
-Prefer trusted Pythonic callables or numeric coefficient arrays. Do not create
-coefficient source strings from user input.
-
-```python
-import numpy as np
-from qutip import QobjEvo, sigmax, sigmaz
-
-def envelope(t, amplitude, center, width):
-    return amplitude * np.exp(-0.5 * ((t - center) / width) ** 2)
-
-H = QobjEvo(
-    [0.5 * sigmaz(), [sigmax(), envelope]],
-    args={"amplitude": 0.2, "center": 5.0, "width": 1.0},
-)
-instantaneous_H = H(5.0)
-H.arguments(amplitude=0.1)
-```
-
-The older `f(t, args)` coefficient signature is deprecated in 5.3 and is
-scheduled for removal in 5.5. See `references/time_evolution.md`.
-
-## Trajectories and stochastic solvers
-
-```python
-import numpy as np
-from qutip import basis, mcsolve, sigmam, sigmaz
-
-tlist = np.linspace(0.0, 10.0, 201)
-result = mcsolve(
-    0.5 * sigmaz(),
-    basis(2, 0),
-    tlist,
-    [np.sqrt(0.2) * sigmam()],
-    e_ops=[basis(2, 0).proj()],
-    ntraj=400,
-    seeds=20260723,
-    options={"keep_runs_results": False, "progress_bar": ""},
-)
-```
-
-Report `ntraj`, `result.seeds`, uncertainty or repeated-seed sensitivity, and
-whether individual runs were retained. Reuse `seeds=previous_result.seeds` only
-when paired trajectories are intentional. `ssesolve` and `smesolve` use the
-boolean `heterodyne` argument, not legacy integer noise codes.
-
-## Steady states, spectra, and phase space
-
-```python
-import numpy as np
-from qutip import QFunc, liouvillian, operator_to_vector, qfunc, steadystate
-
-rho_ss = steadystate(H, c_ops, method="direct")
-residual = (liouvillian(H, c_ops) * operator_to_vector(rho_ss)).norm()
-assert residual < 1e-9
-
-xvec = np.linspace(-5.0, 5.0, 151)
-Q_once = qfunc(rho_ss, xvec, xvec)
-q_many = QFunc(xvec, xvec)
-Q_again = q_many(rho_ss)
-assert Q_once.shape == (len(xvec), len(xvec))
-```
-
-For `wigner`, `qfunc`, and `QFunc`, array element `[j, k]` corresponds to
-`yvec[j]`, `xvec[k]`. In QuTiP 5.3, `QFunc` is initialized with fixed
-coordinates and called with a state; it has no `.eval` method. This skill never
-uses Python dynamic-code execution. Prefer `plot_wigner`, `Result.plot_expect`,
-or explicit Matplotlib axes as documented in `references/visualization.md`.
-
-Direct `spectrum` is a stationary steady-state spectrum. An FFT of a finite
-correlation requires explicit checks for tail decay, timestep aliasing,
-frequency resolution, window sensitivity, and transform convention. See
-`references/analysis.md`.
-
-## Advanced boundaries
-
-- Import HEOM from `qutip.solver.heom`; the legacy QuTiP 4 nonmarkov HEOM
-  namespace is stale.
-- Use `FloquetBasis` for modes and quasi-energies. Verify
-  `H(t + T) == H(t)` numerically and sweep basis/truncation choices.
-- Access PIQS with `from qutip import piqs`. `Dicke.pisolve` is only the
-  optimized diagonal-state/diagonal-Hamiltonian route; general Dicke-basis
-  dynamics use the Liouvillian with `mesolve`.
-- `brmesolve` can violate positivity, especially without secularization. Check
-  density-matrix eigenvalues over time.
-- QIP and optimal control are extension-package concerns. Never present local
-  simulation as quantum-hardware execution.
-
-See `references/advanced.md` for HEOM, Floquet, PIQS, stochastic, and extension
-boundaries.
-
-## Safe local CLIs
-
-All bundled tools are local-only, emit strict JSON, reject non-finite JSON and
-unknown keys, and never load pickle files or executable model code. Simulation
-imports are lazy, so every `--help` works without QuTiP installed.
-
-| Script | Purpose |
-|---|---|
-| `scripts/qobj_model_validator.py` | Validate bounded Qobj model JSON, dimensions, states, rates, and role compatibility |
-| `scripts/two_level_simulation.py` | Run a bounded two-level Lindblad or jump simulation |
-| `scripts/solver_config_planner.py` | Select a current solver and option/checklist plan |
-| `scripts/convergence_sweep.py` | Sweep tolerances/grid size or trajectory count on a synthetic model |
-| `scripts/result_audit.py` | Audit JSON output without deserializing Python objects |
-| `scripts/steady_state_spectrum_planner.py` | Plan bounded steady-state and direct/FFT spectral checks |
-
-Example:
-
-```bash
-python skills/qutip/scripts/two_level_simulation.py --help
-python skills/qutip/scripts/two_level_simulation.py \
-  --decay-rate 0.2 --t-final 10 --time-points 201 \
-  --output two-level.json
-python skills/qutip/scripts/result_audit.py two-level.json
-```
-
-## Completion checklist
-
-- Record units, \(\hbar\), tensor order, initial state, channels, and model
-  assumptions.
-- Validate Hermiticity, norm/trace, positivity, dimensions, and generator units.
-- Pin QuTiP and direct extensions; record platform, Python, NumPy, and SciPy.
-- Inspect result options and stats; do not assume states were stored.
-- Perform cutoff, grid, tolerance/integrator, and stochastic convergence sweeps.
-- Save portable numeric/configuration summaries as JSON or text. Do not load
-  untrusted QuTiP object/result files because object serialization can execute
-  code.
-
-## References
-
-- `references/core_concepts.md` — Qobj, dimensions, tensor products, states,
-  channels, and unit conventions
-- `references/time_evolution.md` — current solver signatures, options, results,
-  QobjEvo, trajectories, and numerical controls
-- `references/analysis.md` — physical-state audits, steady states,
-  correlations, spectra, and convergence
-- `references/visualization.md` — Wigner, Q functions, `QFunc`, Bloch, result,
-  and matrix plots
-- `references/advanced.md` — Bloch-Redfield, stochastic, Floquet, HEOM, PIQS,
-  and QuTiP family package boundaries
-
-## Dated official sources
-
-Verified **2026-07-23**:
-
-- [QuTiP 5.3.0 PyPI metadata](https://pypi.org/project/qutip/)
-- [QuTiP 5.3.0 release](https://github.com/qutip/qutip/releases/tag/v5.3.0)
-- [QuTiP 5.3 changelog](https://qutip.readthedocs.io/en/stable/changelog.html)
-- [QuTiP 5.3 API](https://qutip.readthedocs.io/en/stable/apidoc/apidoc.html)
-- [QuTiP version-5 tutorials](https://github.com/qutip/qutip-tutorials/tree/main/tutorials-v5)
-- [qutip-qip PyPI](https://pypi.org/project/qutip-qip/)
-- [qutip-qtrl PyPI](https://pypi.org/project/qutip-qtrl/)
-- [qutip-jax PyPI](https://pypi.org/project/qutip-jax/)
-- [official unreleased qutip-cupy repository](https://github.com/qutip/qutip-cupy)

package/skills/rdkit/SKILL.md

@@ -1,94 +0,0 @@
----
-name: rdkit
-description: Cheminformatics toolkit for fine-grained molecular control. SMILES/SDF parsing, descriptors (MW, LogP, TPSA), fingerprints, substructure search, 2D/3D generation, similarity, reactions. For standard workflows with simpler interface, use datamol (wrapper around RDKit). Use rdkit for advanced control, custom sanitization, specialized algorithms.
-license: BSD-3-Clause license
-allowed-tools: Read Write Edit Bash
-compatibility: Examples target RDKit 2026.03.x. Use conda-forge for the broadest binary support or PyPI package `rdkit` for supported platform wheels; `rdkit-pypi` is the legacy PyPI name.
-metadata:
-  version: "1.2"
-  skill-author: K-Dense Inc.
----
-
-# RDKit Cheminformatics Toolkit
-
-## Overview
-
-RDKit is a comprehensive cheminformatics library providing Python APIs for molecular analysis and manipulation. This skill provides guidance for reading/writing molecular structures, calculating descriptors, fingerprinting, substructure searching, chemical reactions, 2D/3D coordinate generation, and molecular visualization. Use this skill for drug discovery, computational chemistry, and cheminformatics research tasks.
-
-**Current baseline (checked 2026-06-07):** RDKit **2026.03.3** is the latest GitHub/PyPI release (`rdkit` 2026.3.3 on PyPI). Official installation docs continue to recommend conda-forge for most users, while cross-platform PyPI wheels are published under the `rdkit` package name. `rdkit-pypi` is the old PyPI package name and should only appear when maintaining legacy environments.
-
-## Installation and Setup
-
-Use `uv` when installing into an existing Python environment:
-
-```bash
-uv pip install rdkit
-```
-
-For reproducible chemistry environments, especially when mixing compiled scientific packages, conda-forge remains the upstream recommendation:
-
-```bash
-conda create -c conda-forge -n my-rdkit-env rdkit
-conda activate my-rdkit-env
-```
-
-Avoid installing both conda `rdkit` and PyPI `rdkit`/`rdkit-pypi` into the same environment unless you are deliberately debugging packaging behavior. Mixed installs can make it unclear which binary extension is being imported.
-
-## Core Capabilities
-
-Twelve capability areas, each with worked code, are documented in
-[references/core_capabilities.md](references/core_capabilities.md):
-
-| # | Area | Covers |
-| --- | --- | --- |
-| 1 | Molecular I/O and creation | SMILES, MOL files and blocks, InChI, SDF and SMILES suppliers, multithreaded reading, writers |
-| 2 | Sanitization and validation | disabling automatic sanitization, manual and partial sanitization, detecting problems first |
-| 3 | Analysis and properties | atom and bond iteration, ring information and SSSR, chirality and stereochemistry, fragments |
-| 4 | Descriptors | MW, LogP, TPSA, H-bond donors/acceptors, rotatable bonds, aromatic rings, bulk calculation, drug-likeness |
-| 5 | Fingerprints and similarity | topological, Morgan/ECFP via `rdFingerprintGenerator`, MACCS, atom pair, torsion, Avalon; Tanimoto and other metrics; Butina clustering |
-| 6 | Substructure searching | SMARTS queries, match retrieval, and a library of common patterns |
-| 7 | Chemical reactions | reaction SMARTS, applying reactions, reaction fingerprints |
-| 8 | 2D and 3D coordinates | depiction, template alignment, ETKDG embedding, force-field optimization, RMSD, constrained embedding |
-| 9 | Visualization | single and grid images, substructure highlighting, custom drawer options, Jupyter integration, fingerprint bit environments |
-| 10 | Molecular modification | explicit hydrogens, Kekulization, aromaticity, substructure replacement, charge neutralization |
-| 11 | Hashes and standardization | Murcko scaffold and canonical hashes, regioisomer hashes, randomized SMILES for augmentation |
-| 12 | Pharmacophore and 3D features | feature factories and feature extraction |
-
-Worked workflows and the performance, thread-safety, and version-sensitivity notes are in
-[references/workflows_and_best_practices.md](references/workflows_and_best_practices.md).
-
-Prefer portable exchange formats (SMILES, SDF) for shared data; for local caches RDKit's
-binary molecule representation avoids generic pickle.
-
-## Common Pitfalls
-
-1. **Forgetting to check for None:** Always validate molecules after parsing
-2. **Sanitization failures:** Use `DetectChemistryProblems()` to debug
-3. **Missing hydrogens:** Use `AddHs()` when calculating properties that depend on hydrogen
-4. **2D vs 3D:** Generate appropriate coordinates before visualization or 3D analysis
-5. **SMARTS matching rules:** Remember that unspecified properties match anything
-6. **Thread safety with MolSuppliers:** Don't share supplier objects across threads
-
-## Resources
-
-### references/
-
-This skill includes detailed API reference documentation:
-
-- `api_reference.md` - Comprehensive listing of RDKit modules, functions, and classes organized by functionality
-- `descriptors_reference.md` - Complete list of available molecular descriptors with descriptions
-- `smarts_patterns.md` - Common SMARTS patterns for functional groups and structural features
-
-Load these references when needing specific API details, parameter information, or pattern examples.
-
-Only the files listed in `references/` and `scripts/` are bundled local resources. Names such as `rdkit`, `datamol`, `scipy`, and `sklearn` refer to installable Python packages, not local files in this skill.
-
-### scripts/
-
-Example scripts for common RDKit workflows:
-
-- `molecular_properties.py` - Calculate comprehensive molecular properties and descriptors
-- `similarity_search.py` - Perform fingerprint-based similarity screening
-- `substructure_filter.py` - Filter molecules by substructure patterns
-
-These scripts can be executed directly or used as templates for custom workflows.