cc-Golog: Towards More Realistic Logic-Based Robot Controllers

AAAI 2000

TL;DR

This paper introduces cc-Golog, a logic-based robot control language that bridges the gap between expressive, event-driven robot programming and formal, predictable reasoning. By extending the situation calculus to handle continuous change and a novel waitFor action, cc-Golog allows for more natural specification of complex robot behaviors while retaining a strong foundation for plan projection and verification.

What Problem Does This Paper Address?

High-level robot controllers in real-world scenarios often need to manage concurrent processes, react to events, and deal with continuously changing environments. Existing logic-based languages like ConGolog are excellent for formal reasoning and plan projection but struggle to express event-driven behaviors naturally. Conversely, languages like RPL are good at expressing these behaviors but lack a formal semantics, making it difficult to predict their execution reliably. This paper addresses the challenge of creating a robot control language that is both expressive enough for realistic, event-driven scenarios and formally grounded for robust reasoning and prediction.

Methods

The authors extend the situation calculus, a logic framework for reasoning about actions and change, in two key ways:

  1. Continuous Change and Time: They introduce a new sort for t-function (functions of time) and a val function to evaluate these functions at specific times. This allows modeling properties that change continuously, like a robot's location. They also introduce a start fluent to track the time a situation begins, enabling temporal reasoning.
  2. Event-Driven Actions (waitFor): A new primitive action, waitFor($)`, is introduced. This action suspends execution until a temporal formula `$ becomes true. Crucially, waitFor advances time to the earliest moment the condition is met, ensuring actions happen "as soon as possible" without explicit time scheduling. This is a core mechanism for event-driven behavior.

Based on this extended situation calculus, they propose cc-Golog, a variant of ConGolog. cc-Golog incorporates new control structures:

  • tryAll(σ1, σ2): Executes σ1 and σ2 concurrently, terminating as soon as either finishes.
  • withPol(σ1, σ2): Executes σ2 (a lower-priority plan) but interrupts it if σ1 (a higher-priority policy) can execute.

These new constructs, along with the temporal extensions, allow for more natural expression of concurrent and prioritized behaviors, including the waitFor action.

Datasets

Not discussed in the paper. The paper uses a simulated robot environment for an example and refers to a modified example from (Beetz & Grosskreutz 1998) for experimental evaluation, which involves a mobile robot delivering letters in a museum-like environment.

Key Insights and Ideas

  • Bridging the Expressiveness Gap: The core insight is that by carefully extending the situation calculus with temporal reasoning and a waitFor action, logic-based languages can achieve the expressiveness of event-driven languages like RPL without sacrificing formal rigor.
  • "As Soon As Possible" Semantics: The waitFor action, by advancing time to the earliest moment a condition is met, naturally enforces an "as soon as possible" execution strategy, which is crucial for realistic robot control.
  • tryAll vs. par: The introduction of tryAll (terminates on first completion) and withPol (prioritized interruption) offers more intuitive control structures for concurrent and interruptible tasks than the standard par (requires all to complete) and prio (prioritized but less interruptible).
  • Formal Semantics for Event-Driven Behavior: The paper demonstrates that event-driven behavior, often a challenge for formal methods, can be elegantly captured within a logical framework.

Key Results

  • Natural Specification: The paper shows how the introductory RPL example can be naturally translated into cc-Golog, demonstrating its expressiveness for realistic scenarios.
  • Performance Advantage: In an experimental evaluation using a modified example, cc-Golog projection took 0.5 seconds, significantly faster than the RPL projection mechanism (XFRM) which took 3.6 seconds on the same hardware. The authors attribute this to cc-Golog's simpler implementation and logical foundation compared to RPL's procedural semantics.
  • Provable Predictions: cc-Golog's logical foundation allows for provable predictions about how robot programs will execute, a key advantage over less formal approaches.

Limitations and Future Work

  • Deterministic Fragment: The paper focuses on the deterministic fragment of ConGolog, and the authors note that nondeterministic actions raise interesting issues.
  • Uncertainty: The current framework does not explicitly handle uncertainty, which is a critical aspect of real-world robotics. The authors mention preliminary work on integrating uncertainty into ConGolog.
  • Execution on Real Robots: The paper discusses the projection mechanism as a way to assess executability in principle, not as a direct execution trace for a robot. Future work could involve combining cc-Golog with incremental interpreters for actual robot execution, especially for handling the link between waitFor and real-time sensor readings.
  • Implementation Details: The paper glosses over some implementation details, such as the reification of formulas and programs in logic and the handling of t-forms.

Summary updated

BibTeX
@inproceedings{2000cc,
  title = {{cc-Golog: Towards More Realistic Logic-Based Robot Controllers}},
  booktitle = {AAAI Conference on Artificial Intelligence},
  year = {2000},
}

Loading related content...

Figure