💻 computer science

Learning Compositional Symbolic Task Rules from Demonstrations with Inductive Logic Programming

This paper proposes a decomposed inductive logic programming approach for Learning from Demonstration that infers interpretable, reusable symbolic task rules across multiple abstraction levels, demonstrating strong generalization to complex, unseen scenarios in a synthetic block-assembly environment.

Original authors: Oleh Borys, Karla Stepanova

Published 2026-05-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Oleh Borys, Karla Stepanova

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot how to build a tower out of blocks. Most robots today are like parrots: you show them a video of you stacking a red block, then a blue one, and they try to copy the exact movements. But if you give them a green block or ask them to build a taller tower, they get confused because they only memorized the movements, not the rules.

This paper proposes a different approach. Instead of teaching the robot how to move its arm, the authors teach it what the rules of the game are, using a method called Inductive Logic Programming (ILP). Think of this as teaching the robot the "grammar" of the task rather than just the "accent."

Here is how their system works, broken down into simple concepts:

1. The "Lego Master" Analogy

Imagine you want to teach a child to build a specific type of tower.

Old Way (Standard Learning): You hold the child's hand and move their fingers to stack blocks. They learn the muscle memory. If you change the blocks, they might fail.
This Paper's Way (ILP): You sit the child down and explain the rules: "Red blocks go on the bottom, blue in the middle, and green on top. You can only build towers next to the center spot." Once the child understands these rules, they can build a tower with any blocks, in any spot, as long as they follow the logic.

2. Breaking the Big Task into Small Puzzles

The authors realized that trying to teach a robot all the rules at once is like trying to solve a giant jigsaw puzzle by looking at the whole picture at once—it's too overwhelming.

Instead, they break the task down into three smaller, easier puzzles (levels of abstraction):

Level 1 (The Ingredients): First, the robot learns which material goes where. "Stone goes at the bottom, brick in the middle." It learns this rule from examples.
Level 2 (The Structure): Next, the robot uses the rule it just learned to understand what a "tower" actually is. It learns that a tower is just a list of blocks stacked on top of each other.
Level 3 (The Location): Finally, the robot learns where it is allowed to build. "You can build next to the center, but not on the diagonal."

3. The "Cheat Sheet" Effect

Here is the clever part: Once the robot learns the rule for Level 1 (materials), it writes that rule down and adds it to its "cheat sheet" (background knowledge). When it moves to Level 2, it doesn't have to re-learn about materials; it just uses the cheat sheet.

This is like a student learning math: first, they learn addition. Then, when they learn multiplication, they use addition as a foundation. They don't have to re-learn what "2 + 2" is every time they do a multiplication problem. This makes the learning process faster and the final result much smarter.

4. The Results: Generalization

The researchers tested this in a computer simulation with blocks.

Training: They showed the robot how to build towers of height 2 and 3 using specific blocks.
The Test: They then gave the robot a harder challenge: build a tower of height 4 using a new type of block (wood) that it had never seen before, and in a new location that was blocked off during training.

Because the robot learned the logic (the rules) rather than just copying movements, it succeeded. It figured out, "Oh, the rule says 'wood goes on top,' and the rule says 'I can build next to the center,' so I can build this new tower."

5. Why This Matters (and its Limits)

The Good News:

Human-Readable: The rules the robot learns look like simple "If-Then" sentences (e.g., "If block is stone, then place at level 1"). Humans can read them and understand exactly why the robot made a decision.
Efficient: It needs fewer examples to learn because it builds on what it already knows.

The Catch:

Manual Setup: Right now, humans still have to do a lot of the heavy lifting. A human has to tell the robot what rules to look for and how to describe the blocks. The robot isn't fully autonomous yet; it needs a human to set the stage.
Simple Worlds: This works great for discrete, clear-cut tasks like sorting blocks or assembling toys. It struggles with messy, real-world things where things aren't clearly defined (like a wet, slippery table).

Summary

This paper presents a way to teach robots by helping them discover the logic behind a task, rather than just memorizing the actions. By breaking a complex job into small, logical steps and letting the robot reuse what it learns from one step to help with the next, the robot becomes much better at handling new, tricky situations it hasn't seen before. It's the difference between teaching a robot to dance by moving its feet, versus teaching it the rhythm and steps so it can dance to any song.

