Cycle Log 48

Images created with Image 2 via Codex and Fal.ai

The Post-Perturbation Continuity Gap

Training Humanoid Robots to Preserve Perception, Intent, and Whole-Body Control Through Unexpected Physical Disturbance

A Gray Paper on Continuous Objective Control, Perturbation Training, Persistent 3D State, and Emergent Humanoid Motion
By Cameron Tavassoli and ChatGPT, GPT-5.6 Sol, High Thinking
August 2026

Abstract

Humanoid robotics has advanced to the point that many individual behaviors are becoming remarkably competent. Robots can run, kick, turn, recover from falls, track objects, compete in soccer, perform martial-arts demonstrations, and execute increasingly complex physical tasks. Yet competitive environments expose a different class of weakness. The failure is often not inside a movement itself. It appears during the transition produced when an unexpected physical disturbance moves the robot away from the state in which its current or subsequent behavior was most easily expressed.

A robot may execute a kick correctly, receive an unexpected impact, preserve enough balance to remain operational, and nevertheless lose useful time. It may reorient its body, reacquire its target, move toward a familiar pose, or pass through a recovery regime before productive task behavior resumes. This paper calls the resulting loss of goal-directed continuity the Post-Perturbation Continuity Gap, or PPCG.

The central argument is that a humanoid should not be trained merely to recover after disturbance. It should be trained to preserve as much task value as possible through the disturbance and recovery interval itself.

Traditional conceptual sequence:

action -> perturbation -> recovery -> reacquisition -> task resumes

Proposed sequence:

action -> perturbation -> updated physical and perceptual belief state -> continued objective optimization

Many individual ingredients of this proposal already have strong precedents. Humanoid push recovery has been studied across arbitrary walking phases; reinforcement learning has produced whole-body recovery and dynamic humanoid soccer; adaptive curricula and adversarial training can locate vulnerable robot states; belief-state estimation, domain randomization, goal-conditioned control, and self-play are established techniques; and unified controllers have demonstrated task continuation after recovery.

The proposed contribution is therefore narrower. It is the organization of these ideas around a specific training and evaluation target: retained task value during unexpected physical state transitions. The framework distinguishes mechanical recovery, perceptual continuity, and task continuity; trains physical disturbances throughout dynamically relevant states while leaving the original objective active; maintains external targets as persistent uncertain beliefs rather than ephemeral visual detections; and directly measures how much useful behavior survives the perturbation interval.

The core hypothesis is simple:

Unexpected physical state change should not imply cognitive or task reset.

The humanoid should learn to continue.

1. Foreword: Watching the Failure Between the Movements

This paper began because I was watching robots fight and play soccer. The 2026 World Humanoid Robot Games in Beijing were extraordinary to watch. More than 2,000 robots from hundreds of teams competed across dozens of events designed to stress autonomy, perception, coordination, dexterity, and physical control. The rate of improvement was unmistakable. Robots that once shuffled now sprint. Soccer has expanded into increasingly dynamic multi-robot competition. Martial-arts demonstrations increasingly expose real-time balance, tracking, and whole-body control rather than isolated scripted motions.

But the failures became just as interesting to me as the successes.

In several fighting and soccer demonstrations, I noticed a particular pattern. A robot could have a reasonably competent movement available to it. It could kick, turn, track another robot, or preserve its balance. Then something unexpected would happen: it would get hit, be knocked sideways, land a foot differently than expected, lose its previous orientation, or have the opponent move while its body was still recovering. Then there could be a small but obvious dead zone.

The robot had not necessarily failed at the kick. It had not necessarily failed at balancing. What appeared to fail was continuity between one useful state of behavior and the next.

That distinction became the beginning of this paper.

My first thought was simple: if the robot is going to be struck, then during training we should strike it. Not metaphorically. Physically, in simulation.

Apply force from every meaningful direction. Apply it while the robot is standing, stepping, rotating, approaching a target, contacting a target, lifting one foot, landing the other foot, or recovering from an earlier disturbance. Change the ground. Make it slippery. Make it sticky. Change the friction under each foot independently. Change the magnitude, direction, location, duration, and waveform of the applied force.

Most importantly, do not automatically stop the task when the disturbance occurs. If the robot is pursuing a target, the target remains the target. If it is protecting something, that responsibility remains. If the opponent moves while the robot is rotating sideways, the opponent does not politely freeze until the robot returns to a canonical stance.

The world continues. The robot's objective should continue with it.

That immediately exposed a second problem. If the robot is struck and its camera suddenly rotates away from the opponent, why should it completely lose the opponent's location? The robot knew where the opponent was a fraction of a second earlier. It knew something about velocity. Its proprioceptive system knows how its own body has moved. It can maintain an estimate.

The target briefly leaving the camera should increase uncertainty. It should not produce amnesia.

That led to the idea of a compact dynamic representation of the opponent or other relevant object living inside a larger persistent representation of 3D space.

Then another question followed. Perhaps we have been too interested in making robots perform motions that humans recognize. Human martial arts are solutions to the mechanical constraints of human bodies: our muscles, tendons, bones, reaction times, pain, fatigue, joint limits, foot geometry, and center-of-mass distribution. A humanoid robot resembles us topologically while potentially differing from us in nearly every parameter that made those techniques useful.

If the objective is physical performance rather than human imitation, perhaps the machine should be allowed to discover its own movement vocabulary. Instead of telling it, "Perform this karate kick," tell it, "Achieve controlled contact with this target under these physical and safety constraints."

Then let the optimizer solve the mechanics.

This is not an argument that teams competing in Beijing failed to use perturbation training. Their internal systems cannot be reliably reconstructed from competition footage, and modern robotics already contains sophisticated perturbation-trained control. The narrower claim is more useful:

A robot may recover mechanically while still losing perceptual or task continuity. That difference deserves to be trained and measured directly.

The robot did not necessarily fail inside its motion. It failed in the space between one useful state and another.

The goal is to train that space too.

2. The Post-Perturbation Continuity Gap and the Specific Contribution

I define the Post-Perturbation Continuity Gap, or PPCG, as the loss or degradation of goal-directed behavior following an unexpected physical state transition, relative to the useful task performance the robot could otherwise have produced over the same interval.

Three concepts should be separated. Mechanical recovery asks whether the robot can avoid falling, restore support, or otherwise remain physically operational. Perceptual continuity asks whether the robot continues to maintain a usable estimate of task-relevant external state, including an opponent, ball, payload, obstacle, tool, destination, or person. Task continuity asks whether the robot continues generating actions that advance the active objective from its newly disturbed physical state.

A robot can succeed at the first while failing at the other two.

Traditional recovery is often implicitly treated as:

action -> disturbance -> stabilize -> recover pose -> reacquire environment -> resume objective

The proposed framing is:

action -> disturbance -> update belief state -> continue optimizing objective

Stopping can still be correct. Catastrophic conditions should terminate behavior. Safety constraints remain superior to task continuation. The claim is simply that perturbation itself should not automatically redefine the task as "return to normal."

2.1 What Already Exists

The strongest way to state the contribution is to be explicit about what is not new. Humanoid push recovery is already a mature research problem, including work on disturbances applied at different walking phases and directions. Reinforcement-learning systems have learned whole-body recovery, locomotion, kicking, turning, and dynamic soccer behavior. Automatic Domain Randomization and adversarial curricula already demonstrate that training can concentrate on difficult environments or vulnerable states. Unified humanoid controllers have demonstrated fall recovery followed by continued task performance, and partially observable control has long formalized the distinction between the true world state and the robot's current observation.

This paper does not claim those individual ideas as inventions.

The remaining question is more specific:

How much of the objective remains behaviorally active while the robot is physically disturbed, perceptually displaced, and still recovering?

A robot that falls, stands up, reacquires its target, and resumes a task has demonstrated recovery and eventual continuation. A robot that is struck, loses its expected body configuration, preserves an estimate of the target, reorganizes its available motion around the new momentum, and continues creating task-positive behavior before conventional recovery is complete has demonstrated something stronger.

That interval is the object of study.

2.2 The Contribution in Three Claims

The proposed framework can be reduced to three linked claims. First, recovery should be evaluated by retained task value, not merely restored posture. Second, perturbation training should preserve the active objective while disturbances are sampled throughout relevant dynamical states. Third, physical continuity and perceptual continuity should be trained together, so a disturbance that rotates the robot away from its target changes the certainty of the target estimate without erasing it.

The theory does not depend on a particular reinforcement-learning algorithm, simulator, camera, mapping system, or whole-body controller. At minimum it requires a continuing objective, unexpected physical state transitions, a persistent estimate of self and task-relevant external state, a controller capable of acting from noncanonical states, and measurements of how much useful task behavior survives the disturbance.

Everything else is implementation.

3. Recovery as Continued Optimization

There is a conceptual trap hidden inside the word recovery: what exactly are we trying to recover?

If the answer is "upright posture," then nominal posture can quietly become the controller's destination. If the actual objective is "continue accomplishing the task," upright posture becomes only one possible means of improving future task value.

Suppose a robot is struck on its right shoulder during a target-directed movement. It rotates counterclockwise, its right leg unloads, and its torso now carries angular momentum. A posture-restoration controller may first cancel that rotation. A task-continuous controller asks a more useful question:

Can this new state be useful?

Perhaps the rotation is already part of the trajectory required to face the target. Perhaps another motion can exploit the momentum rather than canceling it. Perhaps what a human observer calls "recovery" becomes the beginning of the next useful action.

Returning to neutral can throw useful state away.

The ideal instruction is therefore not, "Return to what you were doing." It is, "Given what just happened, what is now the best available continuation?"

3.1 Train Relevant States, Not Just Moves

A conventional motion vocabulary might contain walk, turn, kick, block, recover, stand, and sidestep. Reality does not respect those boundaries.

Reality produces:

kick -> collision -> hip rotation -> foot slip -> target motion -> partial recovery -> second disturbance

There may be no meaningful "move complete" event. A useful low-level formulation is therefore:

action_t = policy(belief_state_t, goal_t)

followed by:

action_t+1 = policy(belief_state_t+1, goal_t+1)

The relevant object is the current estimated dynamical state and active goal, not the name of the motion that was supposed to be occurring.

The useful training principle is:

Any relevant, nonterminal physical state inside the intended deployment envelope should be treated as a valid continuation state.

Not every mathematically reachable configuration deserves equal training. Some states are extraordinarily improbable, irrelevant to deployment, or already beyond a legitimate safety boundary. Training priority should instead reflect whether a state is relevant, consequential, insufficiently solved, and informative.

Conceptually:

training_priority = relevance × consequence × current_failure_probability × novelty

The exact implementation need not literally multiply those terms.

3.2 State Is More Than Pose

Instantaneous joint configuration is also insufficient. Two robots may occupy nearly identical poses while having radically different futures because one has just absorbed a large impulse, another has a slipping support foot, another has saturated an actuator, and another is carrying substantial angular momentum.

The control-relevant belief state may therefore include recent impulse estimates, linear and angular momentum, contact changes, slip history, actuator saturation, commanded versus observed movement, joint loading, and perceptual confidence.

The important question is not simply:

"Where are my joints?"

It is:

"What physical situation am I in, how am I moving, what can I still do, where is the objective, and what action now has the highest future value?"

3.3 Never Reset the Objective

This is the central rule of the framework:

The perturbation changes the state. It does not automatically cancel the objective.

Suppose the robot is pursuing goal G:

belief_state_t + goal G -> action_t

A disturbance occurs:

belief_state_t -> disturbance -> belief_state_t+1

The continuity-trained controller still evaluates:

belief_state_t+1 + goal G -> next best action

Stabilization remains valuable because it may increase future controllability. But stabilization should not automatically replace the task as the sole objective merely because the robot left its expected trajectory.

A robot may be falling, rotating, partially inverted, or temporarily supported by an unusual body contact. None of those descriptions alone means there is no useful action available.

The control problem remains alive until physical or safety constraints genuinely terminate it.

4. Perturbation Training as the Core Method

The training system is the technical center of this proposal.

4.1 Replace the Opponent With Physics First

A complete intelligent opponent is unnecessary during the earliest stages of robustness training. An opponent matters strategically, but mechanically an incoming collision can initially be represented by a smaller set of physical variables:

D = {body_link, contact_point, force_direction, F(t), duration, state_context, surface_state, latency, robot_parameters, ...}

Here, body_link identifies the affected segment, contact_point the local point of force application, force_direction the applied direction, F(t) the force magnitude through time, duration the contact duration, state_context the robot's current dynamical state, surface_state the relevant friction and support properties, and robot_parameters the current embodiment dynamics.

Impulse can be represented as:

J = integral of F(t) over the contact duration

The rotational effect depends on:

torque = r cross F

where r is the vector from a chosen reference point to the contact location.

