Validate a small robot simulation before real hardware

Learn in your browser · Chapter 01 of 06

Start with a small question you can falsify, rather than a realistic-looking animation you cannot check.

A simulation is an executable set of assumptions. Here the fictional Bench Carriage is reduced to a point mass moving on one horizontal line, with a separate vertical drop probe to investigate gravity and contact. These are two independent experiments, not a coupled robot. There are no joints, wheels, cameras, sensors, meshes or communications. This original Python baseline is not Newton, Isaac Sim, a digital twin or a learned policy. Its purpose is to make several useful verification failures small enough to calculate by hand.

Separate three questions. Verification asks whether the program implements its stated equations and rules. Validation asks whether that model is an adequate representation for an intended physical use, using suitable external evidence. Operational authorisation asks whether a responsible person has permitted a specific real action. An analytic comparison can support the first question. This course supplies neither physical validation evidence nor permission to connect to a robot. Even a visually convincing, reproducible simulation can represent the wrong system.

Use metres for position, seconds for time and kilograms for mass. Velocity is metres per second, acceleration metres per second squared and force newtons, equivalent to kilogram metres per second squared. A positive vertical coordinate points upwards, so a positive gravity magnitude produces a negative vertical acceleration. Convert the source quantity and label it: 200 millimetres is 0.2 metres, not 200 metres. A number without a unit is not a complete physical input. Our gravity values are stated teaching assumptions, not local measurements.

A reproducibility record contains the source-file hashes, Python version, operating system, parameter values, numerical method, step duration, step count, initial state, expected comparisons and actual outputs. Record the simulated duration separately from wall-clock runtime. Here T equals step count multiplied by step duration. Ten seconds of simulated motion can run much faster than ten seconds of waiting. Repeating the same inputs checks repeatability of this calculation; it does not show that a physical system would behave the same way.

The controller is ordinary proportional-derivative feedback, not AI. An AI coding assistant may help explain or propose a change, but its suggestion must remain a proposal until you inspect and test it. If you later train a policy, keep training, validation and evaluation scenarios distinct and report failures as well as successes. A policy that exploits an inaccurate contact model may obtain a high simulated reward while learning behaviour that will not transfer. Neither a score nor an animation replaces the underlying measurement boundary.

Inputs are part of the model boundary. The supplied functions reject non-finite values such as NaN and infinity, Boolean values presented as numbers, non-positive time steps, invalid counts and out-of-range restitution. Step counts are integers from 1 to 100000. Positive mass is required for the controlled point mass. This is bounded classroom computation: the step cap limits the loop count, while the finite checks prevent several meaningless arithmetic states. These checks do not make arbitrary code from an assistant safe to execute.

Choose the evidence claim before running. A suitable claim is that a semi-implicit drop calculation agrees with the stated no-drag analytic position within 0.03 metres at 0.2 seconds for a specified step size. An unsuitable claim is that the robot is safe because the tests pass. Keep the scope visible beside results: no GPU, account, downloaded asset or network is needed; nothing drives hardware. Completion of written practice is ungraded. A later scored knowledge exam can assess understanding, not practical robotics competence.

Learn in your browser · Chapter 02 of 06

Use an equation with a known solution before trusting an unfamiliar simulator or controller.

For vertical motion with constant gravity and no drag, the chosen sign convention gives y(t) = y0 + v0*t - 0.5*g*t*t and v(t) = v0 - g*t. These expressions apply before any floor response. From y0 = 1 m, v0 = 0 m/s and g = 9.8 m/s squared, the analytic result at t = 0.2 s is y = 0.804 m and v = -1.96 m/s. Calculate the reference directly, rather than calling the same numerical stepping function twice.

Explicit Euler first advances position using the old velocity, then updates velocity: y_next = y + v*dt; v_next = v - g*dt. With dt = 0.1 s for two steps, the states are (1, -0.98) and (0.902, -1.96), where each pair is height and velocity in SI units. The first step has no displacement because its old velocity is zero. The resulting height is 0.098 m above the analytic height. A plausible-looking trajectory can still contain a measurable integration error.

Semi-implicit Euler updates velocity first and uses that new velocity for position: v_next = v - g*dt; y_next = y + v_next*dt. For the same two 0.1 s steps its states are (0.902, -0.98) and (0.706, -1.96). The height is now 0.098 m below the analytic reference. The update order is the relevant difference. Lab tests should identify that difference explicitly, rather than treating two implementations as independent merely because they have different function names.

At a fixed duration T = n*dt and with this constant acceleration, the semi-implicit height is y0 + v0*T - g*dt*dt*n*(n+1)/2. Subtracting the analytic height gives -0.5*g*T*dt. The explicit error has the opposite sign and the same magnitude. This derivation predicts a linear reduction of position error when dt shrinks at fixed T. It does not establish the same convergence rate for contacts, changing accelerations or a stiff controller. Those need their own experiment.

