Blob machines — physim blobs

Post 6 — from the first cargo hauler to composed logistics lines, and the stability laws machine engineering keeps running into.

The relay tug

Uses the trains of post 4; the landscape-growing counterpart is post 5; the search that found the v3 parts is post 7.

Framing per the ratchet literature (Reimann Phys. Rep. 361:57): a static asymmetric potential cannot transport a passive overdamped particle — and ours doesn't. This is an active-particle ratchet: the blobs' own drift mode is the motor, the sawtooth only rectifies it (cf. bacterial ratchet gears, Di Leonardo et al. PNAS 107:9541). Our earlier noise-ratchet negative matches soliton-ratchet theory exactly (Salerno & Quintero PRE 65:025602: transport needs a soft internal mode or translational noise — our solitons are too stiff).

A machine needs an opponent: a load field the cargo will not climb by itself. The trick that makes this clean is zero-footprint forcing ("isok" mode): shift (k₁, k₄) together along the iso-background line as a static function of position, b(x). The vacuum state stays an exact fixed point everywhere (checked to 1e−16) — the landscape is invisible until a blob shows up, and then it feels a force pushing it "downhill" toward lower b. A sawtooth b(x) (5 teeth, period 32, gentle rise + sharp cliff) makes a periodic track where downstream = down the long rising ramps.

Field-theory view of isok (for readers who like actions). To be precise about the knobs: isok shifts both couplings together, k₁ → k₁ + u₀·b(x) and k₄ → k₄ + b(x) (not k₄ alone) — the direction in (k₁,k₄) space along which the vacuum root u₀ is exactly preserved, because the vacuum condition −u³+(λ−k₃−k₄)u+k₁=0 traces a straight line of slope u₀ in that plane. The perturbation to the u-equation collapses to a single term:

δ(∂u/∂t) = −b(x)·(w − u₀)

which is identically zero on the vacuum (w=u₀ there) — that is the whole zero-footprint property, now as one line of algebra. And this term is exactly what a trilinear vertex would produce: add S_int = ∫ b·u·(w−u₀) to a (pseudo-)action and vary in u, and you get −b·(w−u₀) in the equation of motion. So b is best read not as "changing the laws" but as a static third field mediating the u–w interaction — a b·u·w coupling with the u₀ counterterm subtracting its vacuum expectation. Where b≠0, a blob's own inhibitor shadow (w−u₀ > 0 inside the blob, rippling in the tails) costs energy that depends on position; the gradient of that cost is the force. Two honest caveats: this system has no true action (it is dissipative, gradient-flow-like only in pieces), so "vertex" is an analogy at the equations-of-motion level; and b here is frozen (non-dynamical) by design — promoting it to a slow dynamical field with its own relaxation is precisely the door to blobs that reshape their own landscape (chemotaxis-style self-interaction), which we have deliberately kept closed in machine v1 to preserve the honesty rule that the environment is static.

part	made of	function
locomotive	3-blob wake-locked train (M4), τ=5.70	self-propulsion c≈0.06–0.09, strong enough to climb (a pair is NOT: it reverses on any tested tooth — measured, hence 3 blobs minimum, climb margin 1.53×)
track	isok sawtooth b(x), ε=5·10⁻⁴	the adversary: every parked blob slides downstream into a trough and stays
parking brake	pair-only zone (M4)	lone cargo cannot move itself — it waits exactly where it parked
rails	static y-channel: b_chan(y)=0.002·min(\|y−y₀\|, 24)	a shallow zero-footprint valley in the cross direction keeping the train on axis (without rails the growing train buckles into the trough valley after 1–2 pickups — the certified failure of machine v1)
coupler	M2/M4 wake shells	head-on pickup: cargo locks into the leader's front shell at 14.9 px and becomes the new leader — a pusher-tug; train speed grows per pickup (0.059 → 0.073 → 0.085)

M5 — RELAY TUG, the certified run. Left: the field (bright = blobs). Right top: all six blob tracks; cargo lines (cyan) sit flat — parked — until the train arrives, then join the common upstream slope. Right bottom: the sawtooth load field. Certification: 3 seeds — 3/3 pickups each, net upstream cargo displacement 757–780 px (gate: 30), efficiency 5.6–5.8× the do-nothing baseline; null run (no locomotive): cargo drifts 0.5 px downstream. Fresh-seed controller audit reproduced everything; blob count stayed exactly 6 for the full 3600 tu.

