💻 computer science

Automaton-based Characterisations of First Order Logic over Infinite Trees

This paper establishes that First-Order Logic over infinite trees is precisely captured by two classes of hesitant tree automata corresponding to \PolPCTL and \CTLsf, thereby providing a uniform automata-theoretic characterisation and revealing that first-order definability is fundamentally limited to safety or co-safety properties along each branch.

Original authors: Massimo Benerecetti, Dario Della Monica, Angelo Matteo, Fabio Mogavero, Gabriele Puppis

Published 2026-04-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Massimo Benerecetti, Dario Della Monica, Angelo Matteo, Fabio Mogavero, Gabriele Puppis

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 Big Picture: Mapping the Forest

Imagine you are trying to describe a massive, infinite forest. You have two tools to do this:

First-Order Logic (FO): A very precise, rule-based language (like a strict set of instructions) that can talk about individual trees, their parents, their children, and how they are connected.
Tree Automata: A type of robot that walks through the forest, checking if the trees follow certain rules.

The paper's main goal is to answer a difficult question: Can we build a specific kind of robot that can check exactly the same things as our strict rule-based language?

In the world of simple lines (like a single path of trees), we already know the answer: yes, there is a perfect match. But in a branching forest (where trees split into many children), things get messy. The authors of this paper finally built the perfect robots for this branching world.

The Two Types of Robots

The authors didn't just build one robot; they built two different types that both do the same job, but in very different ways.

1. The "Back-and-Forth" Robot (Two-Way Linear HTA)

Think of this robot as a hiker with a map.