Scroll sideways to see every column.

A declared maximum absolute position error of 0.03 m at 0.2 s accepts the dt = 0.025 s result and rejects the two coarser configurations in the table. This is a fictional learning criterion, not an engineering safety tolerance. Declare it before examining outputs and keep the failed configurations in the evidence pack. Do not relax it to 0.05 m after seeing a 0.049 m error unless you record a justified change in the intended question and repeat the assessment.

Both Euler variants produce the same velocity, -1.96 m/s, in this constant-gravity example despite their different heights. A velocity-only assertion would therefore miss the position defect. Choose metrics that expose the intended error: compare position, velocity, time and sign separately. Use approximate numeric comparisons for floating-point values with a stated tolerance. A long decimal tail such as 0.8039999999999999 is not itself evidence of a meaningful physical discrepancy from 0.804.

Run python run_experiment.py and compare its fall_comparison rows with your hand calculation. The independent summed-velocity test also calculates the semi-implicit displacement by summing the integers 1 through n, rather than invoking the stepping loop as its own expected result. A second check using the same wrong formula can agree perfectly and still prove little. For later AI-generated changes, preserve a few short hand-derived fixtures so a shared reasoning error is less likely to survive.

Learn in your browser · Chapter 03 of 06

A projected object can look perfectly above the floor while the collision timing is wrong.

For the release from rest at height 1 m with g = 9.8 m/s squared, the analytic first floor-contact time is sqrt(2*y0/g), about 0.451754 s. Its downward speed magnitude immediately before contact is sqrt(2*g*y0), about 4.427189 m/s. This reference assumes a floor at y = 0 and no drag. It identifies the instant the point reaches the floor, not a contact force, deformation or stress. Those quantities are absent from this point-mass model.

The first_contact function advances flight using the exact constant-acceleration update within each step, then checks the sampled end height. Its contact response occurs at the first sample with height at or below zero. At dt = 0.05 s the preceding sample is 0.45 s and the responding sample is 0.50 s. The interval brackets the analytic crossing for this exact-flight, release-from-rest case. It is a sampling bracket, not a confidence interval about a real impact or an established bound for other integrators.

At 0.50 s the unprojected height is -0.225 m and the sampled velocity is -4.9 m/s. The code projects height to zero and then responds. Although the resulting display position is on the floor, the response is late and its incoming speed magnitude is too large compared with 4.427189 m/s. The penetration_before_projection_m metric retains the 0.225 m discrepancy. Exact free-flight arithmetic has not made this sampled collision response exact. The event-detection rule is a separate approximation.

Restitution e is a dimensionless teaching parameter constrained to the interval from zero to one. The response sets v_after = -e*v_before. For e = 0.5 and a sampled incoming velocity of -4.9 m/s, the outgoing velocity is +2.45 m/s. At the same mass, the ratio of outgoing to incoming kinetic energy at that sampled event is e squared, or 0.25. This algebra verifies the response rule. It does not calibrate e to a material, and the incoming state is still biased by delayed detection.

Keep the pre-projection penetration and incoming velocity, as well as the projected height. A test that checks only post_height_m equals zero would pass even after a very deep sampled penetration. Projection changes the reported state, not the history that produced it. For an educational evidence pack, label both values and their meanings. Do not call projection a collision solver: it has no sustained contact, compliance, force estimate, joint interaction, resting-contact logic or multi-body constraint handling.

A short horizon can end before any sampled contact. The function returns NO_CONTACT_WITHIN_HORIZON instead of fabricating a collision at the last sample. With max_steps = 1 and dt = 0.05 s, the simulation simply has not reached the expected contact time. That result differs from proving that contact cannot occur. Keep horizon length and the reason for termination next to each event result, especially when a later model might stop because of an error or a boundary.

Refine the contact experiment separately. For dt = 0.01 s, the response is at 0.46 s with pre-projection penetration about 0.03684 m. For dt = 0.005 s, it is at 0.455 s with penetration about 0.0144225 m. Both are closer to this analytic event than the 0.05 s case. Do not promise strict improvement at every possible step value: sampling can move in plateaux. Record both timing and penetration criteria, and compare the same initial conditions and gravity.

A full robotics engine may use a different contact model, integrator, solver tolerance and material representation. MuJoCo documentation describes contact and integration as explicit modelling choices; it does not make this lab an implementation of its algorithms. When comparing engines, first reproduce a simple scene with matching units and conditions, then examine event and energy metrics. A screenshot of a bouncing object cannot establish numerical equivalence or tell you which solver assumptions were used.

Learn in your browser · Chapter 04 of 06

Use a second simple reference and change one assumption at a time.