This gives the simulator a huge family of physically meaningful disturbances without requiring another fully animated humanoid to generate each one. A shoulder can receive a sharp impact, a torso a glancing force, a leg a displacement during support, or the whole body two impulses in rapid succession.

The important training variable is not what the external action looked like.

It is the physical state the disturbance creates.

4.2 Sample the Physical Manifold

The disturbance space is combinatorial:

contact location x force x direction x duration x robot state x surface x latency x embodiment

Exhaustive enumeration is unnecessary. Instead, contact points, force vectors, durations, friction, latency, actuator strength, mass distribution, and similar variables can be sampled continuously from bounded distributions.

Massively parallel simulation can therefore expose the policy to vastly more variations of impact, rotation, slip, delay, and misalignment than physical hardware could safely experience.

4.3 Perturb Throughout Relevant Dynamical States

The important idea is broader than perturbing at different timestamps inside a predefined motion.

Perturb throughout the distribution of dynamically relevant task states while the original objective remains active.

Useful states include single-leg support, weight transfer, touchdown, rapid rotation, target approach, contact preparation, recoil, partial falls, and recovery from a previous disturbance. The same shoulder impact can be trivial during double support and catastrophic a fraction of a second later during single support.

The controller therefore should not merely learn:

"If pushed left, step right."

It should learn something closer to:

"Given my current belief state, momentum, support conditions, incoming disturbance, target estimate, uncertainty, structural limits, and continuing objective, what action now produces the greatest expected future value?"

4.4 Randomize Ground and Embodiment

The same disturbance cannot be understood independently of the ground or the robot itself. Training should vary static and kinetic friction, per-foot friction, compliance, slope, local irregularity, and uncertain contact behavior. It should also vary body-link masses, center-of-mass offsets, actuator strength, damping, backlash, sensor bias, latency, battery-dependent torque, payload, and minor mechanical degradation.

For example:

left_foot_mu = 0.82
right_foot_mu = 0.31

Now apply a lateral torso disturbance during weight transfer. The resulting control problem is qualitatively different from the same impact on uniform high-friction ground.

The purpose is not to make physics arbitrary. It is to force the controller to survive the range of physics the real machine may actually encounter.

4.5 Compound Perturbations

Real failure chains rarely occur one variable at a time:

impact -> legs displaced -> camera rotation -> target occlusion -> secondary ground contact -> another impact

Training should therefore progress from individual disturbances to overlapping and sequential disturbances.

The critical test is simple:

Apply the next perturbation before the controller has necessarily completed recovery from the first.

There is no guaranteed reset window.

The environment owes the controller nothing.

4.6 Failure-Directed Training

Broad randomization becomes wasteful once large regions of the disturbance space are solved. Suppose the robot survives millions of ordinary pushes but still fails under a lateral torso impulse during right-foot liftoff on asymmetric low-friction ground. That region has substantially greater training value.

This paper uses the descriptive term Boundary-of-Competence Sampling for concentrating training near those remaining weak regions. The general method belongs to the broader family of adaptive curricula and hard-example mining; the PPCG-specific adaptation is what the adversary is asked to break.

Instead of merely maximizing fall probability, difficult-state generation can target continuity failure by increasing task-positive action latency, degrading target belief, forcing unnecessary visual reacquisition, reducing post-perturbation task progress, or creating repeated off-nominal states without causing a fall.

Find the continuity cliff. Train on the cliff. Move the cliff outward.

Historically difficult states can also be stored and replayed. Once a failure is solved, vary its force, friction, timing, target motion, or surrounding disturbances to search for the next neighboring weakness.

The training system becomes a scientist attacking its own model.

4.7 Privileged Training, Realistic Deployment

Simulation provides exact information the real robot may never receive directly: ground friction, applied force, perfect opponent pose, exact center of mass, and exact actuator state. That information can accelerate teacher training, but deployment should not depend on impossible sensors.

A teacher-student structure can allow the teacher to receive privileged simulation state while the student receives realistic cameras, IMU, encoders, force sensing, motor feedback, and temporal history.

The simulator knows exactly what happened.

The physical robot must infer what happened from the consequences.

That inference is part of the real task.

4.8 From Random Forces to Intelligent Opponents

A mathematical disturbance generator is an efficient early teacher, but not a complete opponent. A real opponent generates correlated behavior, changes timing, responds to the robot, creates strategic pressure, and may repeatedly exploit the same weakness.

A practical training progression is therefore: basic whole-body control; terrain and embodiment randomization; random disturbance generation; state-distributed disturbance with an active objective; moving-target and persistent-belief training; compound disturbances; scripted opponents; self-play and opponent populations; and finally constrained sim-to-real evaluation.

Physical randomization creates robustness to physics.

Opponent diversity creates robustness to intent.

5. Goal-Conditioned Robot-Specific Fighting Behavior

5.1 Do Not Teach Karate

Human martial arts are solutions to human biomechanics. They evolved around our skeletal geometry, muscles, tendon elasticity, vulnerable organs, pain, fatigue, reaction time, balance, and joint limits.

A humanoid robot may share the broad geometry of two arms, two legs, a torso, and a head while differing radically in the properties that made human martial arts useful.

Its vulnerable structures may also be completely different. A human protects the jaw, eyes, ribs, liver, knees, and brain. A robot may instead need to protect cameras, exposed wiring, gearboxes, high-value actuators, battery structures, computing modules, bearings, cable-routing regions, and mechanically fragile joints.

Therefore the robot's optimal defensive posture may look nothing like a boxing guard, and its optimal striking trajectory may look nothing like a human punch or kick.

The policy should be informed by its own vulnerability map, not ours.

Human motion priors can still help initialization or create behavior that is legible around people, but they should not define the mechanical optimum.

5.2 Train Against the Physical Goal, Not the Named Motion

Instead of:

"Perform kick number four."

the goal can be:

"Establish contact with this target region under the permitted physical envelope."

A target may be represented as:

target = {position, velocity, allowable_contact_region, contact_constraints}

The robot is not necessarily told which limb to use. It is not told whether the solution should resemble a kick, punch, shoulder strike, rotational contact, or some completely unfamiliar machine-specific action.

The optimizer searches over the available whole-body mechanics.

Prescribing a human motion too early may eliminate better robotic solutions from the search space before learning even begins.

5.3 "Hit as Hard as You Can Without Destroying Yourself"

Force-Maximization Training Under Self-Preservation Constraints

The important phrase is not only "Hit as hard as you can."

It is "without destroying yourself."

That second half defines the optimization boundary.

The goal is to discover how much useful force the robot can transmit from its current state without exceeding the physical limits that preserve its critical structures and future ability to operate.

The robot is not told to throw a punch or perform a roundhouse kick. It is told:

Generate the greatest permitted useful force at this target while preserving your critical structures and remaining capable of continued control.

Conceptually:

maximize useful_contact_impulse

subject to:

joint_load <= joint_limit
structural_stress <= structural_limit
critical_component_risk <= allowed_risk
self_collision <= permitted_limit
future_controllability >= minimum_required_value
contact_impulse <= competition_or_test_limit

A corresponding reward can include:

R = w_contact × useful_contact_value + w_continuity × post_contact_task_value + w_stability × recoverable_state_value - w_structure × structural_risk - w_critical × critical_component_risk - w_collision × self_collision - w_energy × unnecessary_energy

The objective does not require a human-looking strike.

Suppose Motion A resembles an excellent human roundhouse kick but transfers 700 units of permitted impulse and leaves a high-load hip actuator near its structural limit. Motion B looks completely unfamiliar, perhaps involving torso rotation, an unusual leg trajectory, and a different contact surface, but transfers 850 units while distributing reaction forces through stronger structures and leaving the robot controllable.

Motion B is the better robotic technique.

This requires a self-vulnerability model alongside the external target model. The robot needs to know not merely where it can make contact, but what parts of itself can safely transmit the resulting load and what components must be protected.

The safe physical envelope will therefore be robot-specific.

For ordinary training and competition, the rule is:

Maximize useful force transmission inside the machine's safe physical envelope, without prescribing how that force must be generated.

5.4 Redirect, Reuse, and Continue

Martial arts such as aikido and judo illustrate a useful physical principle: incoming momentum does not always need to be opposed directly. It can sometimes be redirected or incorporated into another useful movement.

The robot should not be taught aikido.

It should be allowed to rediscover the underlying physics.

Incoming force is not only damage or error. It is also a change in state, and sometimes that state contains useful energy.

Suppose a sweeping lateral strike removes the robot's lower-leg support. Its feet are displaced, its body begins rotating, and for a brief period it is partially airborne.

A conventional description might be:

hit -> fall -> recover

A continuous-objective controller sees a richer state. It knows approximately how the pelvis and limbs are rotating, its angular velocity, which joints remain controllable, the available contact surfaces, its vulnerability constraints, and the predicted location of the opponent.

Perhaps retracting one knee changes the moment of inertia and rotational speed. Perhaps another limb becomes aligned with an allowable target while the body is inverted. Perhaps the robot then contacts the floor with its forearms, redirects the remaining angular momentum through another rotation, and arrives in a useful support state without ever returning to neutral.

The sequence should not be programmed.

The optimizer decides whether the incoming momentum should be canceled, absorbed, redirected, or exploited.

Sometimes the correct answer is to stop the rotation and stabilize. Sometimes it is to redirect it. Sometimes it is to continue through it.

Recovery and action are not necessarily separate events. A perturbation can become the beginning of the next useful trajectory.

But that is only possible if the robot still knows where the relevant parts of the world are while its own body passes through an unfamiliar orientation.

That leads directly to persistent belief state.

6. Persistent Belief State: The Perception Half of Continuity

A robot cannot intelligently reuse an unexpected physical state if it simultaneously loses its estimate of the world.

Imagine the robot from the previous example rotating through the air. Its camera may point at the floor, then the ceiling, then sideways. The opponent may disappear from the current image entirely. Yet the controller may have only a few hundred milliseconds in which the disturbed state contains useful momentum.

If visual loss requires complete target reacquisition, that opportunity disappears.

The robot therefore needs continuity not only of objective but of belief.

A standard partially observable formulation is:

x_t = true physical and environmental state
o_t = current sensor observation
b_t = estimated belief about x_t
g_t = continuing objective
a_t = policy(b_t, g_t)

The observation updates the belief.

It does not replace it.

6.1 The Target Does Not Cease to Exist When the Camera Loses It

Suppose the robot knows the opponent's torso is approximately 1.2 meters away and moving laterally just before impact. The robot is then rotated and the opponent leaves its cameras.

The correct internal transition is not:

TARGET_EXISTS -> TARGET_UNKNOWN -> SEARCH

It is:

high-confidence target belief -> predicted target belief -> increasing uncertainty -> correction when visually reacquired

The IMU and joint-state estimator know that the robot's own orientation changed, so the previously estimated external state can be transformed into the changing egocentric coordinate frame.

Even while partially inverted, the controller can retain estimates of the opponent's pelvis, torso, head, velocity, and uncertainty.

The robot does not need to visually discover the opponent from nothing every time its own head turns.

6.2 Dynamic Body-Vector Graph

One interpretable implementation is a Dynamic Body-Vector Graph, or DBVG. For another humanoid, the graph might include the head, torso, shoulders, hands, pelvis, knees, feet, and estimated center of mass.

Each node can maintain:

node_i = {position, velocity, acceleration, orientation, uncertainty}

The fast controller can therefore receive a compact representation such as:

opponent_head = {predicted_relative_XYZ, velocity, uncertainty}

rather than repeatedly interpreting an entire raw image before every useful action.

Return to the example of the robot rotating through the air. The camera may temporarily see no opponent, but the DBVG or equivalent learned latent belief can still estimate where the opponent's head, torso, and center of mass are relative to the robot's rapidly changing orientation.

The controller can therefore evaluate whether any currently reachable trajectory intersects an allowable target region.

Without persistent belief, the disturbed state is largely chaos.

With persistent belief, it remains a control problem.

The DBVG is not claimed as the only or necessarily optimal representation. A learned latent state may ultimately outperform explicit landmarks. The deeper requirement is simply:

Task-relevant external state must persist through temporary observation loss.

6.3 Prediction and Uncertainty

Suppose the last observed target position is p_t, velocity is v_t, and acceleration estimate is a_t.

A simple prediction is:

p_predicted = p_t + v_t × delta_t + 0.5 × a_t × delta_t^2

A learned predictor can additionally use pose history, gait, interaction context, and physical constraints.

As time without observation increases:

uncertainty_t+delta > uncertainty_t

When observation returns:

new_observation -> belief correction -> uncertainty decreases

Thirty milliseconds of occlusion may leave the target estimate extremely useful. Two seconds may produce enough uncertainty that precise target-directed action is no longer rational.

The controller can then prioritize reacquisition.

Perception becomes continuous rather than binary.

6.4 Train Perception Failure Deliberately

