🤖 machine learning

An Unofficial FastLAS Tutorial: A Programmer's Guide

This paper serves as an unofficial, hands-on programmer's guide to FastLAS 2.2.0, offering a syntax-first introduction with progressively difficult, verified examples to teach users how to construct logic program rules for Inductive Logic Programming while highlighting key differences from related systems.

Original authors: Fabio Aurelio D'Asaro

Published 2026-07-28

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Fabio Aurelio D'Asaro

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

The Detective's Notebook: Teaching Computers to Learn the Rules

Imagine you are a detective trying to solve a mystery, but instead of interviewing witnesses, you are teaching a computer to figure out the rules of the world just by showing it a pile of case files. This is the heart of a field called Inductive Logic Programming (ILP). In the world of computer science, there are two main ways to teach a machine: you can either feed it millions of examples and let it guess patterns (like how a child learns to recognize a dog by seeing thousands of pictures), or you can write down every single rule of the universe in a giant instruction manual (like a strict teacher explaining the laws of physics). ILP is the clever middle ground: it asks the computer to write its own instruction manual based on the clues you give it.

To do this, the computer needs three things: Background Knowledge (the facts it already knows, like "birds have wings"), Examples (specific cases of what happened or didn't happen, like "Tweety flew, but the penguin didn't"), and a Language Bias (a set of rules about what kind of sentences the computer is allowed to write). The goal is for the computer to find the simplest, most accurate set of rules that explains all the examples. Why does this matter? Because in the real world, we often have data but no clear theory. Whether it's figuring out why a security system blocked a user, predicting when a meeting will start, or understanding medical symptoms, being able to automatically generate the "rules of the game" from data is a superpower for solving complex problems.

The Paper: A Programmer's Guide to FastLAS

This document is not a dry, official rulebook; it is a friendly, hands-on "unofficial tutorial" written by a user named Fabio Aurelio D'Asaro for other users. It serves as a guide to a specific tool called FastLAS, a computer program designed to learn these logic rules quickly and efficiently. Think of FastLAS as a high-speed detective that doesn't just guess; it systematically builds a theory, checks it against the evidence, and refines it until it fits perfectly.

The paper explains how to write a "task file" (a .las file) that tells FastLAS what to do. It breaks down the process into four main ingredients:

Background Knowledge: The facts the computer already knows (like a dictionary of definitions).
Language Bias: The "vocabulary" the computer is allowed to use. You tell it, "You can only use words about birds, wings, and flying," preventing it from writing nonsense about space travel.
Examples: The clues. These are split into "positive" examples (things that must happen) and "negative" examples (things that must not happen). The paper highlights a clever trick called Context: you can give the computer a specific scenario (like "It is raining") and ask it to predict what happens in that specific situation, rather than just giving it a global fact.
Scoring (The Bias): This is the computer's judge. You tell it what makes a rule "good." Usually, the computer prefers the shortest, simplest rule (Occam's Razor), but the paper shows you can customize this. You can tell the computer, "I don't care about length; I care about covering the most cases," or "I want to avoid using the word 'dangerous'."

