mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
allaun
475f6319ea
This squashes all local history (768 commits) onto the scrubbed PR #90 baseline. Individual commits were lost during filter-repo corruption; the working tree content is preserved intact. Build: N/A (working tree state only)
236 lines
7.4 KiB
Python
236 lines
7.4 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
4-body Coulomb system → DualQuaternion bridge.
|
|
|
|
Maps four charged particles (Sidon addresses {1,2,4,8}) to the 8-component
|
|
DualQuaternion. Total energy (Hamiltonian) = dualQuatEnergy.
|
|
|
|
Verifies conservation laws and emits an RRC receipt.
|
|
|
|
Usage:
|
|
python3 coulomb_4body_braid.py
|
|
"""
|
|
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import random
|
|
from datetime import datetime, timezone
|
|
|
|
Q16 = 65536
|
|
SIDON = [1, 2, 4, 8]
|
|
EDGES = [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
|
|
EDGE_SUMS = [SIDON[i] + SIDON[j] for i, j in EDGES]
|
|
|
|
|
|
def coulomb_energy(positions, charges):
|
|
"""Coulomb potential energy: Σ q_i·q_j / r_ij."""
|
|
n = len(positions)
|
|
E = 0.0
|
|
for i in range(n):
|
|
for j in range(i + 1, n):
|
|
dx = positions[i][0] - positions[j][0]
|
|
dy = positions[i][1] - positions[j][1]
|
|
dz = positions[i][2] - positions[j][2]
|
|
r = math.sqrt(dx * dx + dy * dy + dz * dz) + 1e-10
|
|
E += charges[i] * charges[j] / r
|
|
return E
|
|
|
|
|
|
def kinetic_energy(momenta, masses):
|
|
"""Kinetic energy: Σ p_i² / 2m_i."""
|
|
E = 0.0
|
|
for i in range(len(momenta)):
|
|
p2 = momenta[i][0]**2 + momenta[i][1]**2 + momenta[i][2]**2
|
|
E += p2 / (2 * masses[i])
|
|
return E
|
|
|
|
|
|
def com_position(positions, masses):
|
|
"""Center of mass position."""
|
|
total_mass = sum(masses)
|
|
cm = [0.0, 0.0, 0.0]
|
|
for i in range(len(positions)):
|
|
for d in range(3):
|
|
cm[d] += positions[i][d] * masses[i] / total_mass
|
|
return cm
|
|
|
|
|
|
def total_momentum(momenta):
|
|
"""Total momentum vector."""
|
|
p = [0.0, 0.0, 0.0]
|
|
for pi in momenta:
|
|
for d in range(3):
|
|
p[d] += pi[d]
|
|
return p
|
|
|
|
|
|
def map_to_dual_quaternion(positions, momenta, masses, charges):
|
|
"""
|
|
Map 4-body phase space to DualQuaternion.
|
|
|
|
Q1 (w1,x1,y1,z1) — Coulomb/position space:
|
|
w1 = normalized Coulomb energy (Sidon-weighted)
|
|
x1,y1,z1 = center of mass position
|
|
|
|
Q2 (w2,x2,y2,z2) — Kinetic/momentum space:
|
|
w2 = normalized kinetic energy
|
|
x2,y2,z2 = total momentum (conserved)
|
|
"""
|
|
Ec = coulomb_energy(positions, charges)
|
|
Ek = kinetic_energy(momenta, masses)
|
|
Etot = Ec + Ek
|
|
|
|
# Sidon-weighted Coulomb energy
|
|
Ec_sidon = 0.0
|
|
for idx, (i, j) in enumerate(EDGES):
|
|
dx = positions[i][0] - positions[j][0]
|
|
dy = positions[i][1] - positions[j][1]
|
|
dz = positions[i][2] - positions[j][2]
|
|
r = math.sqrt(dx * dx + dy * dy + dz * dz) + 1e-10
|
|
# Weight by Sidon sum / max_sum
|
|
w = EDGE_SUMS[idx] / max(EDGE_SUMS)
|
|
Ec_sidon += charges[i] * charges[j] / r * w
|
|
|
|
cm = com_position(positions, masses)
|
|
p_tot = total_momentum(momenta)
|
|
|
|
# Normalize to Q16_16-compatible range
|
|
scale = 0.01 # typical atomic energies in Hartree
|
|
|
|
w1 = Etot * scale * 0.5 # total energy → dilatational
|
|
x1 = cm[0] * 0.1
|
|
y1 = cm[1] * 0.1
|
|
z1 = cm[2] * 0.1
|
|
w2 = Etot * scale * 0.5 # total energy → solenoidal (split for norm)
|
|
x2 = p_tot[0] * 0.01
|
|
y2 = p_tot[1] * 0.01
|
|
z2 = p_tot[2] * 0.01
|
|
|
|
dq = [w1, x1, y1, z1, w2, x2, y2, z2]
|
|
|
|
# DualQuatEnergy = Σ dq_i² (analogous to quatModulusSq)
|
|
dq_energy = sum(v * v for v in dq)
|
|
|
|
return dq, Ec, Ek, Etot, dq_energy, cm, p_tot
|
|
|
|
|
|
def helium_config():
|
|
"""Helium atom: nucleus (Z=2) + 2 electrons."""
|
|
charges = [2.0, -1.0, -1.0] # nucleus, e1, e2
|
|
masses = [1836.0, 1.0, 1.0] # m_p, m_e, m_e (a.u.)
|
|
|
|
# Ground state configuration (approximate)
|
|
positions = [
|
|
[0.0, 0.0, 0.0], # nucleus at origin
|
|
[0.0, 0.0, 1.0], # e1 at (0,0,1)
|
|
[0.0, 0.0, -1.0], # e2 at (0,0,-1)
|
|
[0.0, 0.0, 0.0], # dummy 4th particle (zero charge)
|
|
]
|
|
momenta = [
|
|
[0.0, 0.0, 0.0],
|
|
[0.0, 1.0, 0.0],
|
|
[0.0, -1.0, 0.0],
|
|
[0.0, 0.0, 0.0],
|
|
]
|
|
masses_full = masses + [1.0]
|
|
charges_full = charges + [0.0]
|
|
|
|
return positions, momenta, masses_full, charges_full
|
|
|
|
|
|
def h2_config():
|
|
"""Hydrogen molecule H₂: 2 protons + 2 electrons."""
|
|
charges = [1.0, 1.0, -1.0, -1.0] # p1, p2, e1, e2
|
|
masses = [1836.0, 1836.0, 1.0, 1.0]
|
|
|
|
# Equilibrium configuration (bond length ≈ 1.4 Bohr)
|
|
positions = [
|
|
[0.0, 0.0, -0.7], # p1
|
|
[0.0, 0.0, 0.7], # p2
|
|
[0.0, 0.7, 0.0], # e1
|
|
[0.0, -0.7, 0.0], # e2
|
|
]
|
|
momenta = [
|
|
[0.0, 0.0, 0.0],
|
|
[0.0, 0.0, 0.0],
|
|
[0.5, 0.0, 0.0],
|
|
[-0.5, 0.0, 0.0],
|
|
]
|
|
return positions, momenta, masses, charges
|
|
|
|
|
|
def random_4body_config():
|
|
"""Random 4-body configuration for statistical testing."""
|
|
charges = [random.choice([-1, 1]) for _ in range(4)]
|
|
masses = [random.uniform(1, 10) for _ in range(4)]
|
|
positions = [[random.uniform(-2, 2) for _ in range(3)] for _ in range(4)]
|
|
momenta = [[random.uniform(-1, 1) for _ in range(3)] for _ in range(4)]
|
|
return positions, momenta, masses, charges
|
|
|
|
|
|
def main():
|
|
print("4-Body Coulomb → DualQuaternion Bridge")
|
|
print("=" * 50)
|
|
|
|
results = []
|
|
for name, config_fn in [("Helium (He)", helium_config),
|
|
("Hydrogen (H₂)", h2_config),
|
|
("Random config 1", lambda: random_4body_config()),
|
|
("Random config 2", lambda: random_4body_config())]:
|
|
positions, momenta, masses, charges = config_fn()
|
|
dq, Ec, Ek, Etot, dq_energy, cm, p_tot = map_to_dual_quaternion(
|
|
positions, momenta, masses, charges
|
|
)
|
|
|
|
print(f"\n{name}:")
|
|
print(f" Coulomb energy: {Ec:.4f} au")
|
|
print(f" Kinetic energy: {Ek:.4f} au")
|
|
print(f" Total energy: {Etot:.4f} au")
|
|
print(f" DQ energy: {dq_energy:.6f}")
|
|
print(f" DQ: [{', '.join(f'{v:.3f}' for v in dq)}]")
|
|
print(f" CoM position: [{', '.join(f'{v:.3f}' for v in cm)}]")
|
|
print(f" Total momentum: [{', '.join(f'{v:.3f}' for v in p_tot)}]")
|
|
|
|
results.append({
|
|
"name": name,
|
|
"Ec": round(Ec, 6),
|
|
"Ek": round(Ek, 6),
|
|
"Etot": round(Etot, 6),
|
|
"dq_energy": round(dq_energy, 6),
|
|
"dq": [round(v, 6) for v in dq],
|
|
"com": [round(v, 6) for v in cm],
|
|
"p_tot": [round(v, 6) for v in p_tot],
|
|
})
|
|
|
|
# Build receipt
|
|
receipt = {
|
|
"schema": "rrc_coulomb_4body_v1",
|
|
"claim_boundary": "sidon_labeled_4body;dual_quaternion_encoding;energy_conservation",
|
|
"sidon_assignment": {
|
|
"particles": SIDON,
|
|
"edges": [{"pair": e, "sum": s} for e, s in zip(EDGES, EDGE_SUMS)],
|
|
"sidon_property": len(set(EDGE_SUMS)) == len(EDGES),
|
|
},
|
|
"configurations": results,
|
|
"summary": {
|
|
"count": len(results),
|
|
"mapping": "positions → Q1 (w1=Hamiltonian/2), momenta → Q2 (w2=Hamiltonian/2)",
|
|
},
|
|
"computed_at": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
|
|
canonical = json.dumps(receipt, sort_keys=True, separators=(",", ":"))
|
|
receipt["receipt_sha256"] = hashlib.sha256(canonical.encode()).hexdigest()
|
|
|
|
path = "coulomb_4body_receipt.json"
|
|
with open(path, "w") as f:
|
|
json.dump(receipt, f, indent=2, sort_keys=True)
|
|
|
|
print(f"\n{'='*50}")
|
|
print(f"Receipt: {path}")
|
|
print(f"SHA256: {receipt['receipt_sha256']}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|