How it moves: It can walk forward to a child tree, but it can also look back at its parent tree. It can go up and down the family tree.
How it thinks: It is very simple-minded. It only has one "mode" of thinking at any given time (it's "linear"). It can't hold complex thoughts about multiple paths at once.
The Catch: Because it can look back (past), it can understand history. The paper shows that this robot is powerful enough to check everything our strict rule-based language can check.

2. The "One-Way" Robot with Special Glasses (Counter-Free Visible HTA)

Think of this robot as a tour guide walking only forward.

How it moves: It can only walk down from parent to child. It cannot look back.
How it thinks: It has a more complex mind. It can split into groups (components) to handle different tasks. However, it has two strict rules:
- No Loops: It cannot get stuck in a repetitive cycle of checking the same thing over and over (this is called "counter-free").
- Clear Vision (Visibility): When it makes a decision, it must be crystal clear. It can't be ambiguous. If it says "Go left," it must be 100% sure that "Go left" means one specific thing and "Go right" means the exact opposite.
The Result: Even though it can't look back, its strict rules about clarity and non-repetition allow it to check the exact same things as the strict rule-based language.

The "Polarization" Secret

One of the paper's most interesting discoveries is a hidden pattern called Polarization.

Imagine the forest has two types of rules:

Safety Rules: "Nothing bad ever happens." (e.g., "No tree is ever on fire.")
Co-Safety Rules: "Something good eventually happens." (e.g., "A flower will eventually bloom.")

The authors found that the strict rule-based language (FO) has a weird limitation:

If you are looking for a path where something good happens (existential), you can only describe Co-Safety properties (good things eventually happening).
If you are looking for a path where nothing bad happens (universal), you can only describe Safety properties (bad things never happening).

You can't mix them easily. It's like saying, "I can only promise that a good thing will happen if I'm looking for a specific path, but I can only promise that a bad thing won't happen if I'm checking all paths." The paper proves this isn't just a quirk of the language; it's a fundamental law of how these rules work on infinite trees.

Why This Matters

Before this paper, we knew that the strict rule-based language (FO) was powerful, but we didn't have a perfect "robot" to check it. We had to guess or use complicated math.

Now, we have two clear blueprints:

The Hiker: If you want to check these rules, build a robot that can walk up and down but keeps its thoughts simple.
The Tour Guide: If you want to build a robot that only walks down, make sure it never loops and always speaks clearly.

This gives computer scientists a "normal form"—a standard, clean way to write these rules and build the machines to check them. It's like finally finding the perfect translation dictionary between two different languages, allowing us to build better software verification tools that can prove complex systems (like traffic lights or network protocols) will never crash.

Summary

The paper solves a long-standing puzzle by showing that First-Order Logic (a strict rule language) over infinite trees is perfectly matched by two specific types of Tree Automata (robots). One robot moves back and forth but thinks simply; the other moves only forward but thinks with strict clarity. They also discovered a fundamental rule: this logic can only describe "safety" (nothing bad) or "co-safety" (something good) depending on how you look at the tree, revealing a sharp boundary in what these rules can express.

1. Problem Statement

The paper addresses the fundamental problem of characterizing the expressive power of First-Order Logic (FO) over unranked, unordered, infinite trees.

Context: While the correspondence between FO and automata is well-understood for linear structures (words), the branching-time setting (trees) presents significant structural challenges. A major open problem, posed by Thomas in the 1980s, asks whether it is decidable if a given regular tree language is FO-definable.
Gap: Existing algebraic approaches (e.g., using syntactic algebras) have yielded only partial results, mostly for finite trees or specific topological classes. There is a lack of a complete, uniform automaton-theoretic characterization for FO over infinite trees that captures its full expressive power without relying on Monadic Second-Order Logic (MSO).
Goal: To provide robust characterizations of FO over infinite trees using specific classes of hesitant tree automata and to identify the precise structural limitations of FO in this setting.

2. Methodology

The authors employ a multi-faceted approach combining logic, automata theory, and model theory:

Logical Equivalence: The authors build upon known results establishing that FO over infinite trees is expressively equivalent to two specific branching-time temporal logics:
- PastCTL $^\pm$ : A fragment of CTL with past operators and counting modalities.
- CTL $^*_f$ : Full Computation Tree Logic restricted to finite path quantification.
Automaton Classes: They introduce and analyze two specific classes of Hesitant Tree Automata (HTA):
- Two-Way Linear Polarised Hesitant Tree Automata (2W-L-HTA $^\pm$ ): These allow the automaton head to move up (to the parent) and down (to children). The "linear" restriction requires the state space to be partitioned into singleton components.
- Counter-Free Visible Polarised Hesitant Tree Automata (CF-V-HTA $^\pm$ ): These are one-way automata. They impose two key restrictions:
  - Counter-freeness: The linearization of each component (viewed as an $\omega$ -word automaton) must be counter-free (aperiodic).
  - Visibility: A semantic condition ensuring that annotations (sets of atoms representing sub-formulas) used in transitions are mutually exclusive in a way that prevents "hidden" counting behavior.
Polarization Analysis: The authors investigate a "polarization" property where existential path quantifiers are restricted to co-safety properties, and universal path quantifiers are restricted to safety properties. They show this is a fundamental semantic feature of FO over trees.
Translation and Normalization: They construct effective translations between the logical formalisms and the automata, and derive a new normal form for CTL $^*$ (denoted CTL $^*_\pm$ ) that syntactically enforces the polarization property.

3. Key Contributions

A. New Automaton Characterizations

The paper provides the first complete automaton-based characterizations of FO over infinite trees:

Theorem 5.1 & 5.2: Two-Way Linear HTA $^\pm$ are expressively equivalent to PastCTL $^\pm$ (and thus to FO). This is surprising because FO over words is characterized by one-way alternating automata, whereas FO over trees requires two-way movement to achieve full expressiveness, even with the severe "linear" (singleton component) restriction.
Theorem 7.4 & 7.5: Counter-Free Visible HTA $^\pm$ are expressively equivalent to CTL $^*_f$ (and thus to FO). This characterization uses standard one-way automata but requires the complex "visibility" and "counter-free" constraints on the components.

B. Logical Normal Forms and Polarization

CTL $^*_\pm$ : The authors introduce a new syntactic fragment of CTL $^*$ called CTL $^*_\pm$ . They prove that CTL $^*_f$ (semantically restricted to finite paths) is equivalent to this syntactic fragment.
Polarization Property: They demonstrate that FO formulas over trees exhibit a strict polarization:
- Formulas with existential path quantification can only express co-safety properties (properties where a violation is witnessed by a finite prefix).
- Formulas with universal path quantification can only express safety properties (properties where a violation is witnessed by a finite prefix, but the property holds if no violation occurs).
- This reveals a sharp boundary: FO cannot express properties that mix safety and co-safety along a single branch in a non-polarized way.

C. Linear-Time Results

As a side contribution, the paper provides a direct automaton-based characterization for the safety and co-safety fragments of Linear Temporal Logic (LTL):

SafeLTL is equivalent to Counter-free Looping Universal Büchi Automata (UBA).
coSafeLTL is equivalent to Counter-free Looping Nondeterministic co-Büchi Automata (NCA).
This serves as a foundational analogue for the tree results.

4. Key Results

Equivalence Chain:
$\text{FO} \equiv \text{PastCTL}^\pm \equiv \text{CTL}^*_f \equiv \text{CTL}^*_\pm \equiv \text{2W-L-HTA}^\pm \equiv \text{CF-V-HTA}^\pm$
This establishes a full mutual equivalence between the logic, its temporal variants, and two distinct classes of automata.
Two-Way vs. One-Way:
- Two-Way Linear HTA $^\pm$ (with singleton components) are strictly more expressive than Linear HTA $^\pm$ (one-way). The two-way capability is essential for capturing FO over trees when components are restricted to singletons.
- Counter-Free Visible HTA $^\pm$ (one-way) achieve the same power as the two-way models but require complex internal structures (components acting as counter-free word automata) and the visibility constraint.
Expressive Limitation:
The polarization result implies that FO over infinite trees cannot define properties that require "mixing" safety and co-safety along a branch without a specific structural separation. For instance, it cannot define properties that require checking a safety condition and a co-safety condition simultaneously in a way that violates the polarization constraint.

5. Significance and Implications

Resolution of Definability Questions: While the general decidability of FO-definability for regular tree languages remains open, this work provides a concrete, automata-theoretic framework to analyze and potentially decide definability for specific classes of languages.
Understanding FO Structure: The results deepen the understanding of why FO is "ill-behaved" or unpredictable over trees compared to words. The necessity of two-way movement in the linear automaton model highlights the complexity of navigating tree structures with first-order constraints.
Bridge to MSO Fragments: The paper connects FO to Weak Chain Logic (WCL) and the Modal $\mu$ -calculus, showing that the polarization phenomenon observed in FO also appears in WCL. This suggests a hierarchy of expressiveness where FO sits strictly below Monadic Path Logic (MPL) and CTL $^*$ .
Future Directions: The authors identify that extending these results to finite trees remains a major challenge, particularly regarding the lack of a decomposition theorem for deterministic tree automata (unlike the Krohn-Rhodes theorem for words). They also pose the open problem of finding a direct translation between the two-way linear and one-way visible automata models, which would provide deeper structural insights.

In summary, this paper successfully bridges the gap between First-Order Logic and automata theory over infinite trees by introducing novel automaton classes and revealing a fundamental "polarization" constraint inherent to first-order definability in branching-time structures.