The horizontal slide experiment starts at positive velocity on an ideal level surface, with constant kinetic friction and no driving force. Under the assumed normal force N = m*g, friction magnitude is mu*m*g and deceleration magnitude is a = mu*g. Mass cancels from acceleration in this specific model. This is not a statement that mass never matters in robots. Load-dependent friction, contact geometry, changing normals, rolling resistance, motors and static friction are not represented.

For initial speed v0 = 2 m/s, mu = 0.2 and g = 10 m/s squared, deceleration is 2 m/s squared. The analytic stopping time is v0/a = 1 s and stopping distance is v0 squared divided by 2*a = 1 m. The lab uses gravity 10 here as an explicit separate fixture, not as an unnoticed replacement of the drop experiment value 9.8. Calculate the reference before running the loop. At an observation horizon of 2 s the object has stopped and remains at 1 m.

With the same initial speed and gravity but mu = 0.4, deceleration is 4 m/s squared, stopping time 0.5 s and stopping distance 0.5 m. This sensitivity comparison doubles one coefficient and holds the other parameters fixed. It does not establish the coefficient of a real surface. The two values are invented teaching cases. A future physical validation would need an appropriate measurement procedure, uncertainty statement and evidence for the conditions in which the coefficient is used.

The slide code solves the final partial movement within a step. For positive a it uses moving_time = min(dt, v/a), advances distance by v*moving_time - 0.5*a*moving_time squared, then clamps the next speed to zero rather than allowing a sign reversal. With dt = 0.3 s, stopping happens 0.1 s into the fourth step in the mu = 0.2 fixture. Treating all of that step as continued deceleration could make the object move backwards or bias its final distance.

At mu = 0 there is no kinetic deceleration in this model, so positive speed remains constant. From 2 m/s for 1 s, distance is 2 m and final speed is 2 m/s. The stopping-time formula v0/(mu*g) must not be evaluated at zero mu. The code handles this branch directly. A body starting at rest also remains at rest because there is no drive. These behaviours do not test static friction under an applied force; that mechanism has not been implemented.

Do not quietly add the slide friction to the controller experiment and keep calling the result the same baseline. The controller initially isolates force, mass and feedback without friction. Combining the models creates a new experiment, including a decision about friction at zero velocity and under a driving force. Document the combination and write a new reference or invariants before using it. Isolation makes a failed assumption easier to find, even though a future robot will involve several interacting mechanisms.

A parameter sweep is informative when every row retains its configuration and the comparison answers a defined question. For the two slide fixtures, report mu, g, initial speed, step duration, horizon, final distance and final speed. Do not average their stopping distances and label the average a validated surface. If one row fails, retain it with the failure explanation. A missing or invalid row is different from a successful zero-distance result. Numeric input validation and consistent units come before summarising outcomes.

The slide test at dt = 0.3 s deliberately makes the stop occur between sample boundaries. The expected distance remains 1 m because the function accounts for that partial interval. This is a different integration design from sampled first_contact, which deliberately postpones response until the sample end. An improvement in one function cannot be assumed for the other. Compare each approximation against its own reference, and use these differences to explain why a single global tests-passed label can obscure meaningful limitations.

Learn in your browser · Chapter 05 of 06

A bounded force is useful, but tracking and state boundaries need their own checks.

The controlled horizontal point mass starts at x = 0 and v = 0, with target x = 1 m. Requested force is kp*(target - x) - kd*v. The baseline uses mass 1 kg, kp = 16 N/m, kd = 8 N seconds per metre and an applied-force limit of 4 N in either direction. At the initial state the request is 16 N but the applied force is +4 N. Division by mass produces acceleration +4 m/s squared. The damping term opposes velocity, not position error.

The controller advances velocity and then position with a semi-implicit step. At dt = 0.01 s, the first velocity is +0.04 m/s and the first position is +0.0004 m. The proportional and derivative gains are dimensional quantities, not interchangeable labels. A metre-to-millimetre mistake would change their numerical interpretation. This simple control experiment has no sensor noise, delay, torque limits, joint geometry or motor dynamics. Its time-step refinement compares the same synthetic equation; it is not a validated physical servo.

State boundaries are checked on the proposed next state before it becomes accepted. The baseline has absolute travel limit 2 m and speed limit 3 m/s. A travel violation stops with STOP_TRAVEL_LIMIT; otherwise a speed violation stops with STOP_SPEED_LIMIT. The returned accepted position and velocity remain the preceding state, and the rejected proposal is recorded separately. These are simulation stop rules. They do not command emergency braking, clamp the physical speed or design a hardware safety function.

COMPLETED means that the requested number of simulation steps ran without a boundary stop. It is not a tracking verdict. Set both gains to zero and the point mass remains at x = 0 with zero velocity for all 1000 steps. The run completes but its target error remains 1 m. A successful iteration count and a low speed do not establish useful behaviour. Keep the status, terminal error, velocity, requested horizon and limits together when judging a controller.

