SEED ANALYSIS

CHINATOWN WARS DS · SSS* ALGORITHM · VESTA-24 · SAME PROBLEM · THREE DOMAINS
the three systems
Chinatown Wars DS
4MB RAM · full open world
Hardware constraint: cannot hold everything in memory. Solution: hold only what's needed right now. Stream the rest on demand from solid-state cartridge.
SSS* Algorithm (Stockman 1979)
Best-first game tree search
Cannot evaluate all nodes. Solution: OPEN priority queue of partial solution trees sorted by h. Pop best. Apply Γ. Never examine nodes alpha-beta would prune.
VESTA-24 Open Problem 3
Depth-weighted gap metric
Cannot give equal weight to all context depths. Solution: scale(N) = 1 − ln(N+1)/ln(6). Log-linear attenuation. Matches CERN injector chain physics.
technique 1 — only compute what's in the window
DS: Frustum Culling
Top-down camera limits visible area to a small square. Motor only calculates polygons inside that frustum. Everything outside: zero computation.
SSS*: OPEN Queue Pruning
Queue contains only nodes that can still improve the best solution. h value = upper bound. If h ≤ current best: node never examined. Strictly better than alpha-beta.
VESTA: Depth Window
scale(N) defines the sensitivity window per depth. N=0: full computation. N=5: effectively zero. Only the relevant depth receives full evaluation budget.
Common principle: define a window. Compute only what's inside it. Discard everything else before loading it.
technique 2 — stream on demand, delete when passed
DS: Grid Streaming
City divided into grid cells. As player moves: load next cell from cartridge, delete previous cell from 4MB RAM immediately. Solid-state = no seek latency. Never hold more than needed.
SSS*: OPEN List Management
Pop (J,s,h) from head. Apply Γ. Push children. When a MIN node is solved (s=S): push parent, remove ALL children of parent from OPEN. Solved subtrees are deleted immediately.
VESTA: CENTER Layer Stack
N=0..5 depth layers, each a Z/256Z ring (S¹). Read needed depth, compute gap, weight by scale(N). Five nested rings = CERN PSB→PS→SPS→LHC injection chain. Same topology.
DS: RAM ← load(next_cell) ; delete(prev_cell) SSS*: OPEN ← pop(best) ; push(children) ; remove(solved_subtree) VESTA: Δ_eff(N) = |M−G| × scale(N) where scale = 1−ln(N+1)/ln(6)
Common principle: the algorithm IS the moving boundary. Advance it forward. Delete behind it. Never compute ahead of it.
technique 3 — h value = scale function = sensitivity budget
SSS*: h value mechanics
Each state (J, s, h): h is the upper bound on what MAX can achieve from this subtree. Priority queue sorted descending by h — best first.

Terminal node → h := min(h, value(J)). Never overestimate. The h collapses toward truth as nodes are solved.
VESTA: scale(N) mechanics
scale(N) is the effective h-ceiling for depth N. How much does a gap at this depth contribute to the final metric?

N=0 → scale=1.0 (full attention). N=5 → scale=0.0 (fully contextualised). Δ_eff := min(Δ, 255×scale(N)) — never overestimate from deep context.
SSS*: h_new = min(h, value(terminal)) // collapse toward truth VESTA: Δ_eff = min(Δ, 255×scale(N)) // collapse toward contextualised truth Both: monotone non-increasing as depth/exploration increases
Direct equivalence: SSS* h value ≡ VESTA scale(N). Both are monotone non-increasing priority functions. Both prevent overestimation. Both collapse to a single value at the terminal/surface condition.
technique 4 — the Γ operator maps to VESTA depth traversal
SSS* Γ operator → VESTA CI threshold
SSS* MIN node, state L:
push (J.1, L, h) // explore first child // h ceiling preserved // wait for subtree
Explore deeper. h is the ceiling. Don't resolve yet.
VESTA equivalent:
h_eff = scale(N) × 255 Δ_eff = min(Δ, h_eff) // depth N is the MIN node // scale(N) is the h ceiling
Each depth N caps the gap contribution. scale(N) is the h value for that depth layer.
SSS* MIN node, state S (solved):
push (parent(J), S, h) remove all children of parent(J) // solved → propagate up // prune siblings immediately
Node resolved. Propagate result up. Delete the subtree.
VESTA equivalent:
if CI(N) >= 0.91: return Δ_eff to surface discard deeper computation // CI threshold = SSS* solved condition
CI ≥ 0.91 means depth N is "solved." Propagate. Don't compute deeper. Delete the deeper layers from consideration.
The formal equivalence: SSS* solved condition (s=S, propagate to parent) ≡ VESTA CI ≥ 0.91 (depth resolved, propagate Δ_eff to surface). Both terminate depth expansion when the current result is good enough.
technique 5 — constraint becomes the structure (cell shading principle)
DS: Cell Shading
Can't afford realistic textures → flat color + black outlines. The limitation becomes the aesthetic identity. Brain reads low-poly as comic art.
SSS*: Solution Trees
Can't evaluate full game tree → evaluate only solution trees (one branch per MAX node). The restriction becomes the definition of a complete MAX strategy. Constraint = concept.
VESTA: Pacioli Conservation
Can't use continuous metric on discrete Z/256Z → let M+G=255 be the conservation law. The discrete constraint becomes the (1,1)-torus knot. Limitation = structure.
Common principle: don't fight the constraint. Let it define the structure. The structure becomes the identity of the system.
technique 6 — zero-cost emergent content
DS: Math Economy
No RAM for cinematics → pure math drug economy. 6 types, fluctuating prices, RNG events. Variables + arithmetic = infinite gameplay. Zero assets.
SSS*: Null-Window Equivalence
Instead of complex OPEN list: sequence of null-window alpha-beta calls = identical algorithm. Same nodes, same order. No extra data structures. Same result, zero overhead.
VESTA: CI from Gap Math
CI = 1 − (|Δ − Δ_expected(N)| / 255). Coherence Index computed from the same variables already in use. No new data. The gap generates the health metric for free.
Common principle: extract maximum output from the variables already running the core algorithm. Emergent behavior is a zero-cost side effect of the base computation.
implementation note for low-hardware use
What Chinatown Wars proved — confirmed by SSS* theory and VESTA math
On constrained hardware, you do not need to compute everything. You need to compute the right things in the right order with a budget that matches the physics of the problem.
Camera = h function
Choose what's visible. Set the ceiling. Everything below it: zero cost. Don't render what can't beat the current best.
Grid stream = OPEN queue
Moving boundary. Advance forward. Delete behind. Never pre-load. Never hold more than one cell/node ahead.
scale(N) = proximity radius
Full computation near the player/surface. Logarithmically attenuated at depth. Near-zero at maximum depth. Match the scale to the physics.
CI ≥ 0.91 = 30fps threshold
If coherence maintained: done. Don't compute more. Ship the frame. SSS* solved condition = drop the solved subtree = Chinatown Wars deletes the passed cell.
v = αM(s) + βG(s,t) + γN(s) · γ = 0.666 scale(N) = 1 − ln(N+1)/ln(6) ← the loop filter CI ≥ 0.91 ← the SSS* termination condition Δ_eff = min(Δ, 255×scale(N)) ← the h value collapse 3² + 4² = 5² · always · every substrate