菜单
Hamiltonian mechanics — symplectic integrators (leapfrog, Yoshida), Hamilton's equations, Poisson brackets, canonical transformations, action-angle variables, and KAM theory analysis. Use for energy-conserving long-time integration of conservative systems.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/synthetic-sciences/openscience --skill hamiltonian-mechanics命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Diffusion-based molecular docking. Predict protein-ligand binding poses from PDB/SMILES, confidence scores, virtual screening, for structure-based drug design. Not for affinity prediction.
Fast inference and fine-tuning platform with serverless and on-demand GPU deployments. OpenAI-compatible API for chat completions, embeddings, function calling, vision, and structured output. Supports SFT, DPO, and RL fine-tuning. SOC2 + HIPAA compliant.
Serverless inference, fine-tuning, embeddings, image generation, and batch processing on 200+ open-source models via an OpenAI-compatible API. Use when you need fast, cost-effective access to open-source LLMs without managing infrastructure.
基于 SOC 职业分类
正在显示 SKILL.md
| name | hamiltonian-mechanics |
| description | Hamiltonian mechanics — symplectic integrators (leapfrog, Yoshida), Hamilton's equations, Poisson brackets, canonical transformations, action-angle variables, and KAM theory analysis. Use for energy-conserving long-time integration of conservative systems. |
| category | physics |
| version | 1.0.0 |
| author | Synthetic Sciences |
| license | MIT |
| tags | ["Hamiltonian","Symplectic","Leapfrog","Classical Mechanics","Energy Conservation","Physics"] |
| dependencies | ["scipy>=1.11.0","numpy>=1.24.0","matplotlib>=3.7.0"] |
Solve Hamilton's equations using symplectic integrators that exactly conserve the symplectic structure and approximately conserve energy for exponentially long times. Essential for N-body problems, celestial mechanics, molecular dynamics, and any conservative system needing long-time accuracy.
ode-solver with RK45/Radau)import numpy as np
import matplotlib.pyplot as plt
def leapfrog(dH_dq, dH_dp, q0, p0, dt, n_steps):
"""
Leapfrog (Stormer-Verlet) symplectic integrator.
H(q, p) is the Hamiltonian.
dH_dq = ∂H/∂q (returns force: dp/dt = -∂H/∂q)
dH_dp = ∂H/∂p (returns velocity: dq/dt = ∂H/∂p)
"""
n = len(q0)
q = np.zeros((n_steps + 1, n))
p = np.zeros((n_steps + 1, n))
q[0] = q0
p[0] = p0
for i in range(n_steps):
# Half-step momentum
p_half = p[i] - 0.5 * dt * dH_dq(q[i], p[i])
# Full-step position
q[i+1] = q[i] + dt * dH_dp(q[i], p_half)
# Half-step momentum
p[i+1] = p_half - 0.5 * dt * dH_dq(q[i+1], p_half)
return q, p
():
r = np.linalg.norm(q)
q / r**
():
p
q0 = np.array([, ])
p0 = np.array([, ])
dt =
n_steps =
q, p = leapfrog(dH_dq, dH_dp, q0, p0, dt, n_steps)
H = * np.(p**, axis=) - / np.linalg.norm(q, axis=)
()
fig, axes = plt.subplots(, , figsize=(, ))
axes[].plot(q[:, ], q[:, ], , linewidth=)
axes[].plot(, , , markersize=, label=)
axes[].set_xlabel()
axes[].set_ylabel()
axes[].set_title()
axes[].set_aspect()
axes[].legend()
axes[].grid(, alpha=)
t = np.arange(n_steps + ) * dt
axes[].plot(t, (H - H[])/(H[]), , linewidth=)
axes[].set_xlabel()
axes[].set_ylabel()
axes[].set_title()
axes[].grid(, alpha=)
plt.tight_layout()
plt.savefig(, dpi=, bbox_inches=)
def yoshida4(dH_dq, dH_dp, q0, p0, dt, n_steps):
"""
4th-order symplectic integrator (Yoshida 1990).
Composes three leapfrog steps with specific coefficients.
"""
# Yoshida coefficients
w1 = 1 / (2 - 2**(1/3))
w0 = -2**(1/3) * w1
c = [w1/2, (w0+w1)/2, (w0+w1)/2, w1/2]
d = [w1, w0, w1, 0] # last is unused
n = len(q0)
q = np.zeros((n_steps + 1, n))
p = np.zeros((n_steps + 1, n))
q[0] = q0
p[0] = p0
for i in range(n_steps):
qi, pi = q[i].copy(), p[i].copy()
for k in range(4):
qi = qi + c[k] * dt * dH_dp(qi, pi)
if k < 3:
pi = pi - d[k] * dt * dH_dq(qi, pi)
q[i+1] = qi
p[i+1] = pi
return q, p
# Compare leapfrog vs Yoshida on same problem
q_y, p_y = yoshida4(dH_dq, dH_dp, q0, p0, dt, n_steps)
H_y = 0.5 * np.sum(p_y**2, axis=1) - 1 / np.linalg.norm(q_y, axis=1)
print(f"Yoshida4 energy: max |ΔH/H₀| = {np.max(np.abs((H_y - H_y[0])/H_y[0])):.2e}")
def nbody_leapfrog(masses, q0, p0, dt, n_steps, G=1.0):
"""
N-body gravitational simulation with leapfrog.
q0: (N, 3) positions
p0: (N, 3) momenta
"""
N = len(masses)
def acceleration(q):
a = np.zeros_like(q)
for i in range(N):
for j in range(i+1, N):
rij = q[j] - q[i]
r = np.linalg.norm(rij)
force = G * masses[i] * masses[j] / r**3 * rij
a[i] += force / masses[i]
a[j] -= force / masses[j]
return a
q = q0.copy()
p = p0.copy()
v = p / masses[:, None]
trajectory = [q.copy()]
a = acceleration(q)
for step in range(n_steps):
v += 0.5 * dt * a
q += dt * v
a = acceleration(q)
v += 0.5 * dt * a
if step % 100 == 0:
trajectory.append(q.copy())
return np.array(trajectory)
# 3-body problem (figure-8 solution)
masses = np.array([1.0, 1.0, 1.0])
# Chenciner-Montgomery initial conditions
q0 = np.array([
[-0.97000436, 0.24308753, 0],
[0.97000436, -0.24308753, 0],
[0, 0, 0]
])
v0_base = np.array([0.4662036850, 0.4323657300, 0])
p0 = np.array([-v0_base/2, -v0_base/2, v0_base])
traj = nbody_leapfrog(masses, q0, p0, dt=0.001, n_steps=100000)
def poincare_section_hamiltonian(dH_dq, dH_dp, H_func, q0, p0, dt, n_steps,
section_idx=0, section_val=0.0):
"""
Compute Poincare section for a Hamiltonian system.
Collects (q_j, p_j) when q[section_idx] crosses section_val.
"""
q, p = leapfrog(dH_dq, dH_dp, q0, p0, dt, n_steps)
crossings_q = []
crossings_p = []
for i in range(1, len(q)):
q_prev = q[i-1, section_idx] - section_val
q_curr = q[i, section_idx] - section_val
if q_prev < 0 and q_curr >= 0: # positive crossing
# Linear interpolation
frac = -q_prev / (q_curr - q_prev)
q_cross = q[i-1] + frac * (q[i] - q[i-1])
p_cross = p[i-1] + frac * (p[i] - p[i-1])
# Record other phase space coordinates
other_idx = [j for j in range(len(q0)) if j != section_idx]
crossings_q.append(q_cross[other_idx])
crossings_p.append(p_cross[other_idx])
return np.array(crossings_q), np.array(crossings_p)
| Method | Order | Energy Error (1000 orbits) | Cost/Step | Best For |
|---|---|---|---|---|
| Euler (non-symplectic) | 1 | O(1) — drifts! | 1× | Never use for Hamiltonian |
| Leapfrog/Verlet | 2 | O(dt²) bounded | 1× | Default choice |
| Yoshida 4th order | 4 | O(dt⁴) bounded | 3× | High accuracy needed |
| Ruth 3rd order | 3 | O(dt³) bounded | 3× | Rarely used |
| RK4 (non-symplectic) | 4 | O(dt⁴) but DRIFTS | 4× | Short integrations only |
| Symptom | Fix |
|---|---|
| Energy drifts monotonically | You're using a non-symplectic method — switch to leapfrog |
| Close encounters cause blowup | Soften potential: 1/r → 1/√(r² + ε²) |
| Need adaptive timestep | Use time-transformed leapfrog (Mikkola & Aarseth) |
| Phase space structure smeared | Reduce dt (symplectic structure preserved at any dt, but accuracy improves) |