For the 10 s baseline, use a declared educational tracking rule: COMPLETED status, absolute final error below 0.01 m and absolute final speed below 0.01 m/s, with force, travel and speed boundaries respected throughout the accepted trace. The supplied run meets this rule in the tested environment. This criterion checks the terminal state, not a settling-time requirement or robustness across every scenario. A future course could add trajectory-wide error, disturbances and sensor delay as separate requirements.

A deliberate reversed-feedback fault replaces target - x by x - target while retaining the same damping expression. It initially drives away from the target. The supplied default run stops at a state boundary rather than meeting the tracking criterion. A second failure sets the target to 6 m outside the travel envelope: the default speed boundary is reached first. To isolate the travel test, its unit test explicitly raises the synthetic speed limit to 10 m/s. Record the changed configuration instead of claiming that target distance alone predicts the first stop.

Keep requested force separate from applied force and record how often the request saturates. Clipping the command changes the closed-loop dynamics. The trace stores step index, accepted position, accepted velocity and applied force; time is step index multiplied by dt. The default force never exceeds 4 N. This does not limit all consequences: a small force acting over time can still build speed or move outside the desired area. State boundaries therefore remain meaningful even when command bounds work.

Try two runs with the same duration and different steps, then compare final position, velocity, saturation and stop status. The supplied refinement test uses 0.02 s for 100 steps and 0.01 s for 200 steps, both representing 2 s. Its position comparison tolerance is 0.02 m. This is one targeted consistency probe, not proof that either trajectory is accurate for real hardware or that smaller steps can never create a different event order. Preserve the exact configurations with the result.

Learn in your browser · Chapter 06 of 06

End with an honest test record and a narrowly scoped next experiment.

The supplied suite has 30 tests covering hand-derived flight values, fixed-time refinement, sampled event brackets, restitution, partial-step friction, input rejection, controller tracking and boundary failures. Running it checks this version of this teaching implementation in your environment. Save its output, the small experiment JSON, source hashes and the declared criteria. Repeat the experiment and compare its data rather than relying on a screenshot of a green test runner. A test count says nothing about behaviours that were never exercised.

Three deliberate logic faults are applied separately in memory: lose the one-half factor in analytic displacement, reverse the rebound sign, and remove the force clamp. Independent probes detect each changed result. These checks show that the chosen probes can catch those specific faults. They do not establish coverage of every possible implementation defect. A fault that makes a test pass is particularly instructive: examine whether the expected result shares the same calculation, or whether an assertion ignores the quantity that changed.

Keep distinct tests for invariants, reference values and sensitivity. An invariant includes non-negative slide speed after stopping; a reference check compares the declared 0.804 m flight height; sensitivity changes mu or dt while holding the other inputs fixed. Also test invalid inputs and missing events. A passing normal fixture cannot substitute for the boundary cases. Floating-point results need tolerances justified by the model question, not a sequence of arbitrary rounding operations that hides discrepancies.

Optional reading extension, checked 26 October 2026: NVIDIA lists a Newton Fundamentals environment tested with Newton 1.5.x, Python 3.10 or 3.11, Linux x86-64, an RTX GPU and CUDA 12.8 user-space libraries with driver 550 or newer. Its Isaac Lab path names v3.0.0-beta2. Cloud instances can incur charges while idle. These are that learning path's stated conditions, not the requirements of our Python-only baseline. Recheck the linked official setup before making an environment plan. We installed and executed neither Newton nor Isaac Lab.

A larger-engine experiment should reproduce a simple drop using a pinned engine version, solver, step size, gravity, initial state, geometry, mass, coordinate convention and contact settings. Compare event time, pre-contact speed, penetration or solver-equivalent contact metrics, and rebound under declared thresholds. Record how each quantity is defined in that engine. Do not assume its material parameter equals our teaching restitution parameter. The current Newton repository can have requirements different from the pinned learning path, so an unpinned latest install is not an equivalent environment.

Prepare a transfer decision with three columns: evidence obtained, evidence missing and next authorised step. In this packet the first column contains reproducible synthetic checks; missing evidence includes 3D dynamics, physical parameter measurements, sensor effects, hardware limits and independent review. The next step can be a reviewed simulation experiment, not robot operation. Use the version-specific review records to identify what has been checked, and check the published course and assessment pages for current availability and terms; local files do not establish a public offer. A MICKAI educational knowledge certificate is not an accredited qualification, professional licence, NVIDIA credential or permission to operate equipment.

For an AI-assisted change, write a short hypothesis, make one bounded modification and run the relevant reference and failure probes before expanding the change. Keep the previous version so differences can be explained. If a contact metric improves while a control boundary stops earlier, report both. Your conclusion should identify the version, environment, scope and unresolved discrepancies. This habit transfers to richer physical-AI systems without pretending that a tiny reference model reproduces all of their behaviour.