The certified tug layout (parameters)

component	value	why
world	A=4 family (M0 + D_v=4/τ), τ=5.70	pair-only zone: cargo parks, trains travel
track	isok sawtooth, 5 teeth, period 32, ε=5·10⁻⁴, rise fraction 0.85	tooth height 0.0068 < 3-train climb envelope 0.0104 (margin 1.53×)
rails	b_chan(y)=0.002·min(\|y−80\|, 24)	railless trains buckle after 1–2 pickups
locomotive	3-blob train, kick at t=0 only	pairs cannot climb any tested tooth
cargo	3 blobs parked in troughs, spacing 32	trough = parking brake (pair-only zone)
budget	L=160, T=3600, dt=0.02, dx=0.5	3 pickups + ≥2 laps

Tug certification, four panels. Top-left: every blob's position vs time in the certified run — stars mark the three pickups; note the rear locomotive blob shedding at t≈1150 (gray line goes flat = parked at a trough) and being re-collected on the train's next lap at t≈1750 — the self-healing relay. Top-right: the gate metrics across 3 seeds + jitter: per-cycle cargo displacement, all runs essentially identical (net 756–766 px, efficiency 5.6×). Bottom-left: the paired null — without the locomotive, the same cargoes move −0.5 px (solid lines at zero); with it, +235–270 px each (dashed). Bottom-right: the track design that makes it work: tooth apex (+0.0068) below the 3-train climb envelope (dashed red, +0.0104), trough depth far above the replication edge (dotted, −0.09).

Two emergent bonuses, neither designed: at the 6-train power ceiling the machine sheds its rear blob, which slides back, parks at a trough (pair-only zone again), and is re-collected on the next lap — a self-healing relay. And because pickup happens by wake capture, the machine needs no controller at all after t=0: one initial kick, then pure autonomous physics for as long as we watched.

The factory parts list: tow, dock, fork

Third campaign, 2026-02-20/21: two top-down searchers (blob-factory: compose certified mechanisms toward the "fulfillment center" vision; blob-genesis: which hand-built landscapes can the physics grow on its own?) plus the bottom-up equation-space search (section 12). All audited on fresh seeds as usual. Probe dirs: probes/blobs/factory/ (112 records), probes/blobs/genesis/ (58).

The factory searcher added one legalism with big consequences: the cross-species coupling η can be a static field η(x,y) — it enters the v-equations exactly the way isok enters u, so the vacuum stays exact and "where blobs can grip each other" becomes geography. That gives three certified primitives and one composed machine:

