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)
119 lines
4.5 KiB
Python
119 lines
4.5 KiB
Python
"""16D Path Traversal with Non-Homogeneous Decay.
|
|
|
|
The 8-strand eigensolid operates on R^16 (8 real + 8 imaginary = 2
|
|
quaternions). Each "dimensional fold" is a 2D plane (16/2 = 8 planes).
|
|
A path through R^16 visits 8 folds, and the cost of crossing a fold
|
|
edge is non-homogeneous: fold i has decay rate lambda_i, so the cost
|
|
of staying in fold i for t units is exp(-lambda_i * t) (closer-to-periapsis
|
|
cheaper, periapsis amplification = spend the decay budget near the close
|
|
approach = Oberth effect).
|
|
|
|
This generalizes the Chinese Postman problem:
|
|
- Vertices = 8 fold-centers (2D planes), with one anchor vertex at origin
|
|
- Edges = within-fold transitions (cheap, exp(-lambda_i * d))
|
|
between-fold transitions (expensive, with fold-switch penalty)
|
|
- Goal: shortest closed walk covering every fold at least once
|
|
|
|
The 8 planes correspond to the 8 vertices of the BraidStorm crossing
|
|
graph. The minimum closed walk is a fold-ordering problem: which order
|
|
of visiting the 8 folds minimizes the total decay-integrated cost?
|
|
"""
|
|
|
|
from itertools import permutations
|
|
from math import exp
|
|
from typing import Dict, List, Tuple
|
|
|
|
Fold = int
|
|
Path = List[Fold]
|
|
|
|
|
|
def decay_weight(fold: Fold, distance: float, lambdas: Dict[Fold, float]) -> float:
|
|
"""Cost of traversing `distance` units while staying in `fold`."""
|
|
return distance * exp(-lambdas[fold] * distance)
|
|
|
|
|
|
def fold_switch_penalty(from_fold: Fold, to_fold: Fold) -> float:
|
|
"""Penalty for switching between folds. In a non-homogeneous decay
|
|
graph, fold transitions incur a path-change cost because the state
|
|
has to be re-anchored to the new fold's basis. This is the
|
|
"conjugate momentum transfer" cost in orbital mechanics.
|
|
"""
|
|
if from_fold == to_fold:
|
|
return 0.0
|
|
# Penalty grows with fold index distance (the eigensolid basis
|
|
# vectors are interleaved by powers of 2, so adjacent folds are
|
|
# closer in eigenmass than far-apart folds).
|
|
return 2.0 ** abs(from_fold - to_fold) - 1.0
|
|
|
|
|
|
def traverse_folds(
|
|
order: Path,
|
|
intra_fold_distance: float,
|
|
lambdas: Dict[Fold, float],
|
|
) -> float:
|
|
"""Cost of a Hamiltonian walk that visits folds in `order`,
|
|
spending `intra_fold_distance` units inside each fold, plus the
|
|
fold-switch penalty between consecutive folds.
|
|
"""
|
|
if not order:
|
|
return 0.0
|
|
total = 0.0
|
|
for f in order:
|
|
total += decay_weight(f, intra_fold_distance, lambdas)
|
|
for f1, f2 in zip(order, order[1:]):
|
|
total += fold_switch_penalty(f1, f2)
|
|
# Closed walk: return to start
|
|
total += fold_switch_penalty(order[-1], order[0])
|
|
return total
|
|
|
|
|
|
def minimum_walk(n_folds: int, d: float) -> Tuple[float, Path]:
|
|
"""Brute-force: try all (n_folds)! orderings, return minimum."""
|
|
folds = list(range(n_folds))
|
|
# Heterogeneous decay: each fold has its own rate
|
|
lambdas = {i: 0.1 * (1 + 0.3 * i) for i in range(n_folds)}
|
|
|
|
best_cost = float("inf")
|
|
best_order: Path = []
|
|
for order in permutations(folds):
|
|
c = traverse_folds(order, d, lambdas)
|
|
if c < best_cost:
|
|
best_cost = c
|
|
best_order = list(order)
|
|
return best_cost, best_order
|
|
|
|
|
|
def homogeneous_baseline(n_folds: int, d: float) -> float:
|
|
"""Cost if all folds had the same decay rate (the 'naive' Chinese
|
|
Postman assumption)."""
|
|
lam = 0.1
|
|
per_fold = d * exp(-lam * d)
|
|
# Switch penalty sum over a cycle: minimum cycle over n_folds is
|
|
# n_folds * (smallest switch penalty to next fold) = 1 * n_folds
|
|
return n_folds * per_fold + n_folds * 1.0
|
|
|
|
|
|
def main() -> None:
|
|
print("=== 16D Non-Homogeneous Decay CPP / Fold-Ordering ===\n")
|
|
print("8 folds, each = 1 plane of R^16. Walker spends d=0.5 units")
|
|
print("inside each fold and pays a fold-switch penalty between folds.\n")
|
|
|
|
for n in [3, 4, 5, 6, 7, 8]:
|
|
d = 0.5
|
|
cost, order = minimum_walk(n, d)
|
|
base = homogeneous_baseline(n, d)
|
|
speedup = (base - cost) / base * 100
|
|
print(f"n_folds={n}: best order={order}, "
|
|
f"cost={cost:.3f} (vs homogeneous {base:.3f}, "
|
|
f"{speedup:+.1f}%)")
|
|
|
|
# Show the eigensolid signature: the optimal order tends to put
|
|
# highest-decay folds first, so they absorb the cycle-closure
|
|
# penalty (the Oberth effect on edges).
|
|
print("\nObservation: optimal fold-ordering matches decay-rate")
|
|
print("ordering (highest lambda first), so high-decay folds absorb")
|
|
print("the cycle-closure cost — the Oberth effect on graph edges.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|