Introduction
In the mid-1980s, AI planning faced a significant hurdle: the disconnect between abstract logic and the continuous, messy reality of the physical world. While traditional planners could handle discrete actions, they struggled with "natural processes"—events like water boiling or flowing that occur without a robot's direct, constant intervention.
James G. Schmolze's 1986 paper, Physics For Robots (PFR), addresses this gap. Schmolze critiques the prevailing "Naive Physics" (NP) movement, most notably championed by Patrick Hayes. While NP sought to model the entirety of human common-sense knowledge, Schmolze argued for a more pragmatic, utility-driven approach. Robots do not need to understand physics as humans do; they need a specific subset of knowledge that enables them to predict the outcomes of their actions and the natural processes they initiate.
The PFR Framework: A Formal Ontology
The core of PFR is a formal logic-based ontology designed to handle the complexities of physical change over time. It is built upon three primary pillars:
1. The Granule Ontology
To model materials like liquids and gases without descending into the complexity of atomic physics, Schmolze introduced granules. These are hypothetical physical individuals small enough to be part of any substance but large enough to maintain macroscopic properties such as temperature or pressure. By defining objects as sets of granules (using the gset function), the framework allows a robot to track a specific "quantity of liquid" as a persistent entity, even as it is poured, mixed, or divided.
2. Simple Processes
PFR defines "Simple Processes"—such as water flowing from a faucet—through enabling conditions and effects. A process is active if and only if its enabling conditions are met. This is formalized using temporal logic, where relations are treated as functions of time instants, allowing for the representation of continuous change.
3. I/O Programming Language
The framework includes a primitive language for a hypothetical robot, featuring commands like grasp, open.knob, and sensors like Less.full. The ultimate test for the PFR representation is its ability to formally prove that a program written in this language will achieve a desired physical goal.
Key Insights
- Utility-Driven Representation: PFR focuses exclusively on the knowledge necessary for robotic planning, rather than attempting to replicate human cognition.
- Process Identity: The paper establishes formal criteria for the lifecycle of a process (beginning, continuation, and termination). For instance, a flow process is tied to a specific faucet and the state of its control valve over a time interval.
- Evaluation through Proof: The "goodness" of the ontology is measured by its expressive power—specifically, the range of tasks for which one can formally prove a solution exists.
Validation: The Kitchen Task
The paper demonstrates the framework's utility through a formal proof sketch of a common task: filling a pot with water. Starting with initial conditions (a pot positioned under a closed faucet), Schmolze shows that a specific sequence of I/O commands—grasping the knob, opening it, waiting until a sensor indicates the pot is half full, and closing the knob—can be proven to result in the goal state (the pot containing at least 0.5 cups of water). This proof successfully bridges the gap between discrete robotic actions and the continuous natural process of water flow.
Limitations and Future Directions
Despite its formal rigor, PFR faces several challenges:
- The Frame Problem: The proofs rely on default assumptions (e.g., the pot stays put unless moved). A robust theory for managing these assumptions was not fully developed in the paper.
- Hardware Assumptions: The model assumes a level of robotic capability that was "near future" in 1986.
- Complexity: The current model is restricted to "simple" processes where effects depend solely on the physical state, excluding more complex, interdependent interactions.
- Inference Engines: The focus remains on the ontology (what to represent) rather than the inference engine (how to automate the proofs in real-time).
Summary updated