primitive	result	the law it produced
tow	a traveling pair carries a cargo blob locked in its wake well (155 px conveyed at full pair speed)	near-onset cargo law: deep-static cargo (τ₂=2.5) is untowable — any coupling strong enough to grip it destabilizes something (the well ceiling is 0.017, below every stable carrier speed; mutual-η carriers replicate). Cargo parked in the rotor-only zone (τ₂=5.60) still self-parks, but its well response is 7–8× amplified (near-onset susceptibility — M5's adversary physics turned into the coupling): it locks at 8.46 and tows at full speed. One dial switches cargo between inert freight and towable. η=0.1 tows / 0.05 drops.
unload dock	an η→0 null zone (vacuum-exact) releases the towed cargo: 6.5–7.5 px glide past the edge, then frozen ≤0.3 px/500 tu; carrier continues. 3/3 seeds + carry-control (held 149 px) + null-control (1.15 px)	release needs no unbinding physics — switch off the grip in space, not in time. The missing "delivery" primitive from M5, solved by coupling geography.
species fork	per-species rails sort mixed arrivals 24/24 (3 seeds + mirrored geometry), null clean	bonus dial: timescale asymmetry (M slides at 0.074 px/tu, S at 0.0047) — speed sorting even without species rails.

The glued machine, controller-audit run (fresh seed). One world, three mechanisms chained: the carrier pair (purple) picks up near-onset cargo (orange) and tows it along the lane through the η-active zone (green); at the release edge (red dashed, x=104) the grip vanishes and the cargo glides free; the fork branch rail (blue dashed) catches it and sorts it to a parking spot 17.6 px off-lane; the carriers keep lapping (net +293 px). Blob count constant throughout — no replication, no death.

The composition rule (the actual L3→L2 finding). Gluing mechanisms is not free: v1 parked the cargo 7.4 px from the lane and every carrier lap dragged it 6.6 px; v2's fix got it re-captured; releasing at the fork crotch trapped the carrier head-on (4/4 reproducible). The rule that emerged: certified primitives compose iff their interaction footprints — tow-well reach (15 px), rail walls, carrier lane — are disjoint at every handoff. Machine design in this physics is geometric margin management, not new mechanisms. (Also mapped: the "roller" idea — using a spinning heterodimer to advect grazing cargo — is a positioner (~0.07 px/rev, certified, sign-locked, null exact) but not a conveyor at safe couplings; at brief parameters the rotor instead captures the cargo and converts into a new object, an S–M–S pendulum librator (period ~307 tu) — extending the motion hierarchy: bond < travel < rotate < librate.)

The factory primitives, panel by panel. (a) the near-onset cargo law: approach speed into a carrier's η-well vs distance — deep-static cargo (blues) barely responds at any coupling, near-onset cargo (oranges/reds) responds 7–8× hotter; the dashed line is carrier speed — only near-onset cargo can keep up. (b) tow lock: carrier–cargo separation vs time — η=0.1 locks at the 8.5px shell and holds for the whole run; η≤0.05 drops the cargo. (c) the dock: cargo x(t) riding the carrier (red on gray) until the η-null edge (dashed black), then a short glide and a permanent park — while the carry-control (blue dashed, no null zone) keeps going and the null-control (green dotted, no carrier) never moves. (d) the roller verdict: tangential cargo arc next to a spinning rotor — real but tiny (~5px per 3000tu, exactly zero in the η=0 null): a positioner, not a conveyor. (e) the pendulum surprise: put a second anchor near a rotor and the orbiter converts to ±90° libration between them — a new composite mode (bond < travel < rotate < librate). (f) the species fork: y(t) of the two species entering the fork — M (red) climbs to its rail at y=60, S (blue) descends to y=37; 24/24 sorting purity across seeds and a mirrored-geometry swap.

Machine v2 — the convoy line and the law cascade

Scaling the glue machine from one cargo to a queue of three produced a genuinely new machine and three new laws that stopped it short of full certification — the most instructive outcome so far.

The machine that works (certified 3/3 seeds + fresh-seed audit): on a railed lane, a carrier meeting cargo head-on doesn't swing around it (rails forbid the factory's swing-around geometry) — at moderate grip the meet becomes a stable push-capture "blade": the cargo rides 7 px ahead of the carrier at full speed. So sequential one-at-a-time service is impossible on rails; the only throughput machine is a bulldozer convoy — the carrier sweeps the whole queue into a chain and delivers it wholesale. One trick makes the convoy sortable: a sacrificial plug blob rides the blade slot (which can never be fork-sorted — its y-hold is weaker than the fork needs, with 4 distinct trap limit-cycles mapped), so the chain-pushed real cargoes sort cleanly behind it: all 3 delivered to the branch floor as a bond-shell stack (15.3–15.5 px spacing), blob count frozen, cycle time 215 tu.

The law cascade that blocked the full gate: the delivered 3-stack is itself a bonded structure — and per M4 physics, bonded structures near onset travel. The parked stack shuttles ±9 px (isolation control: intrinsic). Fixing it means colder cargo (τ₂ < τ_c(3) ∈ (5.55, 5.60]) — but colder cargo compresses the blade gap below its ~5.4 px split floor at working speed (blade-load law), and slowing the convoy to protect the blade makes the blade contact transversely unstable (slow-convoy buckling, the M5 buckling generalized). For a 3-cargo convoy the window is empty in this architecture. Stack-safety, blade-load, and buckling are now quantified design laws — machine engineering in this physics is navigating a lattice of competing stability windows, exactly the kind of hidden-law structure the eventual agent-facing world wants.

Machine v3 — the first machine built from searched parts