The guide walks the reader through a "ladder" of examples, starting with simple puzzles like "When do I cycle to work?" (Answer: When it's not raining) and moving up to complex real-world problems. It demonstrates how FastLAS can learn to recognize events in video footage (like spotting when two people are meeting) or figure out access control policies for a company (like "Managers with high clearance can enter").

A key finding of the paper is the distinction between two modes of operation: --opl and --nopl.

--opl is the fast, original mode. It works like a detective who assumes the clues are straightforward and the background facts are absolute. It's incredibly quick but can't solve puzzles where the clues are hidden or the background is fuzzy.
--nopl is the slower, more powerful mode. It's like a detective who is willing to dig deeper, making assumptions about hidden causes to solve cases where the obvious clues don't add up. The paper shows that while --opl is usually the best choice for speed, --nopl is necessary when the problem is too complex for simple observation.

The paper also tackles the "scoring" aspect in depth. It explains that you aren't stuck with the computer just finding any rule; you can define exactly what "best" means. For instance, in a security context, you might want a rule that is "most general" (allows the most people in) rather than "shortest." The paper provides code snippets showing how to tweak these settings to get the exact kind of answer you need.

Crucially, the author is very clear about what FastLAS cannot do. It is not a magic wand that solves every type of learning problem. It cannot learn rules that are recursive (rules that refer to themselves, like "A is true if B is true, and B is true if A is true") or handle complex preferences (like "I prefer apples over bananas, but only on Tuesdays"). For those harder problems, the paper points readers to a sibling system called ILASP. FastLAS is built for speed and scalability, handling tens of thousands of examples, but it trades some of that generality for performance.

The guide concludes with a "cheat sheet" for anyone trying to move a task from ILASP to FastLAS, highlighting the small but critical differences in syntax. It emphasizes that while the two systems look similar, they have different philosophies: ILASP is the generalist, and FastLAS is the speed demon. The paper's main contribution is demystifying this speed demon, showing programmers exactly how to harness its power to turn raw data into clear, logical rules, all while keeping the complexity manageable through clever examples and practical tips.

Technical Summary: An Unofficial FastLAS Tutorial

Problem Statement

Inductive Logic Programming (ILP) aims to learn logic programs (hypotheses) from examples and background knowledge. While systems like ILASP provide a general framework for Learning from Answer Sets (LAS), they often struggle with scalability when faced with tens of thousands of examples. The specific problem addressed by FastLAS is the need for a scalable ILP system that can handle large datasets while allowing users to define custom scoring functions for the learned hypotheses, rather than relying on a fixed objective.

This document serves as an unofficial, practical guide to FastLAS 2.2.0, a system designed to bridge the gap between theoretical ILP capabilities and practical, large-scale application. It addresses the difficulty users face in transitioning from general ILP theory or the more general (but slower) ILASP system to the specific syntax, constraints, and algorithmic choices of FastLAS.

Methodology

The guide outlines the methodology of FastLAS through a structured, example-driven approach, focusing on four core components of a learning task:

Background Knowledge ( $B$ ): Written in a subset of Answer Set Programming (ASP) compatible with FastLAS. It includes facts and rules that are fixed and never learned. The system supports standard ASP constructs (facts, rules, integrity constraints, choice rules with bounds) but rejects Clingo-specific extensions like conditional literals and weak constraints within the background program.
Language Bias ( $M$ ): Defined via mode declarations (#modeh, #modeb). These declarations specify the vocabulary (predicates, types, variables) allowed in the learned rules. FastLAS uses typed variables (var(t), const(t)) and a specific mechanism for learning numeric thresholds (num_var(t)) which synthesizes comparison bounds directly from data.
Examples ( $E$ ): Represented as Context-Dependent Partial Interpretations (CDPIs). Each example consists of an ID, a set of inclusions (atoms that must hold), a set of exclusions (atoms that must not hold), and a context (a small ASP program specific to that scenario). This structure allows the system to handle thousands of distinct scenarios without them interfering with one another.
Scoring Bias: A distinctive feature of FastLAS is the #bias directive. Unlike ILASP, which has a fixed objective (minimizing hypothesis length), FastLAS allows users to define a custom scoring function. This function assigns costs to candidate rules based on their structure (e.g., number of literals, specific predicates) and allows for the minimization of a total score comprising rule costs and penalties for uncovered noisy examples.

Algorithms

The guide details two learning algorithms selectable via command-line flags:

--opl (Observational Predicate Learning): The original, faster algorithm. It assumes the target predicates are directly observed in the examples and that the background knowledge yields a single answer set per context.
--nopl (Non-Observational Predicate Learning): A more general but slower algorithm that handles cases where the target predicate is not directly observed (requiring abduction) or where the background admits multiple answer sets.

Key Contributions

The document does not present new theoretical algorithms but rather provides a comprehensive, practical framework for utilizing FastLAS 2.2.0. Its primary contributions are:

Syntax and Semantics Guide: A definitive reference for the .las file format, clarifying the specific dialect of ASP accepted by FastLAS and the precise semantics of mode declarations, examples, and scoring.
Scalability Techniques: Practical advice on writing efficient mode biases, specifically emphasizing the minimization of #maxv (maximum distinct variables) and the careful selection of body modes to prevent combinatorial explosion in the search space.
Handling Limitations: Strategies for working within FastLAS's constraints, such as reframing recursive learning tasks as "verifiers" (learning constraints rather than recursive definitions) and using the background for pre-computed recursive features.
Incremental Learning: A description of the cache mechanism (--write-cache, --read-cache) that allows for incremental learning from data streams, ensuring that the result of processing a new window of data is identical to processing the entire dataset at once.
Porting Cheat-Sheet: A detailed comparison between FastLAS and ILASP, highlighting critical differences in handling negation, constants, example contexts, and the fundamental shift from pruning constraints (ILASP) to scoring functions (FastLAS).

Results and Applications

The guide validates the system through a series of worked examples and case studies, demonstrating FastLAS's ability to:

Learn Complex Rules: Successfully derive rules for propositional logic, typed variables, and numeric thresholds (e.g., learning speed limits for cars based on observed data).
Handle Noise: Utilize weighted examples to tolerate mislabeled data, choosing to abandon low-weight examples rather than learning overly complex rules.
Scale to Real-World Data: The guide references two published applications that serve as case studies:
1. Event Recognition (CAVIAR): Learning definitions of high-level events (e.g., "meeting") from low-level video tracking data involving tens of thousands of examples.
2. Access-Control Policy Learning: Learning security policies from logs of granted and denied requests, where the scoring function can be tuned to prioritize criteria like "least privilege" or "coverage" rather than just rule length.

Significance

The document positions FastLAS as a specialized tool for scalable, custom-scoring ILP. Its significance lies in its ability to process datasets (tens of thousands of examples) that are often intractable for more general ILP systems like ILASP. By decoupling the learning objective from a fixed length metric and allowing users to define custom scoring functions via #bias, FastLAS enables domain-specific optimization (e.g., preferring coverage over brevity in security policies).

The guide emphasizes that while FastLAS trades some generality (e.g., it does not learn recursive rules or preferences directly) for speed and scalability, it remains a powerful tool for learning non-recursive normal rules and constraints. It serves as a practical manual for users to navigate the system's specific constraints and leverage its unique features for large-scale inductive reasoning tasks.