The training environment should reproduce these conditions intentionally. Apply a physical disturbance while rotating the cameras away from the opponent, creating motion blur, dropping frames, occluding body landmarks, adding visual latency, changing target trajectory, or introducing another physical disturbance before full visual reacquisition.

Then ask:

Can the robot still act intelligently while its observation of the world is temporarily incomplete?

That is where physical continuity and perceptual continuity meet.

7. Persistent 3D Context, Sensors, and Latency

The fast target belief must exist inside a larger understanding of space. The robot still needs to know about the floor, nearby obstacles, boundaries, goals, other bodies, free space, and potential support surfaces.

A useful architecture therefore separates persistent local 3D context, which is richer and slower, from dynamic task-relevant belief, which is small and fast:

sensors -> persistent spatial belief -> dynamic target/self belief -> motor policy

Sparse voxel maps, occupancy representations, TSDFs, ESDFs, or learned spatial representations are all possible implementations. PPCG does not depend on any particular mapping technology.

7.1 Egocentric Coordinates and Sensor Fusion

The dynamic representation should generally be expressed relative to the robot's current body frame. If the robot rotates, the coordinate transform changes; the remembered object does not.

This is essential when the robot is sideways, partially inverted, or supported on its arms. Proprioception from the IMU, joint encoders, motor state, foot contacts, and force sensing estimates what happened to the robot itself. Exteroception from cameras and other external sensors estimates what happened in the environment.

Proprioception answers: What happened to me?

Exteroception answers: What happened around me?

The two must be fused. A camera may temporarily lose the opponent while the IMU still accurately tracks the robot's own rotation. That self-motion estimate is precisely what allows the external belief state to remain geometrically meaningful.

7.2 Candidate Vision Architecture

One practical baseline worth evaluating is wide-field global-shutter stereo vision combined with existing proprioception. Stereo provides useful geometric depth, while global shutter reduces distortion during rapid motion. Event vision may provide an additional low-latency motion channel during extremely fast limb movement or camera rotation.

These are engineering candidates rather than requirements of the framework.

The requirement is simply that the controller receive a persistent, sufficiently low-latency estimate of relevant state.

7.3 Different Parts of Reality Need Different Clock Speeds

The robot does not need to reconstruct everything at reflex frequency. A fast proprioceptive loop may update joint, IMU, torque, and contact state hundreds or thousands of times per second. A dynamic-object loop can track opponents, moving limbs, balls, and predicted contacts at the highest useful visual or predictive frequency. The larger world model can update static geometry and semantic context more slowly.

Update each part of reality at the rate at which it matters.

The robot does not need to reconstruct the universe at 1,000 Hz.

It needs to know what changed.

7.4 Latency Means the Robot Must Aim at the Future

Even perfect perception of the present may already be too old. Sensor exposure, readout, perception, inference, motor commands, actuator response, and actual movement all consume time.

The relevant target is therefore often not:

target_position_now

but:

target_position_when_action_arrives

Conceptually:

target_future = predict(target_belief, total_system_latency)

After a major perturbation, the controller is actually predicting two coupled systems: where the target will be and where its own body will be when a candidate action arrives.

The relevant calculation becomes relative future-state intersection:

contact_candidate = intersection(predicted_self_trajectory, predicted_target_trajectory, future_time)

subject to structural constraints, vulnerability constraints, uncertainty, and the active objective.

The robot is not aiming where the opponent was.

It is choosing a future body trajectory that intersects where the target is expected to be while remaining physically survivable itself.

8. Online Embodiment Adaptation and Self-Vulnerability

A physical robot changes over time. Battery voltage changes, motors heat, components wear, gearboxes develop backlash, payloads shift, and impacts may degrade actuators.

A controller assuming permanently fixed dynamics can therefore become progressively wrong.

One useful representation is:

body_state_latent

meaning, approximately:

"What kind of robot am I physically controlling right now?"

The controller can infer changes from discrepancies between commanded torque, expected movement, measured acceleration, recent joint response, contact behavior, and thermal or structural state.

A robot that has just been hit should not only estimate where it is and where the target is. It should also estimate:

Am I still capable of the same trajectories I was capable of five seconds ago?

The related self-vulnerability representation can describe protected components, allowable load by body region, high-value actuators, current thermal or damage state, safe load-transfer directions, and mechanically strong contact surfaces.

A reinforced forearm may be an acceptable temporary support surface. A camera assembly may require extreme protection. A particular hip actuator may tolerate sustained torque but not lateral shock.

Robot-specific fighting behavior should emerge from those actual mechanical facts.

There is no reason its defensive geometry should resemble ours.

9. Training Objective and Continuity Metrics

A general continuity-oriented reward might take the form:

Total Reward = + Task Progress + Target Accuracy + Permitted Contact Value + Dynamic Continuity + Stability + Future Controllability - Structural Stress - Unsafe Contact - Self Collision - Excess Energy - Joint Limit Violation - Unnecessary Reacquisition Delay

The critical addition is Dynamic Continuity: the controller receives value for producing useful task progress during and immediately after the disturbance rather than merely after it has returned to a familiar state.

Otherwise the optimizer may discover a safe universal policy:

freeze -> stabilize -> scan -> restart

A frozen robot may be stable.

It is not continuous.

For contact tasks, the value of an action should include both its immediate effect and what it leaves available afterward:

total_action_value = immediate_task_value + expected_future_controllability + expected_future_task_value - physical_risk

9.1 Task-Positive Action Latency

Let:

t_p = perturbation time
t_positive = first time after perturbation at which the robot resumes measurable positive task progress for a minimum dwell interval

Then:

T_positive = t_positive - t_p

A highly continuous controller may have T_positive close to zero even while visibly recovering.

9.2 Post-Perturbation Continuity Ratio

For tasks with a meaningful non-negative progress measure:

J_pert = cumulative task progress over fixed horizon H after perturbation
J_ref = mean cumulative task progress over matched unperturbed rollouts

Then:

PPCR = J_pert / max(epsilon, J_ref)

A value near 1 indicates little lost task progress. For tasks where reward can cross zero, an absolute measure can be used instead:

Continuity_Loss = J_ref - J_pert

9.3 Supporting Metrics

Additional measurements should include target-belief error during visibility and occlusion, explicit visual reacquisition cost, structural load, energy use, fall probability, and the Perturbation Survival Envelope: the region of disturbance space in which fall probability remains below threshold, task continuity remains above threshold, and structural constraints remain satisfied.

Training should expand that envelope.

10. PPCG Benchmark and the Decisive Experiment

A useful benchmark should not merely ask whether the robot falls. It should ask whether the robot continues.

Tests can include neutral pushes; disturbances during active target pursuit; randomized and asymmetric friction; moving targets during recovery; visual occlusion and frame dropout; camera displacement; compound and repeated disturbances; latency shifts; actuator degradation; withheld opponent behaviors; perturbations that create potentially useful momentum; and temporary visual loss while the robot is rotated or partially inverted.

The most important experiment, however, is deliberately simple.

Train two controllers using the same embodiment, observation space, perturbation distribution, compute budget, underlying task, and ideally the same architecture.

Controller A: Recovery-Oriented. After perturbation, strongly reward stabilization and return toward a nominal recoverable regime.

Controller B: Continuity-Oriented. Keep the original task behaviorally active throughout the disturbance. Reward stability, but also explicitly reward retained task progress and low continuity loss during the recovery interval.

Compare fall rate, recovery time, T_positive, PPCR or Continuity Loss, target-belief error, reacquisition cost, task success, energy use, structural load, momentum utilization, and future controllability.

If Controller B produces no improvement in retained task value, the central thesis is weakened.

If it preserves substantially more useful behavior without unacceptable safety cost, then PPCG has been demonstrated as a meaningful training distinction.

That experiment is more important than whether any particular camera, world model, or neural architecture succeeds.

11. Proposed Experimental Program

A practical implementation should begin with a relatively small humanoid in high-throughput simulation and add complexity incrementally:

1. Establish a normal target-directed locomotion and tracking baseline.

2. Add ordinary perturbation randomization and measure mechanical robustness.

3. Perturb throughout task-relevant states while preserving the original task.

4. Introduce the continuity-oriented reward under otherwise matched conditions.

5. Add randomized and asymmetric ground conditions.

6. Add persistent target belief and controlled post-impact occlusion.

7. Add uncertainty-aware prediction and latency randomization.

8. Add self-vulnerability constraints and unconstrained physical contact objectives.

9. Test whether the policy learns to reuse useful disturbance momentum.

10. Add failure-directed sampling and compare it against broad randomization.

11. Introduce scripted opponents, then self-play and opponent populations.

12. Begin sim-to-real transfer at low contact energies under strict hardware supervision.

The important principle is experimental isolation. If everything is added simultaneously, a successful final robot tells us very little about why it succeeded.

12. Emergent Motion, Simulator Exploits, and Safety

Reinforcement learning may generate behavior that looks strange because its optimization target differs from human aesthetics.

That can be a feature.

If a stance looks absurd but increases stability, reduces actuator stress, improves reachability, preserves future control, and remains inside safety constraints, it should be investigated before being "corrected." Human motion priors remain useful when legibility, social acceptance, or human compatibility matter, but excessive imitation can erase genuine mechanical discovery.

We should allow some ugliness.

A robot should not lose reward merely because an effective movement has no human martial-art name.

But strange does not automatically mean brilliant. A strange policy may instead be exploiting unrealistic friction, geometry penetration, numerical instability, impossible actuator bandwidth, bad restitution, inaccurate compliance, or missing structural flex.

Unusual behaviors should therefore be validated using smaller simulation time steps, altered contact models, alternative physics engines where practical, realistic actuator limits, structural-load monitoring, and eventually instrumented low-energy hardware testing.

A behavior becomes scientifically interesting when its advantage survives increasingly realistic physics.

Otherwise we are not discovering new robotics.

We are discovering bugs.

Hard safety constraints should remain outside the learned reward itself: maximum joint torque and velocity, thermal limits, structural-load limits, allowed contact impulse, protected regions, self-collision prevention, supervisory shutdown, and emergency stop.

The learned policy operates inside that envelope.

The goal is not unlimited collision energy.

The goal is robust embodied control under physical uncertainty.

13. Beyond Fighting

Robot fighting makes PPCG easy to see because disturbances are frequent, adversarial, and visually obvious. It is not the most important eventual application.

Imagine a warehouse humanoid carrying a box when another machine bumps it and one foot slips. A posture-centric controller may preserve the robot while losing the payload. A task-continuous controller asks:

"What trajectory gives me the greatest probability of preserving both the robot and the box?"

The same problem appears when a home robot carries a tray, a rescue robot is struck by debris, a maintenance tool catches unexpectedly, a payload shifts, a factory robot encounters loose flooring, or a humanoid temporarily loses sight of its destination because its body rotates.

A robot carrying something fragile may deliberately accept an ugly body posture because that posture preserves the object. A rescue robot may roll instead of fighting to remain upright if rolling protects critical components and creates a better support state. A slipping foot may become a step instead of a failure.

These are all instances of the same principle:

Unexpected state change should not automatically sever the objective from the controller.

Robot sport is simply a brutal laboratory in which this principle becomes easy to observe.

14. Open Questions

Several major questions remain empirical. An explicit DBVG may prove useful, or learned latent belief may ultimately outperform manually chosen body landmarks. The fast controller may require only a small slice of the larger 3D map, but the correct amount remains unknown. Stereo may be sufficient for external geometry, or event vision, radar, time-of-flight, tactile sensing, or another combination may provide better latency and robustness.

Prediction horizon is similarly uncertain. A 50-millisecond estimate may matter for one action while a 500-millisecond distribution matters for another. Several time horizons may need to coexist. Uncertainty itself should probably alter behavior, but precisely how confidence should trade against aggressive action remains a learning problem.

High-energy contact simulation may become the dominant sim-to-real limitation. Torque limits do not capture cumulative impact fatigue, gearbox damage, frame flex, cable stress, or repeated subcritical loading. The self-vulnerability model may therefore need to become far richer than a simple protected-region mask.

The control hierarchy is also unresolved. One universal policy may eventually outperform manually separated systems, or a fast low-level controller combined with a slower goal-conditioned policy may remain superior.

Failure-directed training must also avoid becoming too narrow. If it concentrates excessively on known weaknesses, the policy may overfit its historical failure surface and lose general robustness. Broad randomization should probably remain mixed with targeted hard-state sampling.

Finally, "never reset the objective" is not absolute. Some states should terminate because continuing would violate safety or because the original objective is no longer physically meaningful.

And perhaps the most interesting open question is this:

If the optimizer is freed from human motion priors while constrained by accurate physics and the robot's actual vulnerabilities, what does an optimal humanoid movement vocabulary look like?

That is an experiment.

15. Conclusion: Train the Space Between Competence

Robotics demonstrations naturally highlight visible units of competence: the kick, the jump, the sprint, the backflip, the grasp.