Technical Summary: Learning Compositional Symbolic Task Rules from Demonstrations with Inductive Logic Programming

Problem Formulation
The paper addresses a limitation in standard Learning from Demonstration (LfD), where robots often learn only how to execute a task (low-level action reproduction) without recovering the underlying what (high-level symbolic task structure). The authors argue that for increasing autonomy, task representations must be inspectable, reusable, and human-interpretable. The core problem is defined as recovering explicit task knowledge from observed executions in a discrete manipulation domain (e.g., block assembly). The system must infer symbolic rules that explain demonstrated behavior across different abstraction (ontological) levels, moving beyond statistical pattern matching to induce logic-rich rules.

Methodology
The proposed framework utilizes Inductive Logic Programming (ILP), specifically the state-of-the-art solver Popper, to induce symbolic task rules. The methodology is characterized by a decomposed, hierarchical learning approach:

Task Decomposition: Instead of learning a monolithic task program, the complex task is broken down into an ordered sequence of simpler, task-relevant learning targets ( $\Psi_{learn} = [\tau_1, \dots, \tau_K]$ ) at different abstraction levels.
Iterative Rule Induction: For each target predicate $\tau$ $τ$ , the system:
- Grounds demonstrations into abstract states using a background program $B$ (containing object ontologies and environment definitions).
- Extracts positive ( $E^+$ ) and negative ( $E^-$ ) examples.
- Uses Popper to induce a hypothesis $H_\tau$ (a set of definite clauses) that explains the data under the current background knowledge.
Knowledge Reuse: Crucially, after learning a target, the induced rules ( $H_\tau$ ) are added back into the background knowledge ( $B \leftarrow B \cup H_\tau$ ). This allows subsequent, higher-level targets to reuse previously learned abstractions (e.g., using a learned "material-to-level" mapping to define a "tower" concept).
Execution: At test time, a Prolog-based planner uses the union of all learned rules ( $H = \bigcup H_\tau$ ) to constrain the search space, enumerating candidate action sequences and pruning those that violate the learned symbolic constraints to produce a valid pick-and-place plan.

Key Contributions

ILP-based Framework for Task-Level LfD: The paper presents a novel framework that learns and reuses first-order logic compositional rules across abstraction levels, contrasting with approaches relying on latent neural representations or stochastic grounding which offer only partial interpretability.
Evaluation in Synthetic Block-Assembly: The authors provide both qualitative and quantitative evaluations in a synthetic domain. They demonstrate that the learned rules are interpretable, support planning, and generalize to harder, held-out tasks involving unseen objects (e.g., new materials) and unseen placement locations.

Experimental Results
The system was evaluated in a 3x3 grid world where a robot builds towers of varying heights (2–4 blocks) using blocks of different materials (stone, brick, glass, wood).

Generalization: The system successfully generalized to test tasks requiring taller towers (height 4) and different placement sites than those seen in training.
Data Efficiency: To achieve 100% goal satisfaction and logical rule match across all targets, the system required an average of 243 demonstrations (40 for target_z, 166 for tower_from, and 37 for tower_site). When demonstrations were manually selected to maximize constraint density, this requirement dropped to 77 total demonstrations.
Interpretability: The learned rules were compact and human-readable. For instance, the system learned recursive definitions for tower structures and compositional rules for material placement (e.g., "stone blocks are assigned to level z1") rather than memorizing specific coordinates.
Performance: Inducing rules and planning took only a few seconds per task on a standard CPU.

Significance and Claims
The paper claims to provide preliminary evidence that decomposing complex tasks into simpler learning objectives makes ILP a feasible approach for task-level LfD. The authors emphasize that their approach offers strong generalization and interpretability compared to neuro-symbolic methods that rely on Vision-Language Models (VLMs) for complex predicate evaluation, which can be unreliable.

The paper maintains a modest tone regarding its scope:

It focuses on the symbolic core and synthetic evaluation, acknowledging that real-world integration requires future work on perception modules and probabilistic reasoning.
It explicitly notes limitations, including the system's lack of autonomy (requiring manual specification of target predicates, biases, and encodings) and the combinatorial nature of searching First-Order Logic hypotheses, which can lead to scalability issues if the background knowledge is too extensive.
Future work is proposed to address these limitations through automated predicate invention, bias generation, and the integration of probabilistic logic (e.g., Scallop) to handle noisy real-world inputs.