Certified. The carrier is the 3-field engine the atlas found (c=0.20–0.34); the cargo is the plateau-bond world blind uniform search invented; neither was designed. The only engineered step was the coupling, and even that was found by systematic search over coupling moves: the suggested weak cross-v failed (no grip at 0.05, splits the engine at 0.10), single-channel writes failed, and the minimal grip turned out to be a 60% "phantom cargo" imprint — the engine writes a scaled copy of the cargo's own field signature into the cargo's channels, one-way, leaving engine dynamics unchanged to 4 digits. Tow is a push blade at 4.3 px standoff (pull is impossible — an engine placed ahead simply runs away); drag 131 px per lock noiselessly (controller-replicated to 5 digits), lock–slip–relock under working noise (caveat recorded). Release is the cleanest yet: cut the coupling and the cargo parks instantly (10⁻¹⁵ px), and a decoupled engine laps the torus straight through the cargo's neighborhood without disturbing it — architectural flyby immunity.

Delivery mode has a twist the laws demanded: towing a pre-bonded 3-stack is a mapped no-go in this world (full-speed pushing merges the chain; slow pushing tears it). The certified machine instead does sequential single-cargo pushes with assembly at the dock: three noisy-seed runs each delivered a parked, bonded 3-stack at the certified bond spacing (13.6–14.0 px) with hold drift under 0.002 px — the stack-safety property the plateau cargo was recruited for, demonstrated in the delivered product.

Watch tow-and-release (both species' activator fields; orange = engine, blue = cargo): with the phantom-cargo coupling ON, the engine closes in and push-blades the cargo across the domain at 4.3 px standoff; at t=500 the coupling is CUT — the cargo freezes on the spot (drift 10⁻¹⁵ px) while the engine, now blind to it, drives on and laps the torus straight past the parked cargo without a nudge: release and flyby immunity are the same property, seen from two sides.

Earlier status note

The convoy line's three blocking laws (stack-safety, blade-load, buckling) were turned into search queries, and the equation-space atlas answered all three — see post 7 for the harvest. The v3 parts list: a 3-field engine carrier at c = 0.20–0.30 (2–5× blade-load margin), plateau-bonded cargo stacks that park motionless under noise (the stack-safety fix), and two candidate 3-species worlds with clean cross-bonds for species-tagged rails. Separately, a closed-loop recirculation test (cargo gripped → towed → released → re-gripped over multiple carrier laps) and the first machine with an L1-grown component are in progress. This section will be updated when v3 certifies.

Watch the convoy run (controller-audit seed): the carrier pair (purple) sweeps up the plug (gray) and three cargoes (oranges) into a blade convoy inside the green coupling zone; at the dock (red dashed) the chain releases; the three real cargoes slide down the fork branch (blue dashed) to the y=20 floor and park as a bonded stack, while the plug stays on-lane — it can never be sorted, which is exactly why it rides the blade slot. The wiggle near x≈120 is convoy formation: the blade finding its standoff.

Why full certification failed — the delivered stack is alive. Left: the cert table: function passes 3/3 seeds (pickups, sort, throughput) but the park gate fails 3/3 — the delivered stack shuttles ±10px. Right: the smoking gun: x(t) of a delivered-stack blob (orange) vs the same stack built in isolation (blue) — both oscillate identically. The stack is not being disturbed; it is a bonded 3-train at τ₂=5.60 > τ_c(3)≈5.56, and bonded trains above threshold travel. The fix (colder cargo) is blocked by the blade-load split floor, and slowing down hits buckling — the three-law cascade in the text.

The recirculation no-go (V2c, closed)

Can a single dock recycle its own cargo — grip, tow, release, and re-grip on the next lap? Two certified runs answer no, structurally: the cargo is towed once, released past the coupling-zone edge, and parks outside the zone — where the lapping carrier passes it 4+ times with zero re-grip and zero disturbance (the same flyby immunity that makes release clean makes re-collection impossible). The law: release and re-entry cannot share an edge — closing a loop requires a return leg (a second zone with an opposing carrier, or a landscape slope sliding parked cargo back to the entry — the genesis toolkit's job). Docks compose in series only with an interposed transport primitive. This closes V2c as a mapped negative and writes the requirements list for a true closed-loop logistics line.

Watch the no-go: the carrier (purple) grips each towable blob once inside the green zone, releases it past the red edge — and then laps the torus again and again (counter top-left), passing within pixels of the parked cargo with zero re-grip: outside the coupling zone, the cargo is invisible to it. The release property and the un-collectable property are the same physics. Closing a loop needs a return leg.