Autonomous systems spend enormous portions of their existence elsewhere: between walking and turning, between grasping and carrying, between stability and disturbance, between seeing something and temporarily losing it, and between expectation and reality.

A robot may possess excellent individual skills and still behave poorly because the transitions between them remain brittle.

That transition space deserves direct training.

I began with a simple observation while watching the World Humanoid Robot Games in Beijing. The robot knew how to kick. It knew how to walk. It knew how to balance. Yet after an unexpected impact, there could be a moment where the body remained functional but useful behavior became disconnected.

The body recovered.

Then the task resumed.

That interval is what this paper attempts to attack.

The proposed solution is not one algorithm. It is a training and evaluation philosophy.

Perturb the robot during training. Perturb it in different physical states. Change force, direction, duration, contact location, surface, latency, and embodiment dynamics. Move the target during recovery. Temporarily hide it. Apply another disturbance before the first one is over.

But do not automatically give the robot the courtesy of returning to neutral.

Do not automatically remove the task from the control problem.

Make it continue.

Maintain external state as a persistent belief rather than an ephemeral image. Predict through temporary observation loss. Keep uncertainty explicit. Let the controller reason from the body state it actually occupies rather than the one the movement designer hoped it would occupy.

Do not assume mechanically optimal humanoid fighting should resemble ours. Do not tell the robot that a block must look like a block or a kick must look like a kick. Give it the physical target, its own vulnerability map, the safety envelope, and the objective.

Let it solve the mechanics.

Tell it, in effect:

Hit as hard as you can without destroying yourself.

Not because force without constraint is intelligent, but because the phrase defines the correct physical search: maximize useful force while preserving the machine and its future ability to continue.

And when the environment supplies the energy, do not automatically throw it away. A strike that rotates the robot is a disturbance, but it is also angular momentum. A swept leg destroys the previous support state, but it may create another reachable trajectory. A falling body is not necessarily a body without options.

If the robot still knows where it is, still knows where the target is, still understands what parts of itself are vulnerable, and still carries the same objective, then the disturbed state remains part of the problem rather than the end of it.

When broad perturbations become easy, attack the remaining continuity failures. When a strange solution appears, determine whether it is physics or a simulator bug. When simulation becomes robust, move carefully onto real hardware.

This paper does not claim that push recovery, belief states, adversarial training, self-play, goal-conditioned control, or task continuation after recovery are individually new.

Its proposed contribution is narrower:

Train and measure whether the objective remains behaviorally alive while the robot is being physically and perceptually displaced from its expected state.

Competence should not be measured only by whether a system can execute a skill from the state in which we intended that skill to begin. It should also be measured by how much of the objective remains recoverable from the states reality actually produces.

The real world will never give the robot exactly the state distribution we designed. Something will slip. Something will collide. Something will move unexpectedly. A camera will lose sight of something. An actuator will behave differently from the simulator.

The measure of robustness is not simply whether the machine eventually gets back to normal.

It is what the machine can still accomplish before normal ever returns.

In that sense, the most interesting training space may not be the space of perfect actions.

It may be the space between competence and competence.

An unexpected physical state is not automatically a reason to stop thinking.

The robot should not experience:

movement -> disturbance -> recovery -> reacquisition -> movement

as separate conceptual worlds.

It should experience:

state -> state -> state -> state

with one constrained objective flowing through them.

The goal is not merely to build a robot that knows how to recover.

The goal is to build a robot for which recovery is simply another moment of continuous action.

References

1. Beijing Municipal Government. Coverage and official information concerning the 2026 World Humanoid Robot Games.

2. Reuters. Coverage of the 2026 World Humanoid Robot Games and the physical and autonomous performance of participating humanoids.

3. Haarnoja, Tuomas, et al. "Learning Agile Soccer Skills for a Bipedal Robot with Deep Reinforcement Learning." Science Robotics, 2024.

4. Ferigo, Diego, et al. "On the Emergence of Whole-body Strategies from Humanoid Robot Push-recovery Learning." IEEE Robotics and Automation Letters, 2021.

5. Kumar, Ashish, Zipeng Fu, Deepak Pathak, and Jitendra Malik. "RMA: Rapid Motor Adaptation for Legged Robots." Robotics: Science and Systems, 2021.

6. OpenAI et al. "Solving Rubik's Cube with a Robot Hand." 2019.

7. Wang, Yushi, et al. "Learning Vision-Driven Reactive Soccer Skills for Humanoid Robots." 2025.

8. NVIDIA. "Isaac ROS nvblox Technical Details."

9. Sony / Prophesee. "IMX636 Event-Based Vision Sensor Product Brief."

10. Zhu, Xiang, Shucheng Kang, and Jianyu Chen. "A Contact-Safe Reinforcement Learning Framework for Contact-Rich Robot Manipulation." 2022.

11. Su, Zhi, et al. "Toward Real-World Cooperative and Competitive Soccer with Quadrupedal Robot Teams." 2025.

12. Adiwahono, Albertus Hendrawan, Chee-Meng Chew, and Bingbing Liu. "Push Recovery Through Walking Phase Modification for Bipedal Locomotion." International Journal of Humanoid Robotics, 2013.

13. Zhang, Yang, et al. "Keep On Going: Learning Robust Humanoid Motion Skills via Selective Adversarial Training." Proceedings of the AAAI Conference on Artificial Intelligence, 2026.

14. Yang, Lizhi, et al. "HANDOFF: Humanoid Agentic Task-Space Whole-Body Control via Distilled Complementary Teachers." 2026.

15. "Research on Robot Collision Response Based on Human-Robot Collaboration."Sensors, 2026.

Proposed Terms Used in This Gray Paper

Post-Perturbation Continuity Gap, PPCG: Loss of task-directed performance caused by an unexpected physical state transition beyond the question of whether mechanical balance is eventually restored.

Post-Perturbation Continuity, PPC: The degree to which useful goal-directed behavior survives a disturbance and its immediate recovery interval.

Post-Perturbation Continuity Ratio, PPCR: A normalized comparison between task progress after disturbance and task progress in a matched unperturbed reference window.

Task-Positive Action Latency, T_positive: The delay from perturbation until measurable positive task progress resumes.

Dynamic Body-Vector Graph, DBVG: A proposed interpretable sparse representation of task-relevant dynamic body points containing position, motion, orientation where useful, and uncertainty. It is one candidate implementation of persistent task-relevant belief state rather than a required component of PPCG.

Self-Vulnerability Model: A representation of robot-specific mechanical fragility, protected components, load-transfer capacity, and safe contact regions used to constrain whole-body physical behavior.

Boundary-of-Competence Sampling: A descriptive curriculum strategy that allocates more training toward disturbance regions where continuity remains fragile. It is not claimed as a new class of adversarial or hard-example training.

Task-Continuous Recovery: Recovery evaluated according to retained task value rather than return to canonical posture alone.

Continuous Objective Control: A control framing in which attack, defense, locomotion, and recovery need not correspond to separate low-level states. The active objective remains conditioned on current belief state and safety constraints as the physical situation changes.

TL;DR

A humanoid should not merely be trained to recover and then resume its task; it should be trained to preserve as much of the task as possible through the recovery itself.

<kg-llm-seed-map version="1.0">

  <metadata>
    <title>The Post-Perturbation Continuity Gap</title>
    <subtitle>
      Training Humanoid Robots to Preserve Perception, Intent, and Whole-Body Control
      Through Unexpected Physical Disturbance
    </subtitle>
    <document_type>Gray Paper Knowledge Graph Seed Map</document_type>
    <authors>
      <author>Cameron Tavassoli</author>
      <author>ChatGPT, GPT-5.6 Sol</author>
    </authors>
    <date>August 2026</date>
    <domain>Humanoid Robotics</domain>
    <subdomains>
      <subdomain>Reinforcement Learning</subdomain>
      <subdomain>Whole-Body Control</subdomain>
      <subdomain>Push Recovery</subdomain>
      <subdomain>Persistent Perception</subdomain>
      <subdomain>Belief-State Estimation</subdomain>
      <subdomain>Robot Combat Research</subdomain>
      <subdomain>Sim-to-Real</subdomain>
      <subdomain>Adversarial Training</subdomain>
      <subdomain>Embodied Intelligence</subdomain>
    </subdomains>
  </metadata>


  <paper_identity>

    <core_problem id="PPCG">
      <name>Post-Perturbation Continuity Gap</name>

      <definition>
        The loss or degradation of goal-directed behavior following an unexpected
        physical state transition, relative to the useful task performance the robot
        could otherwise have produced over the same interval.
      </definition>

      <central_observation>
        A humanoid robot may remain mechanically capable of continuing its task after
        an impact while temporarily losing perceptual continuity, task continuity, or both.
      </central_observation>

      <central_thesis>
        A humanoid should not merely be trained to recover and then resume its task;
        it should be trained to preserve as much of the task as possible through the
        recovery itself.
      </central_thesis>

      <compressed_thesis>
        Unexpected physical state change should not imply cognitive or task reset.
      </compressed_thesis>

      <control_principle>
        The perturbation changes the state. It does not automatically cancel the objective.
      </control_principle>
    </core_problem>


    <traditional_sequence>
      action
      -> perturbation
      -> recovery
      -> reacquisition
      -> task resumes
    </traditional_sequence>

    <proposed_sequence>
      action
      -> perturbation
      -> updated physical and perceptual belief state
      -> continued objective optimization
    </proposed_sequence>

  </paper_identity>


  <origin_of_hypothesis>

    <observation_context>
      <event>2026 World Humanoid Robot Games in Beijing</event>

      <observed_behavior>
        Robots increasingly demonstrate competent isolated behaviors including locomotion,
        kicking, turning, balance recovery, object tracking, soccer, and martial-arts-like
        interaction.
      </observed_behavior>

      <observed_failure_pattern>
        After unexpected impact or body displacement, a robot may remain operational yet
        exhibit a temporary dead zone before meaningful task-directed behavior resumes.
      </observed_failure_pattern>

      <examples>
        <example>Robot receives a lateral hit and rotates away from target.</example>
        <example>Foot lands differently than expected.</example>
        <example>Opponent moves during recovery.</example>
        <example>Robot slips during an active maneuver.</example>
        <example>Camera orientation changes suddenly because the body rotates.</example>
      </examples>

      <inference>
        The failure may exist not inside a trained motion but in the state space between
        useful motions.
      </inference>
    </observation_context>

  </origin_of_hypothesis>


  <novelty_boundary>

    <not_claimed_as_new>
      <item>Humanoid push recovery</item>
      <item>Reinforcement-learning-based recovery</item>
      <item>Domain randomization</item>
      <item>Pushes at different walking phases</item>
      <item>Whole-body locomotion policies</item>
      <item>Goal-conditioned control</item>
      <item>POMDP and belief-state estimation</item>
      <item>Persistent 3D mapping</item>
      <item>Self-play</item>
      <item>Adversarial curriculum generation</item>
      <item>Hard-example mining</item>
      <item>Rapid motor adaptation</item>
      <item>Task continuation after fall recovery</item>
      <item>Event-based vision</item>
      <item>Safe contact reinforcement learning</item>
    </not_claimed_as_new>


    <proposed_contribution>

      <contribution id="C1">
        <name>Continuity-Oriented Recovery Objective</name>
        <description>
          Treat retained task value during and immediately after disturbance as a
          first-class training and evaluation objective rather than measuring recovery
          primarily by restored posture.
        </description>
      </contribution>

      <contribution id="C2">
        <name>State-Distributed Perturbation With Objective Persistence</name>
        <description>
          Apply physical perturbations across dynamically relevant task states while
          leaving the original objective behaviorally active.
        </description>
      </contribution>

      <contribution id="C3">
        <name>Coupled Physical and Perceptual Continuity</name>
        <description>
          Maintain task-relevant external belief through temporary visual loss so that
          disturbed physical states remain actionable.
        </description>
      </contribution>

    </proposed_contribution>


    <novelty_summary>
      The proposed contribution is not a new isolated recovery algorithm. It is a
      framework that treats the perturbation-to-continuation interval itself as the
      object to optimize, train, and measure.
    </novelty_summary>

  </novelty_boundary>


  <recovery_taxonomy>

    <recovery_type id="mechanical_recovery">
      <name>Mechanical Recovery</name>
      <questions>
        <question>Can the robot avoid falling?</question>
        <question>Can the robot restore support?</question>
        <question>Can the robot remain physically operational?</question>
      </questions>
    </recovery_type>

    <recovery_type id="perceptual_continuity">
      <name>Perceptual Continuity</name>
      <questions>
        <question>Does the robot still know where task-relevant entities are?</question>
        <question>Can it maintain target state through temporary observation loss?</question>
      </questions>
    </recovery_type>

    <recovery_type id="task_continuity">
      <name>Task Continuity</name>
      <questions>
        <question>Does the controller continue advancing the active objective?</question>
        <question>Can useful action occur before canonical recovery is complete?</question>
      </questions>
    </recovery_type>

    <key_relation>
      Mechanical recovery does not imply perceptual continuity.
      Mechanical recovery does not imply task continuity.
    </key_relation>

  </recovery_taxonomy>


  <control_framework>

    <state_representation>

      <principle>
        The controller should reason from current estimated dynamical state rather than
        from the name or expected completion state of a predefined movement.
      </principle>

      <core_equation>
        action_t = policy(belief_state_t, goal_t)
      </core_equation>

      <next_step_equation>
        action_t+1 = policy(belief_state_t+1, goal_t+1)
      </next_step_equation>

      <belief_state_components>

        <self_state>
          <component>Joint positions</component>
          <component>Joint velocities</component>
          <component>IMU orientation</component>
          <component>Linear velocity</component>
          <component>Angular velocity</component>
          <component>Estimated momentum</component>
          <component>Foot contact</component>
          <component>Force distribution</component>
          <component>Actuator saturation</component>
          <component>Thermal state</component>
          <component>Recent impulse history</component>
          <component>Slip history</component>
        </self_state>

        <external_state>
          <component>Target location</component>
          <component>Target velocity</component>
          <component>Target acceleration estimate</component>
          <component>Opponent body geometry</component>
          <component>Obstacles</component>
          <component>Support surfaces</component>
          <component>Uncertainty</component>
        </external_state>

        <goal_state>
          <component>Current active objective</component>
          <component>Task constraints</component>
          <component>Safety constraints</component>
          <component>Permitted contact regions</component>
        </goal_state>

      </belief_state_components>

    </state_representation>


    <valid_continuation_state_principle>
      Any relevant, nonterminal physical state inside the intended deployment envelope
      should be treated as a valid continuation state.
    </valid_continuation_state_principle>

    <training_priority>
      training_priority =
      relevance
      * consequence
      * current_failure_probability
      * novelty
    </training_priority>

    <note>
      This expression is conceptual. An implementation does not need to multiply these
      factors literally.
    </note>

  </control_framework>


  <perturbation_training>

    <core_principle>
      Train the robot in the dynamically awkward states that reality actually creates.
    </core_principle>


    <disturbance_generator>

      <representation>
        D = {
          body_link,
          contact_point,
          force_direction,
          F(t),
          duration,
          state_context,
          surface_state,
          latency,
          robot_parameters,
          ...
        }
      </representation>

      <variables>

        <variable name="body_link">
          Affected robot body segment.
        </variable>

        <variable name="contact_point">
          Local location of physical force application.
        </variable>

        <variable name="force_direction">
          Direction of applied external force.
        </variable>

        <variable name="F(t)">
          Force magnitude as a function of time.
        </variable>

        <variable name="duration">
          Contact duration.
        </variable>

        <variable name="state_context">
          Robot dynamical state when perturbation occurs.
        </variable>

        <variable name="surface_state">
          Friction, slope, compliance, contact geometry.
        </variable>

        <variable name="latency">
          Sensor, computation, and actuator delay.
        </variable>

        <variable name="robot_parameters">
          Mass, actuator strength, damping, backlash, alignment, payload, etc.
        </variable>

      </variables>


      <physics>

        <impulse>
          J = integral of F(t) over contact duration
        </impulse>

        <torque>
          torque = r cross F
        </torque>

      </physics>


      <purpose>
        The receiving robot does not initially require a fully animated intelligent
        opponent to learn the mechanical consequences of contact.
      </purpose>

      <abstraction>
        Opponent strategy can be added later. Early-stage robustness can be trained by
        abstracting contact into physical disturbances.
      </abstraction>

    </disturbance_generator>


    <continuous_sampling>

      <principle>
        Do not enumerate every possible combination of forces, directions, contact points,
        timings, surfaces, and robot states.
      </principle>

      <sampling_examples>
        <sample>contact_point ~ body-surface distribution</sample>
        <sample>force_direction ~ directional distribution</sample>
        <sample>peak_force ~ bounded force distribution</sample>
        <sample>contact_duration ~ bounded duration distribution</sample>
        <sample>surface_friction ~ friction distribution</sample>
        <sample>sensor_delay ~ latency distribution</sample>
        <sample>actuator_scale ~ dynamics distribution</sample>
      </sampling_examples>

      <summary>
        Sample the physical manifold rather than attempting to enumerate the universe.
      </summary>

    </continuous_sampling>


    <state_distributed_perturbation>

      <principle>
        Perturb throughout the distribution of dynamically relevant task states while
        leaving the original objective active.
      </principle>

      <valuable_states>
        <state>Double support</state>
        <state>Single-leg support</state>
        <state>Weight transfer</state>
        <state>Foot touchdown</state>
        <state>Foot liftoff</state>
        <state>Rapid yaw rotation</state>
        <state>Target approach</state>
        <state>Contact preparation</state>
        <state>Post-contact recoil</state>
        <state>Partial fall</state>
        <state>Recovery from previous perturbation</state>
      </valuable_states>

      <important_distinction>
        The same external force can produce radically different outcomes depending on
        current body state.
      </important_distinction>

    </state_distributed_perturbation>


    <ground_randomization>

      <parameters>
        <parameter>Static friction</parameter>
        <parameter>Kinetic friction</parameter>
        <parameter>Independent left-foot friction</parameter>
        <parameter>Independent right-foot friction</parameter>
        <parameter>Local friction changes</parameter>
        <parameter>Surface compliance</parameter>
        <parameter>Slope</parameter>
        <parameter>Unevenness</parameter>
        <parameter>Deformability</parameter>
        <parameter>Contact model uncertainty</parameter>
      </parameters>

      <example>
        left_foot_mu = 0.82
        right_foot_mu = 0.31
      </example>

      <principle>
        Terrain properties should be treated as latent dynamics the controller may need
        to infer rather than as constants the engineer is allowed to assume.
      </principle>

    </ground_randomization>


    <embodiment_randomization>

      <parameters>
        <parameter>Body-link mass</parameter>
        <parameter>Center-of-mass offsets</parameter>
        <parameter>Motor strength</parameter>
        <parameter>Joint damping</parameter>
        <parameter>Joint friction</parameter>
        <parameter>Gear backlash</parameter>
        <parameter>Sensor noise</parameter>
        <parameter>Encoder bias</parameter>
        <parameter>IMU alignment error</parameter>
        <parameter>Observation latency</parameter>
        <parameter>Actuator latency</parameter>
        <parameter>Battery-related torque variation</parameter>
        <parameter>Thermal performance change</parameter>
        <parameter>Payload</parameter>
        <parameter>Wear</parameter>
      </parameters>

      <constraint>
        Domain randomization should represent plausible deployment variability rather
        than making physics arbitrarily chaotic.
      </constraint>

    </embodiment_randomization>


    <compound_perturbation>

      <example>
        impact
        -> legs displaced
        -> camera rotation
        -> target occlusion
        -> secondary ground contact
        -> second impact
      </example>

      <critical_training_case>
        Apply the next perturbation before the controller has necessarily completed
        recovery from the first.
      </critical_training_case>

      <principle>
        There is no guaranteed reset window.
      </principle>

      <phrase>
        The environment owes the controller nothing.
      </phrase>

    </compound_perturbation>

  </perturbation_training>


  <boundary_of_competence>

    <name>Boundary-of-Competence Sampling</name>

    <definition>
      A descriptive curriculum strategy that concentrates new training around regions
      where continuity remains fragile.
    </definition>

    <novelty_note>
      Adaptive curriculum learning, hard-example mining, and adversarial environment
      generation already exist. The PPCG-specific contribution is the continuity failure
      objective used to define which states are valuable.
    </novelty_note>

    <failure_targets>
      <target>Fall probability</target>
      <target>Task-positive action latency</target>
      <target>Target belief degradation</target>
      <target>Unnecessary reacquisition</target>
      <target>Loss of post-perturbation task progress</target>
      <target>Loss of future controllability</target>
    </failure_targets>

    <process>
      <step>Generate broad perturbation distribution.</step>
      <step>Train policy.</step>
      <step>Record failures and near-failures.</step>
      <step>Estimate continuity failure regions.</step>
      <step>Increase sampling density near those regions.</step>
      <step>Generate nearby variants.</step>
      <step>Continue until fragile region becomes robust.</step>
      <step>Repeat.</step>
    </process>

    <summary>
      Find the continuity cliff.
      Train on the cliff.
      Move the cliff outward.
    </summary>

  </boundary_of_competence>


  <failure_directed_replay>

    <stored_events>
      <event>Fall</event>
      <event>Near-fall</event>
      <event>Target loss</event>
      <event>Severe continuity loss</event>
      <event>Actuator saturation</event>
      <event>Structural-limit approach</event>
      <event>Extreme visual reacquisition delay</event>
    </stored_events>

    <replay_strategy>
      Restart simulation near historically difficult states and vary force, friction,
      timing, contact point, target motion, or subsequent disturbances.
    </replay_strategy>

    <principle>
      Rare failures should become abundant training data.
    </principle>

  </failure_directed_replay>


  <goal_conditioned_robot_motion>

    <human_motion_prior>

      <principle>
        Human martial arts are optimized around human biomechanics and vulnerabilities.
      </principle>

      <human_constraints>
        <constraint>Muscle physiology</constraint>
        <constraint>Tendon elasticity</constraint>
        <constraint>Human joint geometry</constraint>
        <constraint>Pain</constraint>
        <constraint>Fatigue</constraint>
        <constraint>Human reaction time</constraint>
        <constraint>Human balance</constraint>
        <constraint>Human vulnerable organs</constraint>
      </human_constraints>

      <robot_difference>
        A humanoid robot may share human topology while possessing radically different
        actuator geometry, strength, mass distribution, vulnerability, joint constraints,
        and safe load paths.
      </robot_difference>

      <conclusion>
        Robot-optimal movement should not be assumed to resemble human martial arts.
      </conclusion>

    </human_motion_prior>


    <physical_goal>

      <human_authored_command>
        Perform kick number four.
      </human_authored_command>

      <preferred_goal>
        Establish permitted contact with this target region under the allowed physical
        envelope.
      </preferred_goal>

      <target_representation>
        target = {
          position,
          velocity,
          allowable_contact_region,
          contact_constraints
        }
      </target_representation>

      <policy_freedom>
        The policy may discover a punch, kick, shoulder strike, rotational strike,
        grounded pivot, unusual machine-native trajectory, or another mechanically
        valid solution.
      </policy_freedom>

    </physical_goal>

  </goal_conditioned_robot_motion>


  <force_maximization>

    <section_name>Hit as Hard as You Can Without Destroying Yourself</section_name>

    <core_interpretation>
      This is force-maximization training under self-preservation constraints.
    </core_interpretation>

    <important_phrase>
      Without destroying yourself defines the force envelope.
    </important_phrase>

    <objective>
      Maximize useful force transmission without prescribing a human movement used to
      generate that force.
    </objective>

    <optimization>
      maximize useful_contact_impulse
    </optimization>

    <constraints>
      <constraint>joint_load <= joint_limit</constraint>
      <constraint>structural_stress <= structural_limit</constraint>
      <constraint>critical_component_risk <= allowed_risk</constraint>
      <constraint>self_collision <= permitted_limit</constraint>
      <constraint>future_controllability >= minimum_required_value</constraint>
      <constraint>contact_impulse <= competition_or_test_limit</constraint>
    </constraints>

    <conceptual_reward>
      R =
      + w_contact * useful_contact_value
      + w_continuity * post_contact_task_value
      + w_stability * recoverable_state_value
      - w_structure * structural_risk
      - w_critical * critical_component_risk
      - w_collision * self_collision
      - w_energy * unnecessary_energy
    </conceptual_reward>

    <future_state_value>
      effective_action_value =
      immediate_contact_value
      + post_contact_future_value
    </future_state_value>

    <principle>
      A slightly weaker immediate strike may have greater total value if it leaves the
      robot structurally healthy and better positioned for the next action.
    </principle>

  </force_maximization>


  <self_vulnerability_model>

    <name>Self-Vulnerability Model</name>

    <definition>
      A representation of robot-specific mechanical fragility, protected components,
      load-transfer capacity, and safe contact regions.
    </definition>

    <possible_sensitive_regions>
      <region>Cameras</region>
      <region>Optical assemblies</region>
      <region>Exposed wiring</region>
      <region>Gearboxes</region>
      <region>High-value actuators</region>
      <region>Battery structures</region>
      <region>Compute modules</region>
      <region>High-load bearings</region>
      <region>Cable routing regions</region>
      <region>Structurally fragile joints</region>
    </possible_sensitive_regions>

    <possible_robust_regions>
      <region>Reinforced forearms</region>
      <region>Load-bearing frame members</region>
      <region>Protected structural contact surfaces</region>
    </possible_robust_regions>

    <relation_to_motion>
      The vulnerability map influences attack, defense, temporary support contacts, force
      transmission, and acceptable recovery trajectories.
    </relation_to_motion>

    <conclusion>
      Robot-specific defensive geometry should emerge from the machine's actual anatomy
      rather than human anatomical assumptions.
    </conclusion>

  </self_vulnerability_model>


  <momentum_reuse>

    <name>Redirect, Reuse, and Continue</name>

    <inspiration>
      Aikido and judo illustrate the general physical principle of redirecting or
      incorporating incoming momentum rather than always opposing it directly.
    </inspiration>

    <important_distinction>
      The robot should not be trained to imitate aikido or judo techniques.
    </important_distinction>

    <physical_principle>
      Incoming force is not only damage or error.
      It is also a change in state, and sometimes that state contains useful energy.
    </physical_principle>

    <possible_policy_choices>
      <choice>Cancel momentum</choice>
      <choice>Absorb momentum</choice>
      <choice>Redirect momentum</choice>
      <choice>Exploit momentum</choice>
    </possible_policy_choices>

    <example_scenario>

      <initial_event>
        Opponent delivers sweeping lateral impact to robot's lower legs.
      </initial_event>

      <new_state>
        Robot loses conventional footing and begins rotating while partially airborne.
      </new_state>

      <available_information>
        <item>Pelvis orientation</item>
        <item>Limb state</item>
        <item>Angular velocity</item>
        <item>Linear velocity</item>
        <item>Available actuators</item>
        <item>Available temporary support surfaces</item>
        <item>Self-vulnerability constraints</item>
        <item>Persistent opponent belief</item>
      </available_information>

      <possible_emergent_continuation>
        Robot retracts one knee to alter rotational inertia, extends another limb toward
        an allowable target region, contacts the ground using a reinforced hand or
        forearm as a temporary pivot, redirects remaining angular momentum, and reaches
        another useful fighting state without returning to neutral.
      </possible_emergent_continuation>

    </example_scenario>

    <key_conclusion>
      Recovery and action are not necessarily separate events.
    </key_conclusion>

    <key_conclusion_2>
      A perturbation can become the beginning of the next useful trajectory.
    </key_conclusion_2>

  </momentum_reuse>


  <persistent_belief_state>

    <core_problem>
      Physical perturbation frequently disrupts perception precisely when rapid control
      decisions matter most.
    </core_problem>

    <formalism>

      <state>x_t = true physical and environmental state</state>
      <observation>o_t = current sensor observation</observation>
      <belief>b_t = estimated belief about x_t</belief>
      <goal>g_t = continuing objective</goal>

      <policy>
        a_t = policy(b_t, g_t)
      </policy>

    </formalism>

    <principle>
      Observation updates belief. Observation does not replace belief.
    </principle>


    <temporary_target_loss>

      <incorrect_transition>
        TARGET_EXISTS
        -> TARGET_UNKNOWN
        -> SEARCH
      </incorrect_transition>

      <preferred_transition>
        high-confidence target belief
        -> predicted target belief
        -> increasing uncertainty
        -> visual correction when reacquired
      </preferred_transition>

      <summary>
        The target briefly leaving the camera should increase uncertainty.
        It should not produce amnesia.
      </summary>

    </temporary_target_loss>

  </persistent_belief_state>


  <dynamic_body_vector_graph>

    <name>Dynamic Body-Vector Graph</name>
    <abbreviation>DBVG</abbreviation>

    <status>
      Proposed interpretable implementation candidate, not a required component of PPCG.
    </status>

    <purpose>
      Provide the fast controller with a sparse persistent representation of relevant
      dynamic external state.
    </purpose>

    <possible_nodes>
      <node>Head</node>
      <node>Torso</node>
      <node>Left shoulder</node>
      <node>Right shoulder</node>
      <node>Left hand</node>
      <node>Right hand</node>
      <node>Pelvis</node>
      <node>Left knee</node>
      <node>Right knee</node>
      <node>Left foot</node>
      <node>Right foot</node>
      <node>Estimated center of mass</node>
    </possible_nodes>

    <node_representation>
      node_i = {
        position,
        velocity,
        acceleration,
        orientation,
        uncertainty
      }
    </node_representation>

    <principle>
      The fast controller should receive task-relevant state rather than repeatedly
      rediscovering everything from raw visual pixels.
    </principle>

    <alternative>
      A learned latent belief state may outperform explicit body landmarks.
    </alternative>

    <deeper_requirement>
      Task-relevant external state must persist through temporary observation loss.
    </deeper_requirement>

  </dynamic_body_vector_graph>


  <prediction>

    <short_horizon_prediction>
      p_predicted =
      p_t
      + v_t * delta_t
      + 0.5 * a_t * delta_t^2
    </short_horizon_prediction>

    <uncertainty_rule>
      uncertainty_t+delta > uncertainty_t
    </uncertainty_rule>

    <reobservation>
      new_observation
      -> belief_correction
      -> uncertainty_decreases
    </reobservation>

    <behavioral_effect>
      Short visual loss may permit prediction-based action.
      Longer visual loss may eventually make precise target action irrational and increase
      the value of reacquisition.
    </behavioral_effect>

  </prediction>


  <perception_failure_training>

    <training_corruptions>
      <corruption>Frame dropout</corruption>
      <corruption>Visual latency</corruption>
      <corruption>Motion blur</corruption>
      <corruption>Partial occlusion</corruption>
      <corruption>Missing landmarks</corruption>
      <corruption>Noisy depth</corruption>
      <corruption>False detections</corruption>
      <corruption>Lighting variation</corruption>
      <corruption>Temporary target loss from field of view</corruption>
      <corruption>Camera displacement due to body rotation</corruption>
    </training_corruptions>

    <training_question>
      Can the robot still act intelligently while observation of the world is temporarily incomplete?
    </training_question>

  </perception_failure_training>


  <persistent_3d_context>

    <architecture>

      <layer id="persistent_world">
        <name>Persistent Local 3D Context</name>
        <content>
          <item>Floor</item>
          <item>Walls</item>
          <item>Obstacles</item>
          <item>Goals</item>
          <item>Support surfaces</item>
          <item>Free space</item>
          <item>Unsafe regions</item>
          <item>Other robots</item>
        </content>
      </layer>

      <layer id="dynamic_control_state">
        <name>Dynamic Task-Relevant Belief</name>
        <content>
          <item>Opponent body state</item>
          <item>Ball state</item>
          <item>Fast moving hazards</item>
          <item>Predicted contact trajectories</item>
          <item>Critical nearby geometry</item>
        </content>
      </layer>

    </architecture>

    <pipeline>
      sensors
      -> persistent spatial belief
      -> dynamic target/self belief
      -> motor policy
    </pipeline>

    <possible_world_representations>
      <representation>Occupancy map</representation>
      <representation>TSDF</representation>
      <representation>ESDF</representation>
      <representation>Sparse voxel map</representation>
      <representation>Learned spatial representation</representation>
    </possible_world_representations>

  </persistent_3d_context>


  <egocentric_control>

    <principle>
      Dynamic task state should generally be represented relative to the robot's current
      body frame.
    </principle>

    <example>
      If the robot rotates 35 degrees after impact, the remembered opponent should be
      transformed into the new egocentric frame rather than rediscovered visually.
    </example>

    <summary>
      The coordinate transform changes.
      The remembered object does not.
    </summary>

  </egocentric_control>


  <sensor_fusion>

    <proprioception>
      <question>What happened to me?</question>
      <sensors>
        <sensor>IMU</sensor>
        <sensor>Joint encoders</sensor>
        <sensor>Joint velocity</sensor>
        <sensor>Motor currents</sensor>
        <sensor>Torque estimates</sensor>
        <sensor>Foot contacts</sensor>
        <sensor>Force sensing</sensor>
      </sensors>
    </proprioception>

    <exteroception>
      <question>What happened around me?</question>
      <sensors>
        <sensor>RGB cameras</sensor>
        <sensor>Stereo cameras</sensor>
        <sensor>Event cameras</sensor>
        <sensor>Depth sensors</sensor>
      </sensors>
    </exteroception>

    <principle>
      A camera should not carry the entire state-estimation burden.
    </principle>

  </sensor_fusion>


  <candidate_vision_stack>

    <baseline>
      wide-field global-shutter stereo vision
      + proprioception
    </baseline>

    <optional_fast_channel>
      Event camera
    </optional_fast_channel>

    <role_of_event_camera>
      Provide low-latency motion updates between heavier conventional perception cycles.
    </role_of_event_camera>

    <status>
      Engineering hypothesis requiring empirical validation.
    </status>

  </candidate_vision_stack>


  <multi_rate_architecture>

    <principle>
      Update each part of reality at the rate at which it matters.
    </principle>

    <fast_loop>
      <name>Proprioceptive / Reflex Loop</name>
      <possible_rate>Hundreds to thousands of updates per second</possible_rate>
      <content>
        IMU, joint state, motor state, contact state, torque, short-horizon stabilization.
      </content>
    </fast_loop>

    <dynamic_loop>
      <name>Dynamic Object Loop</name>
      <content>
        Opponent body vectors, balls, incoming contact trajectories, nearby moving objects.
      </content>
    </dynamic_loop>

    <world_loop>
      <name>Persistent World Model Loop</name>
      <content>
        Static geometry, semantics, obstacles, navigation context, scene reconstruction.
      </content>
    </world_loop>

    <summary>
      The robot does not need to reconstruct the universe at 1,000 Hz.
      It needs to know what changed.
    </summary>

  </multi_rate_architecture>


  <latency_prediction>

    <problem>
      Even perfect perception of the present may already be too old by the time physical
      action reaches the target.
    </problem>

    <latency_chain>
      sensor exposure
      -> sensor readout
      -> perception
      -> state fusion
      -> policy inference
      -> motor command
      -> actuator response
      -> mechanical motion
    </latency_chain>

    <target_equation>
      target_future =
      predict(target_belief, total_system_latency)
    </target_equation>

    <coupled_prediction>
      The controller must predict both future target state and future self state.
    </coupled_prediction>

    <relative_intersection>
      contact_candidate =
      intersection(
        predicted_self_trajectory,
        predicted_target_trajectory,
        future_time
      )
    </relative_intersection>

    <constraints>
      <constraint>Structural limits</constraint>
      <constraint>Self-vulnerability</constraint>
      <constraint>Uncertainty</constraint>
      <constraint>Task objective</constraint>
    </constraints>

  </latency_prediction>


  <online_embodiment_adaptation>

    <latent_variable>
      body_state_latent
    </latent_variable>

    <meaning>
      What kind of robot am I physically controlling right now?
    </meaning>

    <changing_conditions>
      <condition>Battery voltage</condition>
      <condition>Actuator temperature</condition>
      <condition>Mechanical wear</condition>
      <condition>Backlash</condition>
      <condition>Payload change</condition>
      <condition>Impact damage</condition>
      <condition>Actuator degradation</condition>
    </changing_conditions>

    <inference_sources>
      <source>Commanded torque</source>
      <source>Expected movement</source>
      <source>Observed movement</source>
      <source>Joint response</source>
      <source>Contact behavior</source>
      <source>Thermal data</source>
    </inference_sources>

    <critical_question>
      Am I still capable of the same trajectories I was capable of five seconds ago?
    </critical_question>

  </online_embodiment_adaptation>


  <training_objective>

    <general_reward>
      Total Reward =
      + Task Progress
      + Target Accuracy
      + Permitted Contact Value
      + Dynamic Continuity
      + Stability
      + Future Controllability
      - Structural Stress
      - Unsafe Contact
      - Self Collision
      - Excess Energy
      - Joint Limit Violation
      - Unnecessary Reacquisition Delay
    </general_reward>

    <critical_term>
      Dynamic Continuity
    </critical_term>

    <failure_mode_to_avoid>
      freeze
      -> stabilize
      -> scan
      -> restart
    </failure_mode_to_avoid>

    <principle>
      A frozen robot may be stable.
      It is not continuous.
    </principle>

    <action_value>
      total_action_value =
      immediate_task_value
      + expected_future_controllability
      + expected_future_task_value
      - physical_risk
    </action_value>

  </training_objective>


  <metrics>

    <metric id="T_positive">

      <name>Task-Positive Action Latency</name>

      <definition>
        Delay from perturbation until measurable positive task progress resumes.
      </definition>

      <equations>
        t_p = perturbation time

        t_positive =
        first time after perturbation at which measurable positive task progress
        resumes for a minimum dwell interval

        T_positive = t_positive - t_p
      </equations>

      <ideal_behavior>
        T_positive approaches zero even while visible mechanical recovery is still underway.
      </ideal_behavior>

    </metric>


    <metric id="PPCR">

      <name>Post-Perturbation Continuity Ratio</name>

      <definitions>
        J_pert =
        cumulative task progress over fixed horizon H after perturbation

        J_ref =
        mean cumulative task progress over matched unperturbed rollouts
      </definitions>

      <equation>
        PPCR = J_pert / max(epsilon, J_ref)
      </equation>

      <interpretation>
        PPCR near 1 implies little task progress was lost because of perturbation.
      </interpretation>

    </metric>


    <metric id="continuity_loss">
      <name>Continuity Loss</name>
      <equation>
        Continuity_Loss = J_ref - J_pert
      </equation>
      <purpose>
        Alternative metric when normalized ratios are unsuitable.
      </purpose>
    </metric>


    <metric id="target_belief_error">
      <name>Target-Belief Error</name>
      <measurements>
        <measurement>Position error</measurement>
        <measurement>Velocity error</measurement>
        <measurement>Orientation error</measurement>
        <measurement>Uncertainty calibration</measurement>
      </measurements>
    </metric>


    <metric id="reacquisition_cost">
      <name>Reacquisition Cost</name>
      <definition>
        Extra scanning, head motion, body motion, or time required before useful target
        behavior resumes.
      </definition>
    </metric>


    <metric id="survival_envelope">
      <name>Perturbation Survival Envelope</name>
      <conditions>
        <condition>fall_probability <= threshold</condition>
        <condition>task_continuity >= threshold</condition>
        <condition>structural_constraints = satisfied</condition>
      </conditions>
      <goal>
        Expand this envelope through training.
      </goal>
    </metric>

  </metrics>


  <benchmark>

    <name>PPCG Benchmark</name>

    <tests>

      <test id="B1">
        <name>Neutral Push</name>
        <description>Apply disturbance while standing.</description>
      </test>

      <test id="B2">
        <name>Task-State Push</name>
        <description>Apply disturbance during active target pursuit.</description>
      </test>

      <test id="B3">
        <name>Friction Variation</name>
      </test>

      <test id="B4">
        <name>Asymmetric Foot Friction</name>
      </test>

      <test id="B5">
        <name>Target Motion During Perturbation</name>
      </test>

      <test id="B6">
        <name>Visual Occlusion</name>
      </test>

      <test id="B7">
        <name>Camera Displacement</name>
      </test>

      <test id="B8">
        <name>Frame Dropout</name>
      </test>

      <test id="B9">
        <name>Compound Perturbation</name>
      </test>

      <test id="B10">
        <name>Repeated Perturbation</name>
      </test>

      <test id="B11">
        <name>Latency Shift</name>
      </test>

      <test id="B12">
        <name>Actuator Degradation</name>
      </test>

      <test id="B13">
        <name>Withheld Opponent</name>
      </test>

      <test id="B14">
        <name>Momentum Opportunity Test</name>
        <description>
          Produce disturbances that create potentially useful translational or rotational
          momentum and test whether the policy exploits rather than automatically cancels it.
        </description>
      </test>

      <test id="B15">
        <name>Inverted-Belief Test</name>
        <description>
          Rotate or partially invert the robot while temporarily removing direct target
          observation and measure whether target belief remains accurate enough for rational action.
        </description>
      </test>

    </tests>

    <benchmark_principle>
      Do not merely measure whether the robot falls.
      Measure whether the robot continues.
    </benchmark_principle>

  </benchmark>


  <decisive_ablation>

    <experiment_name>
      Recovery-Oriented Controller vs Continuity-Oriented Controller
    </experiment_name>

    <controls>
      <control>Same robot embodiment</control>
      <control>Same observation space</control>
      <control>Same task</control>
      <control>Same perturbation distribution</control>
      <control>Same compute budget</control>
      <control>Same or comparable policy architecture</control>
    </controls>

    <controller_A>
      <name>Recovery-Oriented</name>
      <objective>
        Strongly reward stabilization and return toward nominal recoverable state.
      </objective>
    </controller_A>

    <controller_B>
      <name>Continuity-Oriented</name>
      <objective>
        Keep the original task behaviorally active throughout perturbation and reward
        retained task progress alongside stability.
      </objective>
    </controller_B>

    <comparison_metrics>
      <metric>Fall rate</metric>
      <metric>Upright recovery time</metric>
      <metric>T_positive</metric>
      <metric>PPCR</metric>
      <metric>Continuity Loss</metric>
      <metric>Target-belief error</metric>
      <metric>Reacquisition cost</metric>
      <metric>Task success</metric>
      <metric>Energy use</metric>
      <metric>Structural load</metric>
      <metric>Momentum utilization</metric>
      <metric>Future controllability</metric>
    </comparison_metrics>

    <falsification_condition>
      If continuity-oriented training provides no meaningful retained-task advantage
      under otherwise matched conditions, the central PPCG hypothesis is weakened.
    </falsification_condition>

    <supporting_condition>
      If continuity-oriented training preserves substantially greater useful behavior
      without unacceptable safety cost, PPCG has been demonstrated as a meaningful
      training distinction.
    </supporting_condition>

  </decisive_ablation>


  <experimental_program>

    <stage number="1">
      Establish target-directed locomotion and tracking baseline.
    </stage>

    <stage number="2">
      Add broad physical perturbations.
    </stage>

    <stage number="3">
      Perturb throughout task-relevant states.
    </stage>

    <stage number="4">
      Introduce continuity-oriented reward under matched conditions.
    </stage>

    <stage number="5">
      Randomize ground and support dynamics.
    </stage>

    <stage number="6">
      Add persistent target belief and controlled occlusion.
    </stage>

    <stage number="7">
      Add uncertainty-aware prediction and latency randomization.
    </stage>

    <stage number="8">
      Add self-vulnerability model and unconstrained physical contact objectives.
    </stage>

    <stage number="9">
      Test disturbance-momentum reuse.
    </stage>

    <stage number="10">
      Add Boundary-of-Competence Sampling and failure-directed replay.
    </stage>

    <stage number="11">
      Add scripted opponents, self-play, and opponent populations.
    </stage>

    <stage number="12">
      Begin constrained sim-to-real transfer.
    </stage>

    <experimental_principle>
      Add components incrementally so individual contributions remain measurable.
    </experimental_principle>

  </experimental_program>


  <self_play>

    <reason>
      Random forces teach general physical robustness but do not provide intelligent,
      adaptive, correlated opponent behavior.
    </reason>

    <opponent_diversity>
      <opponent>Highly aggressive</opponent>
      <opponent>Defensive</opponent>
      <opponent>Unpredictable movement</opponent>
      <opponent>Frequent low-force contacts</opponent>
      <opponent>Rare high-force contacts</opponent>
      <opponent>Targeted exploitation of known recovery weakness</opponent>
    </opponent_diversity>

    <principle>
      Physical randomization creates robustness to physics.
      Opponent diversity creates robustness to intent.
    </principle>

  </self_play>


  <sim_to_real>

    <risk>
      Strange high-performing simulation behavior may exploit inaccurate physics.
    </risk>

    <possible_simulator_exploits>
      <exploit>Unrealistic friction</exploit>
      <exploit>Geometry penetration</exploit>
      <exploit>Numerical instability</exploit>
      <exploit>Impossible actuator bandwidth</exploit>
      <exploit>Incorrect joint compliance</exploit>
      <exploit>Incorrect collision restitution</exploit>
      <exploit>Missing structural flex</exploit>
    </possible_simulator_exploits>

    <validation_methods>
      <method>Smaller simulation time steps</method>
      <method>Alternative contact models</method>
      <method>Alternative physics engines</method>
      <method>Realistic actuator constraints</method>
      <method>Structural-load monitoring</method>
      <method>High-speed physical measurement</method>
      <method>Low-energy hardware replay</method>
    </validation_methods>

    <principle>
      Strange motion becomes scientifically interesting only when its advantage survives
      increasingly realistic physics.
    </principle>

    <phrase>
      Otherwise we are not discovering new robotics.
      We are discovering bugs.
    </phrase>

  </sim_to_real>


  <safety>

    <hard_constraints>
      <constraint>Maximum joint torque</constraint>
      <constraint>Maximum joint velocity</constraint>
      <constraint>Joint-range limits</constraint>
      <constraint>Thermal limits</constraint>
      <constraint>Structural-load limits</constraint>
      <constraint>Maximum permitted contact impulse</constraint>
      <constraint>Protected body regions</constraint>
      <constraint>Self-collision constraints</constraint>
      <constraint>Supervisory shutdown</constraint>
      <constraint>Emergency stop</constraint>
    </hard_constraints>

    <principle>
      Learned optimization operates inside a hard physical safety envelope.
    </principle>

    <goal>
      Robust embodied control under physical uncertainty, not unlimited collision energy.
    </goal>

  </safety>


  <applications_beyond_robot_sport>

    <application>
      <name>Warehouse Payload Preservation</name>
      <scenario>
        Robot carrying a box is bumped and slips but continues optimizing for both balance
        and payload preservation rather than dropping the box to regain posture.
      </scenario>
    </application>

    <application>
      <name>Home Robotics</name>
      <scenario>
        Robot carrying a tray is accidentally bumped and preserves the task through
        disturbance.
      </scenario>
    </application>

    <application>
      <name>Rescue Robotics</name>
      <scenario>
        Robot struck by debris redirects the resulting motion into a safe and useful
        continuation.
      </scenario>
    </application>

    <application>
      <name>Factory Robotics</name>
      <scenario>
        Loose flooring or unexpected contact alters support conditions while the task
        remains active.
      </scenario>
    </application>

    <application>
      <name>Maintenance Robotics</name>
      <scenario>
        Tool catches unexpectedly and the robot preserves control of both body and task.
      </scenario>
    </application>

    <application>
      <name>Mobile Manipulation</name>
      <scenario>
        Payload shifts unexpectedly and controller preserves task value rather than
        treating stabilization as an isolated objective.
      </scenario>
    </application>

    <generalization>
      Robot sport is a useful laboratory because perturbations are frequent, visible,
      adversarial, and measurable. The underlying continuity problem is much broader.
    </generalization>

  </applications_beyond_robot_sport>


  <open_questions>

    <question id="Q1">
      Is an explicit DBVG better than a learned latent dynamic representation?
    </question>

    <question id="Q2">
      How many task-relevant landmarks are needed?
    </question>

    <question id="Q3">
      How much of the persistent world model should the fast controller receive?
    </question>

    <question id="Q4">
      Is global-shutter stereo sufficient?
    </question>

    <question id="Q5">
      Do event cameras materially improve continuity after accounting for total system latency?
    </question>

    <question id="Q6">
      What prediction horizons are optimal?
    </question>

    <question id="Q7">
      How should increasing uncertainty modify aggressive versus conservative action?
    </question>

    <question id="Q8">
      How accurately can high-energy humanoid contact be simulated?
    </question>

    <question id="Q9">
      How should cumulative structural fatigue be represented?
    </question>

    <question id="Q10">
      How detailed should the self-vulnerability model be?
    </question>

    <question id="Q11">
      Should control be monolithic or hierarchical?
    </question>

    <question id="Q12">
      How should failure-directed sampling avoid overfitting to previously discovered weaknesses?
    </question>

    <question id="Q13">
      Which states should legitimately terminate the continuing objective?
    </question>

    <question id="Q14">
      What machine-native movement vocabulary emerges when human motion priors are removed?
    </question>

  </open_questions>


  <knowledge_graph_relations>

    <relation>
      <subject>Perturbation</subject>
      <predicate>changes</predicate>
      <object>Physical State</object>
    </relation>

    <relation>
      <subject>Perturbation</subject>
      <predicate>does_not_necessarily_cancel</predicate>
      <object>Task Objective</object>
    </relation>

    <relation>
      <subject>Mechanical Recovery</subject>
      <predicate>does_not_imply</predicate>
      <object>Task Continuity</object>
    </relation>

    <relation>
      <subject>Mechanical Recovery</subject>
      <predicate>does_not_imply</predicate>
      <object>Perceptual Continuity</object>
    </relation>

    <relation>
      <subject>Persistent Belief State</subject>
      <predicate>enables</predicate>
      <object>Action During Temporary Occlusion</object>
    </relation>

    <relation>
      <subject>Proprioception</subject>
      <predicate>updates</predicate>
      <object>Self State</object>
    </relation>

    <relation>
      <subject>Exteroception</subject>
      <predicate>updates</predicate>
      <object>External State</object>
    </relation>

    <relation>
      <subject>Sensor Fusion</subject>
      <predicate>maintains</predicate>
      <object>Belief State</object>
    </relation>

    <relation>
      <subject>Dynamic Body-Vector Graph</subject>
      <predicate>represents</predicate>
      <object>Task-Relevant Dynamic External State</object>
    </relation>

    <relation>
      <subject>DBVG</subject>
      <predicate>is_candidate_implementation_of</predicate>
      <object>Persistent Belief State</object>
    </relation>

    <relation>
      <subject>Incoming Force</subject>
      <predicate>creates</predicate>
      <object>New Dynamical State</object>
    </relation>

    <relation>
      <subject>New Dynamical State</subject>
      <predicate>may_contain</predicate>
      <object>Useful Momentum</object>
    </relation>

    <relation>
      <subject>Useful Momentum</subject>
      <predicate>may_be</predicate>
      <object>Redirected</object>
    </relation>

    <relation>
      <subject>Useful Momentum</subject>
      <predicate>may_be</predicate>
      <object>Exploited</object>
    </relation>

    <relation>
      <subject>Self-Vulnerability Model</subject>
      <predicate>constrains</predicate>
      <object>Force Maximization</object>
    </relation>

    <relation>
      <subject>Self-Vulnerability Model</subject>
      <predicate>constrains</predicate>
      <object>Defense</object>
    </relation>

    <relation>
      <subject>Self-Vulnerability Model</subject>
      <predicate>constrains</predicate>
      <object>Temporary Support Contact</object>
    </relation>

    <relation>
      <subject>Goal-Conditioned Control</subject>
      <predicate>allows_emergence_of</predicate>
      <object>Machine-Native Movement</object>
    </relation>

    <relation>
      <subject>Human Motion Priors</subject>
      <predicate>may_limit</predicate>
      <object>Robot-Specific Mechanical Optima</object>
    </relation>

    <relation>
      <subject>Boundary-of-Competence Sampling</subject>
      <predicate>concentrates_training_on</predicate>
      <object>Continuity Failure Regions</object>
    </relation>

    <relation>
      <subject>Failure-Directed Replay</subject>
      <predicate>converts</predicate>
      <object>Rare Failures</object>
      <result>Abundant Training Examples</result>
    </relation>

    <relation>
      <subject>Latency</subject>
      <predicate>requires</predicate>
      <object>Future-State Prediction</object>
    </relation>

    <relation>
      <subject>Future-State Prediction</subject>
      <predicate>uses</predicate>
      <object>Predicted Self Trajectory</object>
    </relation>

    <relation>
      <subject>Future-State Prediction</subject>
      <predicate>uses</predicate>
      <object>Predicted Target Trajectory</object>
    </relation>

    <relation>
      <subject>Continuity-Oriented Training</subject>
      <predicate>should_reduce</predicate>
      <object>Task-Positive Action Latency</object>
    </relation>

    <relation>
      <subject>Continuity-Oriented Training</subject>
      <predicate>should_increase</predicate>
      <object>PPCR</object>
    </relation>

    <relation>
      <subject>Continuity-Oriented Training</subject>
      <predicate>should_reduce</predicate>
      <object>Reacquisition Cost</object>
    </relation>

    <relation>
      <subject>PPCG Benchmark</subject>
      <predicate>measures</predicate>
      <object>Continuity Through Disturbance</object>
    </relation>

    <relation>
      <subject>Robot Sport</subject>
      <predicate>serves_as</predicate>
      <object>Stress Test for General Embodied Continuity</object>
    </relation>

  </knowledge_graph_relations>


  <hypotheses>

    <hypothesis id="H1">
      Continuity-oriented training will produce lower Task-Positive Action Latency than
      recovery-oriented training under matched perturbations.
    </hypothesis>

    <hypothesis id="H2">
      Continuity-oriented training will produce higher PPCR than recovery-oriented training.
    </hypothesis>

    <hypothesis id="H3">
      Persistent target belief will reduce visual reacquisition cost following body rotation.
    </hypothesis>

    <hypothesis id="H4">
      Perturbing throughout relevant dynamical states will improve robustness beyond
      perturbation training concentrated on nominal states.
    </hypothesis>

    <hypothesis id="H5">
      Training compound perturbations will improve behavior when disturbances overlap
      before recovery is complete.
    </hypothesis>

    <hypothesis id="H6">
      Self-vulnerability-aware force maximization will discover higher-value robot-specific
      contact trajectories than human-authored striking motions.
    </hypothesis>

    <hypothesis id="H7">
      Some perturbations will be profitably exploited as momentum rather than optimally canceled.
    </hypothesis>

    <hypothesis id="H8">
      Machine-native movement discovered without strong human motion priors will include
      trajectories that appear unconventional to human observers while remaining
      mechanically superior.
    </hypothesis>

    <hypothesis id="H9">
      Hard-state sampling targeted at continuity loss will improve sample efficiency over
      uniform perturbation sampling.
    </hypothesis>

    <hypothesis id="H10">
      A persistent sparse dynamic state representation will allow fast control through
      temporary visual loss without requiring complete scene reconstruction at reflex frequency.
    </hypothesis>

  </hypotheses>


  <failure_conditions>

    <failure_condition>
      Continuity-oriented training does not improve retained task value.
    </failure_condition>

    <failure_condition>
      Continuity-oriented policies sacrifice unacceptable amounts of physical stability.
    </failure_condition>

    <failure_condition>
      Persistent belief provides no advantage over recurrent raw-observation policies.
    </failure_condition>

    <failure_condition>
      Boundary-of-Competence Sampling reduces out-of-distribution robustness.
    </failure_condition>

    <failure_condition>
      Machine-native motion consistently exploits simulator inaccuracies and fails on hardware.
    </failure_condition>

    <failure_condition>
      Momentum reuse produces no advantage over conventional stabilization.
    </failure_condition>

    <failure_condition>
      PPCG metrics fail to correlate with actual task performance.
    </failure_condition>

    <scientific_attitude>
      The goal is not to make the terminology survive.
      The goal is to discover the architecture that works.
    </scientific_attitude>

  </failure_conditions>


  <broader_principle>

    <statement>
      Autonomous systems spend large portions of their existence between clean,
      human-readable units of competence.
    </statement>

    <transition_examples>
      <transition>Walking -> turning</transition>
      <transition>Grasping -> carrying</transition>
      <transition>Stable -> disturbed</transition>
      <transition>Visible target -> temporarily occluded target</transition>
      <transition>Expected state -> unexpected state</transition>
    </transition_examples>

    <principle>
      Useful behavior should degrade gracefully as state becomes unfamiliar rather than
      disappearing at the boundary of a trained motion.
    </principle>

    <competence_definition>
      Competence should include how much of the objective remains recoverable from the
      states reality actually produces, not only performance from ideal skill-start states.
    </competence_definition>

    <phrase>
      Train the space between competence and competence.
    </phrase>

  </broader_principle>


  <terminology>

    <term>
      <name>Post-Perturbation Continuity Gap</name>
      <abbreviation>PPCG</abbreviation>
      <definition>
        Loss of task-directed performance caused by an unexpected physical state transition,
        beyond whether mechanical balance is eventually restored.
      </definition>
    </term>

    <term>
      <name>Post-Perturbation Continuity</name>
      <abbreviation>PPC</abbreviation>
      <definition>
        Degree to which useful goal-directed behavior survives disturbance and its
        immediate recovery interval.
      </definition>
    </term>

    <term>
      <name>Post-Perturbation Continuity Ratio</name>
      <abbreviation>PPCR</abbreviation>
      <definition>
        Normalized comparison between post-disturbance task progress and matched
        unperturbed task progress.
      </definition>
    </term>

    <term>
      <name>Task-Positive Action Latency</name>
      <abbreviation>T_positive</abbreviation>
      <definition>
        Delay from perturbation until measurable positive task progress resumes.
      </definition>
    </term>

    <term>
      <name>Dynamic Body-Vector Graph</name>
      <abbreviation>DBVG</abbreviation>
      <definition>
        Sparse persistent representation of task-relevant dynamic body points containing
        position, motion, orientation where useful, and uncertainty.
      </definition>
    </term>

    <term>
      <name>Self-Vulnerability Model</name>
      <definition>
        Representation of robot-specific mechanical fragility, protected components,
        safe load paths, and robust contact regions.
      </definition>
    </term>

    <term>
      <name>Boundary-of-Competence Sampling</name>
      <definition>
        Curriculum strategy allocating greater training probability to disturbance
        regions where continuity remains fragile.
      </definition>
    </term>

    <term>
      <name>Task-Continuous Recovery</name>
      <definition>
        Recovery evaluated according to retained task value rather than canonical posture.
      </definition>
    </term>

    <term>
      <name>Continuous Objective Control</name>
      <definition>
        Control framing in which locomotion, attack, defense, stabilization, and recovery
        need not correspond to separate low-level states; the objective remains conditioned
        on current belief state and constraints as physical state changes.
      </definition>
    </term>

  </terminology>


  <research_lineage>

    <related_work>
      <work>
        Haarnoja et al.
        Learning Agile Soccer Skills for a Bipedal Robot with Deep Reinforcement Learning.
        Science Robotics, 2024.
      </work>

      <work>
        Ferigo et al.
        On the Emergence of Whole-body Strategies from Humanoid Robot Push-recovery Learning.
        2021.
      </work>

      <work>
        Kumar et al.
        RMA: Rapid Motor Adaptation for Legged Robots.
        RSS, 2021.
      </work>

      <work>
        OpenAI et al.
        Solving Rubik's Cube with a Robot Hand.
        2019.
      </work>

      <work>
        Wang et al.
        Learning Vision-Driven Reactive Soccer Skills for Humanoid Robots.
        2025.
      </work>

      <work>
        NVIDIA Isaac ROS nvblox.
        Persistent TSDF / ESDF scene representation.
      </work>

      <work>
        Sony / Prophesee IMX636.
        Event-based vision sensor.
      </work>

      <work>
        Zhu et al.
        Contact-Safe Reinforcement Learning for Contact-Rich Manipulation.
        2022.
      </work>

      <work>
        Su et al.
        Cooperative and Competitive Robot Soccer With Self-Play.
        2025.
      </work>

      <work>
        Adiwahono et al.
        Push Recovery Through Walking Phase Modification for Bipedal Locomotion.
        2013.
      </work>

      <work>
        Zhang et al.
        Keep On Going: Learning Robust Humanoid Motion Skills via Selective Adversarial Training.
        2026.
      </work>

      <work>
        Yang et al.
        HANDOFF: Humanoid Agentic Task-Space Whole-Body Control via Distilled Complementary Teachers.
        2026.
      </work>

      <work>
        Research on Robot Collision Response Based on Human-Robot Collaboration.
        Sensors, 2026.
      </work>
    </related_work>

  </research_lineage>


  <llm_reasoning_seeds>

    <seed>
      Do not equate balance recovery with task recovery.
    </seed>

    <seed>
      When evaluating a disturbed humanoid, ask what useful task value is being generated
      during the recovery interval itself.
    </seed>

    <seed>
      Treat unexpected momentum as a state variable, not automatically as an error to cancel.
    </seed>

    <seed>
      Treat temporary visual loss as increasing uncertainty rather than deleting the target.
    </seed>

    <seed>
      Distinguish the observation from the underlying world state.
    </seed>

    <seed>
      Prefer goal-conditioned physics over prespecified human martial-art motions when
      searching for robot-specific optima.
    </seed>

    <seed>
      Force maximization is meaningful only inside structural, vulnerability, safety, and
      future-controllability constraints.
    </seed>

    <seed>
      Robot-sensitive regions are not necessarily analogous to human-sensitive regions.
    </seed>

    <seed>
      A noncanonical body state can still be a valuable action state.
    </seed>

    <seed>
      A recovery trajectory can simultaneously be an attack trajectory, locomotion
      trajectory, interception trajectory, or task-preservation trajectory.
    </seed>

    <seed>
      The fastest layer of control should consume compact task-relevant state rather than
      reconstruct the entire world at reflex frequency.
    </seed>

    <seed>
      Optimize the transition space between skills, not only the skills themselves.
    </seed>

    <seed>
      Test novelty conservatively. Many underlying ingredients already exist.
      Focus novelty claims on the continuity-oriented synthesis, metrics, training target,
      and cross-layer coupling.
    </seed>

  </llm_reasoning_seeds>


  <final_conceptual_chain>

    physical perturbation
    -> unexpected dynamical state
    -> proprioceptive self-state update
    -> persistent external belief update
    -> uncertainty-aware prediction
    -> evaluate reachable trajectories
    -> apply structural and vulnerability constraints
    -> preserve continuing objective
    -> optionally redirect or exploit momentum
    -> choose highest-value continuation
    -> continue acting before canonical recovery is complete

  </final_conceptual_chain>


  <final_summary>

    <statement>
      The framework proposes training humanoid robots so that physical recovery,
      perception, and task pursuit remain part of one continuously evaluated control problem.
    </statement>

    <statement>
      The perturbation is not the end of the action.
      It is the beginning of a new state.
    </statement>

    <statement>
      The world continues.
      The objective should continue with it.
    </statement>

    <central_thesis>
      A humanoid should not merely be trained to recover and then resume its task;
      it should be trained to preserve as much of the task as possible through the
      recovery itself.
    </central_thesis>

    <closing_statement>
      The goal is to build a robot for which recovery is simply another moment of
      continuous action.
    </closing_statement>

  </final_summary>

</kg-llm-seed-map>