Abstract 1 Introduction 2 Preliminaries and Definitions 3 Learning with unbounded use of binary operators 4 Learning with a bounded amount of binary operators 5 Future Work References

The Complexity of Learning LTL, CTL and ATL Formulas

Benjamin Bordais ORCID TU Dortmund University, Center for Trustworthy Data Science and Security, University Alliance Ruhr, Dortmund, Germany Daniel Neider ORCID TU Dortmund University, Center for Trustworthy Data Science and Security, University Alliance Ruhr, Dortmund, Germany Rajarshi Roy ORCID Department of Computer Science, University of Oxford, UK
Abstract

We consider the problem of learning temporal logic formulas from examples of system behavior. Learning temporal properties has crystallized as an effective means to explain complex temporal behaviors. Several efficient algorithms have been designed for learning temporal formulas. However, the theoretical understanding of the complexity of the learning decision problems remains largely unexplored. To address this, we study the complexity of the passive learning problems of three prominent temporal logics, Linear Temporal Logic (LTL), Computation Tree Logic (CTL) and Alternating-time Temporal Logic (ATL) and several of their fragments. We show that learning formulas with unbounded occurrences of binary operators is NP-complete for all of these logics. On the other hand, when investigating the complexity of learning formulas with bounded occurrences of binary operators, we exhibit discrepancies between the complexity of learning LTL, CTL and ATL formulas (with a varying number of agents).

Keywords and phrases:
Temporal logic, passive learning, complexity
Copyright and License:
[Uncaptioned image] © Benjamin Bordais, Daniel Neider, and Rajarshi Roy; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation
Related Version:
Full Version: https://arxiv.org/abs/2408.04486 [8]
Funding:
Rajarshi Roy acknowledges partial funding by the ERC under the European Union’s Horizon 2020 research and innovation programme (grant agreement No.834115, FUN2MODEL).
Editors:
Olaf Beyersdorff, Michał Pilipczuk, Elaine Pimentel, and Nguyễn Kim Thắng

1 Introduction

Temporal logics are the de-facto standard for expressing temporal properties for software and cyber-physical systems. Originally introduced in the context of program verification [33, 15], temporal logics are now well-established in numerous areas, including reinforcement learning [40, 25, 10], motion planning [17, 12], process mining [13], and countless others. The popularity of temporal logics can be attributed to their unique blend of mathematical rigor and resemblance to natural language.

Until recently, formulating properties in temporal logics has been a manual task, requiring human intuition and expertise [6, 39]. To circumvent this step, in the past ten years, there have been numerous works to automatically learn (i.e., generate) properties in temporal logic. Among them, a substantial number of works [29, 11, 35, 26, 41] target Linear Temporal Logic (LTL) [33]. There is now a growing interest in learning formulas [16, 34, 9] in Computation Tree Logic (CTL) [15] and Alternating-time Temporal Logic (ATL) [1] due to their ability to express branching-time properties, including for multi-agent systems.

While existing approaches for learning temporal properties demonstrate impressive empirical performance, detailed comparisons of computational complexity across different temporal logics remain underexplored. Most related works focus on LTL, either in the verification domain [18, 27] or the database domain [19, 24]. These studies primarily report complexity results, often highlighting 𝖭𝖯-completeness for learning LTL-formulas and their fragments. In contrast, the computational complexity of learning CTL- and ATL-formulas has not yet been thoroughly examined.

In this work, we extend the study of learning temporal properties to include CTL- and ATL-formulas. Additionally, we broaden existing results for LTL to cover a more comprehensive set of operators, specifically addressing all binary operators (temporal or not).

To elaborate on our contributions, let us precisely describe the problem that we consider, the passive learning problem for temporal logic [29, 11]. Its decision version asks the following question: given two sets 𝒫, 𝒩 of positive and negative examples of a system’s behavior and a size bound B, does there exist a “separating” formula of size at most B, which is satisfied by the positive examples and violated by the negative ones.

Our instantiation of the above problem depends on the considered logic, following related literature [29, 34, 9]: LTL-formulas express linear-time properties, CTL-formulas express branching-time properties, and ATL-formulas express properties on multi-agent systems. Accordingly, the input examples for learning LTL, CTL and ATL are linear structures (or equivalently infinite words), Kripke structures and concurrent game structures, respectively. We refer to Section 2 for formal definitions and other prerequisites.

We summarize our contributions in Table 1.

Our first result, illustrated in the left column, shows that allowing formulas with unrestricted use of at least one binary operator makes the corresponding learning decision problem 𝖭𝖯-complete for all considered logics. Some of these 𝖭𝖯-hardness results are (closely) inspired by [27], involving reductions from the hitting set problem – one of Karp’s 21 𝖭𝖯-complete problem; some others require novel proof techniques, e.g. one involves a reduction from an 𝖭𝖯-complete modulo-2 calculus problem. We describe the outline of the proofs in Section 3.

Table 1: The complexity results for learning LTL, CTL and ATL formulas. The notation 𝖠𝖳𝖫k refers to 𝖠𝖳𝖫-formulas with k agents. 𝖴𝗍{¬,𝐗,𝐅,𝐆} refers to the set of unary temporal operators.
Unbounded Bounded use of binary operators
use of binary 𝐗𝖴𝗍 𝐗𝖴𝗍
operators {𝐅,𝐆}𝖴𝗍 𝖴𝗍={𝐅},{𝐆}
𝖫𝖳𝖫 𝖭𝖯-c 𝖫
𝖢𝖳𝖫 𝖭𝖯-c 𝖭𝖫-c
𝖠𝖳𝖫2 𝖭𝖯-c 𝖯-c
𝖠𝖳𝖫k 𝖭𝖯-c

All of the above 𝖭𝖯-hardness proofs rely on separating formulas with linearly many (in the size of the input) occurrences of binary operators. Thus, in the search of expressive temporal logic fragments with lower complexities, we focus on formulas with a bounded occurrences of binary logical operators such as (and), (or), etc. and no binary temporal operators such as 𝐔 (until), 𝐑 (release), etc. This choice of formulas is motivated by the fact that such formulas can still express interesting properties (e.g., GR(1) [32] formulas, mode-target formulas [4], etc.) and are used in several practical applications (see Section 4.1 for details). We explore several fragments with different unary temporal operators, 𝐗 (next), 𝐅 (eventually) and 𝐆 (globally), and present the results in the rightmost column of Table 1. We notice that, in this case, the complexity of the learning problems varies considerably between different logics and unary operators. Importantly, we exhibit fragments where the learning problem is below 𝖭𝖯. We prove the three 𝖭𝖯-hardness results using a reduction from the hitting set problem; we give key insights on all of these results in Section 4.

All details can be found in the extended version [8].

Related Works.

The most closely related works are [18] and [27], which operate within a similar framework to ours. Both works consider learning problems in several fragments of LTL, especially involving boolean operators such as and , and temporal operators such as 𝐗, 𝐅 and 𝐆 and prove their 𝖭𝖯-completeness. We extend part of their work by categorizing fragments based on the arity of the operators and studying which type of operators contribute to the hardness. Moreover, there are several differences in the parameters considered for the learning problem. The most important one is the following: the above works consider the size upper bound B to be in binary, while we assume B given in unary. Although, in complexity problems, integers are most often assumed to be written in binary, we believe that considering size bound in unary is justified since one may want to not only decide the existence of a formula but also effectively output one, which will require to explicitly write it. The other differences with the setting of the above works are mostly due to the fact that we do not only consider 𝖫𝖳𝖫 learning, but 𝖢𝖳𝖫 and 𝖠𝖳𝖫 learning as well. A thorough discussion of these differences can be found in the extended version of this paper [8].

In the past, complexity analysis of passive learning has been studied for formalisms other than temporal logics. For instance, [21] and [2] proved 𝖭𝖯-completeness of the passive learning problems of deterministic finite automata (DFAs) and regular expressions (REs).

When it comes to temporal logics, most related works focus on developing efficient algorithms for learning temporal logic formulas. Among these, the emphasis has predominantly been on learning LTL (or its significant fragments), which has been discussed in detail in a recent survey summarizing various learning techniques [30]. Broadly, the techniques can be categorized into three main types: constraint solving [29, 11, 37, 20, 22], enumerative search [35, 41], and neuro-symbolic techniques [26, 42].

For learning CTL, some approaches rely on handcrafted templates [14, 43] for simple enumerative search, while others employ constraint-solving methods to learn formulas with arbitrary structures [34]. The constraint-solving methods are extended to learn ATL-formulas as well [9]. There are also works on learning other logics such as Signal Temporal Logic [7, 28], Metric Temporal Logic [36], Past LTL [3], Property Specification Language [38], etc.

2 Preliminaries and Definitions

We let denote the set of all integers and 1 denote the set of all positive integers. For all ij, we let [i,,j] denote the set of integers {i,i+1,,j}.

Given any non-empty set Q, we let Q,Q+ and Qω denote the sets of finite, non-empty finite and infinite sequences of elements in Q, respectively. For all ρQ+, we denote by |ρ| the number of elements of ρ. For all {+,ω}, ρQ and i1, if ρ has at least i elements, we let: ρ[i]Q denote the i-th element in ρ, in particular ρ[1]Q is the first element of ρ; ρ[:i]Q+ denotes the non-empty finite sequence ρ1ρiQ+; ρ[i:]Q denotes the non-empty sequence ρiρi+1Q, in particular we have ρ[1:]=ρ.

For the remainder of this section, we fix a non-empty set of propositions 𝖯𝗋𝗈𝗉.

2.1 Structures

Usually, ATL-formulas are interpreted on concurrent game structures, i..e. games where, at each state, the concurrent actions of several agents have an impact on the next state reached. A special kind of concurrent game structures are turn-based game structures, where each state belongs to a specific agent who decides what the next state is. Here, we introduce only this special kind of games mainly due to a lack of space, but also because all of our hardness results, presented in Table 1, hold even when only considering turn-based game structures.

Definition 1.

A turn-based game structure (TGS for short) T=Q,I,𝖲𝗎𝖼𝖼,𝖠𝗀,α,𝖯𝗋𝗈𝗉,π is a tuple where: Q is a finite set of states; IQ is the set of initial states; 𝖲𝗎𝖼𝖼:Q2Q maps each state to its set of successors; 𝖠𝗀 denotes the set of agents; α:Q𝖠𝗀 maps each state to the agent owning it; and π:Q2𝖯𝗋𝗈𝗉 maps each state qQ to the set of propositions that hold in q. A state q is said to be self-looping if q𝖲𝗎𝖼𝖼(q). A structure is self-looping if all of its states are self-looping.

For all coalitions of agents A𝖠𝗀, a strategy 𝗌A for the coalition A is a function 𝗌A:Q+Q such that, for all ρ=ρ1ρnQ+, if α(ρn)A, then sA(ρ)𝖲𝗎𝖼𝖼(ρn). We denote by 𝖲A the set of strategies for the coalition A. Then, from any state qQ, we define the set 𝖮𝗎𝗍(q,𝗌A) of infinite paths compatible with the strategy sA from q: 𝖮𝗎𝗍(q,𝗌A):={ρqQωi1:α(ρ[i])Aρ[i+1]=𝗌A(ρ[:i])}.

Finally, the size |T| of the turn-based structure T is equal to: |T|=|Q|+|𝖠𝗀|+|𝖯𝗋𝗈𝗉|.

Unless otherwise stated, a turn-based structure T will always refer to the tuple T=Q,I,𝖲𝗎𝖼𝖼,A,α,𝖯𝗋𝗈𝗉,π.

There are also special kinds of turn-based structures of interest for us, introduced below.

Definition 2.

A Kripke structure is a turn-based structure with only one agent. A linear structure is a Kripke structure such that: |I|=1, and for all qQ, we have |𝖲𝗎𝖼𝖼(q)|=1. Finally, a turn-based structure is size-1 if |Q|=1.

Unless otherwise stated, a Kripke structure K will always refer to a tuple Q,I,𝖲𝗎𝖼𝖼,𝖯𝗋𝗈𝗉,π111In Kripke structures, there is only one agent, thus 𝖠𝗀 and α are irrelevant..

We have introduced the notion of linear structures as we are going to interpret LTL-formulas on them. In the literature, they are usually interpreted on ultimately periodic words. However, both models are equivalent and can be encoded into each other straightforwardly.

2.2 ATL, CTL and LTL formulas

The 𝖫𝖳𝖫, 𝖢𝖳𝖫 and 𝖠𝖳𝖫-formulas that we consider throughout this paper use the following temporal operators: 𝐗 (neXt), 𝐅 (Future), 𝐆 (Globally), 𝐔 (Until), 𝐑 (Release), 𝐖 (Weak until), 𝐌 (Mighty release). We group these operators into the sets of unary and binary operators: 𝖮𝗉𝖴𝗇:={¬,𝐗,𝐅,𝐆} and 𝖮𝗉𝖡𝗂𝗇𝗍𝗉:={𝐔,𝐑,𝐖,𝐌}. We also let 𝖮𝗉𝖡𝗂𝗇𝗅𝗀 be the set of all logical binary operators, i.e. classical logical operators, along with their negations: 𝖮𝗉𝖡𝗂𝗇𝗅𝗀:={,,,,,¬,¬,¬,¬,¬} (we have |𝖮𝗉𝖡𝗂𝗇𝗅𝗀|=10).

To define ATL-formulas, we consider two types of formulas: state formulas – where strategic operators occur, denoted with the Greek letter ϕ – and path formulas – where temporal operators occur, denoted with the Greek letter ψ. Consider some 𝖴𝗍𝖮𝗉𝖴𝗇, 𝖡𝗍𝖮𝗉𝖡𝗂𝗇𝗍𝗉, and 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀. For all k1, we denote by 𝖠𝖳𝖫k(𝖯𝗋𝗈𝗉,𝖴𝗍,𝖡𝗍,𝖡𝗅) the set of 𝖠𝖳𝖫k-state formulas defined by the grammar:

ϕp¬ϕϕϕAψ

ψ1ϕϕ2ϕ

where ϕ is a state-formula, ψ is a path formula, p𝖯𝗋𝗈𝗉, 𝖡𝗅, A[1,,k] is a subset of agents, 1𝖴𝗍{¬}, and 2𝖡𝗍. We denote by 𝖠𝖳𝖫k the set of all 𝖠𝖳𝖫k-state formulas ϕ. Note that 𝖢𝖳𝖫-formulas are 𝖠𝖳𝖫1(𝖯𝗋𝗈𝗉,𝖴𝗍,𝖡𝗍,𝖡𝗅)-formulas. Hence, there are only two possible strategic operator: , usually denoted , and {1} usually denoted . We define 𝖫𝖳𝖫-formulas as 𝖠𝖳𝖫1-formulas using only the quantifier . Since 𝖫𝖳𝖫-formulas are interpreted on linear structures, where each state has exactly one successor, the strategic operators used have no impact on the satisfaction of the formula. For readability, we will depict 𝖫𝖳𝖫-formulas without the quantifier.

The set of sub-formulas 𝖲𝗎𝖻𝖥(ϕ) of a formula ϕ is then defined inductively as follows: 𝖲𝗎𝖻𝖥(ϕ):={ϕ}S where S:= if ϕ=p𝖯𝗋𝗈𝗉, S:=𝖲𝗎𝖻𝖥(ϕ) if ϕ{¬ϕ,A1ϕ} and S:=𝖲𝗎𝖻𝖥(ϕ1)𝖲𝗎𝖻𝖥(ϕ2) if ϕ{ϕ1ϕ2,A(ϕ12ϕ2)}. The size |ϕ| of a formula is then defined as its number of sub-formulas: |ϕ|:=|𝖲𝗎𝖻𝖥(ϕ)|. We also denote by |ϕ|𝖻𝗂𝗇 the number of sub-formulas of ϕ using a binary operator, |ϕ|𝖻𝗂𝗇:=|𝖲𝗎𝖻𝖡𝗂𝗇(ϕ)| with: 𝖲𝗎𝖻𝖡𝗂𝗇(ϕ):={ϕ1ϕ2𝖲𝗎𝖻𝖥(ϕ)ϕ1,ϕ2𝖲𝗎𝖻𝖥(ϕ),𝖮𝗉𝖡𝗂𝗇𝗍𝗉𝖮𝗉𝖡𝗂𝗇𝗅𝗀}.

We interpret 𝖠𝖳𝖫-formulas over TGS using the standard definitions [1]. That is, given a state q and a state formula ϕ, the fact q satisfies ϕ, denoted qϕ, is defined inductively:

q p iff pπ(q)
q ¬ϕ iff q⊧̸ϕ
q ϕ1ϕ2 iff (qϕ1)(qϕ2)=𝖳𝗋𝗎𝖾
q Aψ iff 𝗌A𝖲A,π𝖮𝗎𝗍(q,s),πψ

where 𝖮𝗉𝖡𝗂𝗇𝗅𝗀 is a binary operator seen as a boolean function :𝔹×𝔹𝔹 with 𝔹:={𝖳𝗋𝗎𝖾,𝖥𝖺𝗅𝗌𝖾}. Furthermore, given a path πQω and a path formula ψ, the fact that ψ holds for the path π, also denoted πϕ, is defined inductively as follows:

π 𝐗ϕ iff π[2:]ϕ;
π 𝐅ϕ iff i1,π[i:]ϕ;
π 𝐆ϕ iff i1,π[i:]ϕ
π ϕ1𝐖ϕ2 iff π(ϕ1𝐔ϕ2)𝐆ϕ1
π ϕ1𝐔ϕ2 iff i1,π[i:]ϕ2 and
1ji1,π[j:]ϕ1
π ϕ1𝐑ϕ2 iff π¬(¬ϕ1𝐔¬ϕ2)
π ϕ1𝐌ϕ2 iff π(ϕ1𝐑ϕ2)𝐅ϕ1

An 𝖠𝖳𝖫-formula ϕ accepts a TGS T, denoted by Tϕ, if qϕ for all initial states qI, otherwise it rejects it. Given two formulas ϕ,ϕ, we write ϕϕ if, for all TGS T, if Tϕ, then Tϕ. We write ϕϕ when ϕϕ and ϕϕ.

2.3 Learning decision problem

We define the 𝖫𝖳𝖫, 𝖢𝖳𝖫 and 𝖠𝖳𝖫 learning problems below, where models for 𝖫𝖳𝖫, 𝖢𝖳𝖫, and 𝖠𝖳𝖫 are linear structures, Kripke structures and turn-based game structures, respectively.

Definition 3.

Let 𝖳𝖫{𝖫𝖳𝖫,𝖢𝖳𝖫,𝖠𝖳𝖫kk1} and consider some sets of operators 𝖴𝗍𝖮𝗉𝖴𝗇, 𝖡𝗍𝖮𝗉𝖡𝗂𝗇𝗍𝗉 and 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀. For all n{}, we denote by 𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,𝖡𝗍,𝖡𝗅,n) the decision problem:

  • Input: (𝖯𝗋𝗈𝗉,𝒫,𝒩,B) where 𝖯𝗋𝗈𝗉 is a set of propositions, 𝒫,𝒩 are two finite sets of models for 𝖳𝖫, and B.

  • Output: yes if and only if there exists a 𝖳𝖫-formula φ𝖳𝖫(𝖯𝗋𝗈𝗉,𝖴𝗍,𝖡𝗍,𝖡𝗅) such that |φ|B, |φ|𝖻𝗂𝗇n, and φ is separating, i.e. such that : for all X𝒫 (resp. X𝒩), we have Xφ (resp. X⊧̸φ).

The size of the input is equal to |𝖯𝗋𝗈𝗉|+|𝒫|+|𝒩|+B (i.e. B is written in unary).

As the model checking problems for 𝖫𝖳𝖫, 𝖢𝖳𝖫, 𝖠𝖳𝖫 are in 𝖯 [1], it follows that the learning problems for all these logics are in 𝖭𝖯, with a straightforward guess-and-check subroutine.

Proposition 4.

For all 𝖴𝗍𝖮𝗉𝖴𝗇, 𝖡𝗍𝖮𝗉𝖡𝗂𝗇𝗍𝗉, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, n{}, and 𝖳𝖫{𝖫𝖳𝖫,𝖢𝖳𝖫,𝖠𝖳𝖫kk1}, the decision problem 𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,𝖡𝗍,𝖡𝗅,n) is in 𝖭𝖯.

2.4 Hitting set problem

We recall below the 𝖭𝖯-complete problem from which we will establish almost all of our (𝖭𝖯-hardness) reductions.

Definition 5 (Hitting set problem).

We denote by 𝖧𝗂𝗍 the following decision problem:

  • Input: a triple (l,C,k) where l1, C=C1,,Cn are non-empty subsets of [1,,l]

  • Output: yes iff there is a subset H[1,,l] of size at most k such that, we have HCi for all 1in. In such a case, the set H is called a hitting set.

In the following, if (l,C,k) is an instance of the hitting set problem, then C refers to C1,,Cn for some n1.

3 Learning with unbounded use of binary operators

First, we consider the case of learning a formula with arbitrarily many occurrences of binary operators. The main result of this section is stated in Theorem 6 below.

Theorem 6.

Let 𝖡𝗍𝖮𝗉𝖡𝗂𝗇𝗍𝗉 and 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀 such that 𝖡𝗍𝖡𝗅. Then, for all 𝖴𝗍𝖮𝗉𝖴𝗇, the decision problem 𝖫𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,𝖡𝗍,𝖡𝗅,) is 𝖭𝖯-hard.

In the passive learning setting that we consider, the size of the formulas is crucial due to the upper bound B. Therefore, although it is possible to express e.g. disjunctions with conjunctions and negations, since doing so affects the size of the formulas involved, if we have proved that a learning problem is 𝖭𝖯-hard with the operators ,¬, it does not imply a priori that it is also 𝖭𝖯-hard with the operator . Hence, for the sake of completeness, we consider all those fourteen binary operators (ten logical, four temporal), although it seems that some of these binary operators (like or ) make much more sense to consider than others (like or ¬). Since these operators behave differently, we cannot do a single reduction working for all these operators at once. However, we do partition these operators in different groups and exhibit a reduction per group of operators.

Most of the reductions use only size-1 structures, that are (almost) entirely defined by the subset of propositions labeling their only state. In addition, most of the reductions are done from the hitting set problem. In that case, how we extract a hitting set from a (small enough) separating formula relies only on the variables that need to occur in a formula separating the positive and negative structures, regardless of the operators involved.

We start with the operators ,,, i.e. we assume that 𝖡𝗅{,,}. The reduction for this case is actually a straightforward adaptation of the proof of [27, Theorem 2]. We describe it here. Given an instance (l,C,k) of the hitting set problem, we let 𝖯𝗋𝗈𝗉:={aj,bj1jl}. Furthermore, for all subsets T[1,,l], we let (T) denote a size-1 (linear) structure whose only state is labeled by the set {aj,bjjT,jT}. Then, we let 𝖨𝗇,,:=(𝖯𝗋𝗈𝗉,𝒫,𝒩,B) for 𝒫:={(Ci)1in}, 𝒩:={()}, and B:=2k1. Let us illustrate this reduction on a simple example. Assume that l=4, C=({1,2,3},{2,4},{1,4}), and k=2. Then, the sets labeling the only state of the positive structures are {a1,a2,a3,b4}, {b1,a2,b3,a4}, and {a1,b2,b3,a4} while the set labeling the only state of the negative structure is {b1,b2,b3,b4}. Furthermore, B=3. Then, H:={1,4} is the a hitting set with |H|2, while φ:=a1a4, φ:=b1a4, and φ:=a1b4 are all separating formulas with |φ|=|φ|=|φ|3.

We claim that (l,C,k) is a positive instance of 𝖧𝗂𝗍 iff 𝖨𝗇,, is a positive instance of 𝖫𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,𝖡𝗍,𝖡𝗅,). Indeed, given a hitting set H={i1,,ir} with rk, one can check that the 𝖫𝖳𝖫-formula φ:=1xraix of size 2r1B accepts 𝒫 and rejects 𝒩. Note that, the 𝖫𝖳𝖫-formulas φ:=bj1(bj2(ajr)) and φ:=((aj1bj2))bjr of size 2r+1B also accept 𝒫 and reject 𝒩. On the other hand, consider an 𝖫𝖳𝖫-formula φ of size at most B that accepts 𝒫 and rejects 𝒩. We let H:={1jlaj or bj occurs in φ}. Since |φ|B, we have |H|k. Furthermore, consider any 1in. Let us consider the set Si (resp. S) labeling the only state of the structure (Ci) (resp. ()). We have Δ(Si,S):=SiSSSi={aj,bjjCi}. One can then show (rather straightforwardly, by induction on 𝖫𝖳𝖫-formulas) that, since φ accepts (Ci) and rejects (), at least one variable in Δ(Si,S) occurs in φ. That is, CiH and H is a hitting set of size at most k.

In fact, the reduction for the operators ,¬,¬ is obtained from the above one by reversing the positive and negative sets (the arguments are almost identical).

We then handle the operators ¬,¬. The above reductions cannot be used since, when the operator ¬ (or the operator ¬) is used successively, the formula obtained is semantically equivalent to an alternation of conjunctions and disjunctions. For instance, consider six variables r1,r2,r3,r4,x1,x2 to use in a single 𝖫𝖳𝖫-formula using only the ¬ operator, e.g.: φ:=r1¬(x1¬(r2¬(x2¬(r3¬r4)))). It is semantically equivalent to: φ¬r1(x1(¬r2(x2(¬r3¬r4))). This is in sharp contrast with the above-formulas φ,φ and φ. To circumvent this difficulty, we change the reduction by adding propositions labeling the only state of all the positive size-1 linear structures (but not the only state of all the negative ones). We can then place these propositions where x2 and x4 were in the above formula. That way, we semantically obtain a disjunction on relevant variables r1,r2,r3,r4. The obtained reduction is slightly more subtle than the previous ones.

Before considering the last two logical operators ,¬, we handle the temporal operators 𝐖,𝐌. The two previous reductions only use size-1 structures. On such structures, the temporal operators 𝐖,𝐌 are actually equivalent to and respectively. Hence, the reductions for and can also be used as is for the operators 𝐖 and 𝐌 respectively.

We then handle the final two logical operators ,¬. These operators are unlike the other operators. Let us give an intuition of how the learning problems with these operators behave. Consider an 𝖫𝖳𝖫-formula φ using only the operators ¬, and ¬ and a size-1 structure . Let S denote the set of propositions labeling the only state of . We let 𝖭𝖾𝗀(φ) denote the number of occurrences of the operators ¬,¬ in φ. We also let 𝖭𝖻𝖮𝖼S¯(φ) denote the number of occurrences of the propositions not in S in φ. Then, one can realize that φ if and only if 𝖭𝖾𝗀(φ) and 𝖭𝖻𝖮𝖼S¯(φ) have the same parity. This simple observation suggests that the learning problem with the operators ,¬ is linked to modulo-2 calculus. The reduction for these operators is established from an 𝖭𝖯-complete problem dealing with modulo-2 calculus, known as the Coset Weight problem [5].

Finally, we handle the temporal operators 𝐔 and 𝐑. On size-1 structures, for all 𝖫𝖳𝖫-formulas φ1,φ2, we have the following equivalences: φ1𝐔φ2φ1𝐑φ2φ2. That is, contrary to the temporal operators 𝐖 and 𝐌, on size-1 structures, 𝐔 and 𝐑 are equivalent to unary operators. Hence, the reduction that we consider does not involve only size-1 structures. It is once again established from the hitting set problem, though the construction and the correctness proof are more involved than for the above cases.

On top of that, for all sets of operators, ATL learning is at least as hard as CTL learning, which is itself at least as hard as LTL learning. Thus, from Theorem 6, we obtain that CTL and ATL learning with unbounded use of binary operators are 𝖭𝖯-hard. This justifies the leftmost column of Table 1.

4 Learning with a bounded amount of binary operators

Since, with unbounded use of binary operators, all the learning problems are 𝖭𝖯-hard, we focus on learning formulas where the number of occurrences of binary operators is bounded. Note that the bound n parameterizes the decision problem itself, and therefore is independent of the input. For simplicity, we restrict ourselves to formulas that do not use at all binary temporal operators. Before we dive into the details of our results as summarized in the rightmost column of Table 1, let us first argue why this fragment is interesting to focus on.

4.1 Expressivity

The passive learning problem that we consider in this paper bounds the size of the formulas considered. This is because we want a separating formula not to overfit the input (i.e. not to simply describe the positive and negative models). However, another benefit is that the smaller the formulas, the more understandable they are for users. Similarly, using too many binary operators could make the formulas hard to grasp, regardless of their size.

In addition, there are examples of interesting specifications that can be expressed with a bounded amount of binary operators. We give three examples below with 𝖫𝖳𝖫-formulas.

Consider first so-called “mode-target” formulas of the shape j(𝐅𝐆Mji𝐅𝐆Ti,j), where all Mj,Ti,j are propositions. These types of formulas were introduced in [4] and exhibit two interesting features: the corresponding 𝖫𝖳𝖫-synthesis problem is tractable, and these formulas express an interesting property, which can be summarized as follows: if a model eventually settles in a mode Mj, then it should eventually settle in one of the target Ti,j. Interestingly, when the number of different modes and targets that a system can have is fixed, then the number of binary operators sufficient to express such specification is also bounded.

Similarly, there are also interesting specifications related to “generalized reactivity” (from [32] for 𝖫𝖳𝖫-formulas). Such specifications are of the shape i𝐆𝐅ψii𝐆𝐅ψi, where all formulas ψi and ψi do not feature at all temporal operators. As such, up to introducing additional propositions, these could be expressible with few binary operators. These formulas can be read as an implication between assumptions and guarantees. As above, when the number of assumptions and guarantees is bounded, then the number of binary operators sufficient to express such formulas also is.

Finally, one of the popular LTL learning tools, Scarlet [35], relies on a fragment of LTL, directed LTL and its dual, which uses unary temporal operators and binary logical operators only. In these fragments, formulas of a fixed length (a search parameter they define) can use several of 𝐅 𝐆 and 𝐗 operators while using only bounded occurrences of and operators.

4.2 Abstract recipes

The six decision problems captured in the rightmost column of Table 1 are of two kinds: three are 𝖭𝖯-complete, while three others are below 𝖭𝖯. In fact, the proofs of all three results of the same kind will follow the same abstract recipes. We present them below.

Recipe for the membership-below-NP proofs.

Let 𝖳𝖫 denote either 𝖫𝖳𝖫 formulas, or 𝖢𝖳𝖫 formulas without the operator 𝐗, or 𝖠𝖳𝖫2 formulas with only one unary operator 𝐅 or 𝐆 (i.e. one of the three logical fragment for which the corresponding decision problem is below 𝖭𝖯). Then, we follow the two steps below:

  1. A)

    First, we show that given the set of propositions 𝖯𝗋𝗈𝗉 and the bound B, there is a set of relevant 𝖳𝖫-formulas 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) such that: 1) For all 𝖳𝖫(𝖯𝗋𝗈𝗉)-formulas ϕ of size at most B, there is a formula ϕ𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) such that ϕϕ; and 2) the size of 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) is polynomial in |𝖯𝗋𝗈𝗉| and B.

  2. B)

    Second, we show that for all 𝖳𝖫-formulas ϕ𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B), deciding if ϕ satisfies a 𝖳𝖫-model M can be done, depending on |𝖯𝗋𝗈𝗉|,B,|M|, within the resources allowed, i.e. logarithmic space for the 𝖫𝖳𝖫 case, non-deterministic logarithmic space for the 𝖢𝖳𝖫 case, and polynomial time for the 𝖠𝖳𝖫2 case.

Due to a lack of space, in this paper we will only present these two steps in the context of formulas that do not use any binary operator. Since the occurrences of binary operators is bounded in any case, the arguments are essentially the same for the general case. For instance, for the first step, from the result established for formulas without binary operators, we can straightforwardly deduce the result for all formulas, by induction on the bound n. That way, we obtain that |𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B)| could be exponential in the bound n, but this does not have an impact complexity-wise, since n is fixed.

Recipe for the NP-hardness proofs.

The formulas that we consider only use a bounded amount of binary operators. Thus, contrary to the 𝖭𝖯-hardness reductions of Section 3, here, our 𝖭𝖯-hardness proofs do not rely on binary operators. In fact, these binary operators make it harder to argue about how the permitted unary operators interact. For this reason, our proof of 𝖭𝖯-hardness is decomposed into two steps. We first exhibit reductions for the learning problems without binary operators. Then, from these reductions, we devise reductions for the learning problems with bounded occurrences of binary operators. We present in details the former reductions in this paper and give intuition behind the later reductions below.

Let n and 𝖮𝗉𝖡𝗂𝗇𝗅𝗀 be a binary (non-temporal) operator. We consider n propositions {p1,,pn} and we define multiple size-1 structures using the propositions {p1,,pn} forming two sets 𝒜n, and n,. The idea is that to distinguish these two sets, a separating formula will necessarily feature all the propositions {p1,,pn}. In fact, from a positive and a negative sets of structures 𝒫 and 𝒩 on the set of proposition {p}222In fact, for technical reason, in [8], we use two propositions {p,p¯}. (which is the only proposition that unary formulas can use in our reductions), we can show the following: if a formula of size at most B+2n, with at most n occurrences of binary operators, separates both 𝒫 and 𝒩, and 𝒜n, and n,, then there is a unary formula of size at most B that separates 𝒫 and 𝒩.333Actually, we can also show the converse (which is important for us to prove that the reduction is correct). That way, a reduction for the learning problem without binary operators can be translated (in logspace) into a reduction for the learning with bounded occurrences of binary operators. Note that the arguments presented in this paragraph are not straightforward to formally state and prove (this is handled in Theorem “Proving 𝖭𝖯-hardness without binary operators is sufficient” in the extended version [8]).

Let us now consider how we handle the reduction without binary operators. From an instance (l,C,k) of the hitting problem, we proceed as follows. We define a sample of structures (and a bound B) such that all separating formulas have a specific shape, and there is a bijection between subsets H[1,,l] and formulas φ(l,H) of that specific shape. This correspondence allows us to extract a hitting set. More specifically, we follow the abstract recipe below:

  1. (a)

    We define the bound B and positive and negative structures that “eliminate” certain operators or pattern of operators from any potential separating formula. This way we ensure that any separating formula will be of the form φ(l,H), for some H[1,,l].

  2. (b)

    We define a negative structure satisfied by a formula φ(l,H) if and only if |H|k+1.

  3. (c)

    For all 1in, we define a positive structure that a formula φ(l,H) accepts if and only if HCi.

By construction, the instance of the learning decision problem that we obtain is a positive instance if and only if the hitting set instance (l,C,k) also is. Furthermore, note that in all three cases, this reduction can be computed in logspace.

4.3 LTL learning

We start with LTL learning. We have the proposition below.

Proposition 7.

For all sets of unary operators 𝖴𝗍𝖮𝗉𝖴𝗇, sets of binary (non-temporal) operators 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and n, the decision problem 𝖫𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,,𝖡𝗅,n) is in 𝖫.

We present Steps A and B of Section 4.2 in the case n=0. Toward Step A, we have the equivalences below (see e.g. [27, Prop. 8]), which imply the corollary that follows.

Observation 8.

For all 𝖫𝖳𝖫-formulas φ and k, we have: 1) 𝐅𝐗kφ𝐗k𝐅φ, 𝐆𝐗kφ𝐗k𝐆φ; 2) 𝐅𝐅φ𝐅φ, 𝐆𝐆φ𝐆φ; 3) 𝐅𝐆𝐅φ𝐆𝐅φ, 𝐆𝐅𝐆φ𝐅𝐆φ.

Corollary 9.

Consider a set of propositions 𝖯𝗋𝗈𝗉. We let 𝖫𝗂𝗍(𝖯𝗋𝗈𝗉):={x,¬xx𝖯𝗋𝗈𝗉} and 𝖫𝖳𝖫𝖴𝗇(𝖯𝗋𝗈𝗉):={𝐗kx,𝐗k𝐅x,𝐗k𝐆x,𝐗k𝐅𝐆x,𝐗k𝐆𝐅xk,x𝖫𝗂𝗍(𝖯𝗋𝗈𝗉)}.

Then, for any 𝖫𝖳𝖫-formula φ𝖫𝖳𝖫(𝖯𝗋𝗈𝗉,𝖮𝗉𝖴𝗇,,𝖡𝗅,0), there is an 𝖫𝖳𝖫-formula φ𝖫𝖳𝖫𝖴𝗇(𝖯𝗋𝗈𝗉)𝖫𝖳𝖫(𝖯𝗋𝗈𝗉,𝖮𝗉𝖴𝗇,,𝖡𝗅,0) such that φφ and |φ||φ|.

Proof sketch.

With the equivalences 1) from Observation 8, we can push the 𝐗 operators in φ at the beginning of the formula. The equivalences 2) and 3) from Observation 8 ensure that it is possible to have at most two nested 𝐅,𝐆 operators in the resulting formula φ.

The set of relevant formulas 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) is then obtained directly from the set of formulas 𝖫𝖳𝖫𝖴𝗇(𝖯𝗋𝗈𝗉). Note that however, how it is obtained depends on the exact operators in 𝖴𝗍. For instance, if 𝐆𝖴𝗍 while ¬,𝐅𝖴𝗍, we should replace the occurrences of 𝐆 in formulas in 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) by ¬𝐅¬. Nonetheless, in any case, we obtain a set 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B) of relevant formulas whose number of elements is linear in |𝖯𝗋𝗈𝗉|B. This concludes the arguments for Step A. As for Step B, one can realize that since there are at most two nested 𝐅,𝐆 operators in formulas in 𝖱𝖾𝗅𝖥𝗈𝗋𝗆(𝖯𝗋𝗈𝗉,B), then checking that they hold on a linear structure can be done in logarithmic space (because it suffices to have a constant number of pointers browsing the structure).

4.4 CTL learning

Consider now the more involved case of CTL learning. As can be seen in Table 1, we distinguish two cases: with and without the operator 𝐗.

Assume that 𝐗𝗨𝘁.

The goal is to show the theorem below.

Theorem 10.

For all sets 𝖴𝗍𝖮𝗉𝖴𝗇, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and bound n, if 𝐗𝖴𝗍, then the decision problem 𝖢𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,,𝖡𝗅,n) is 𝖭𝖯-hard.

As stated in Section 4.2, we argue the theorem in the case n=0. Recall that in that case we consider a single proposition {p}. Consider an instance (l,C,k) of the hitting set problem 𝖧𝗂𝗍. We follow the three Steps ab, and c. Toward Step a, we define Kripke structures that prevent the use of the operators 𝐅,𝐆,¬. To do so, we let B:=l+1 and for two sets S1,S2{p}, we consider the Kripke structure Kl,S1,S2 that is depicted in Figure 1. These structures satisfy the lemma below.

Figure 1: The structure Kl,S1,S2 where S1{p} (resp. S2{p}) labels ql+1 (resp. ql+2).
Lemma 11.

A formula ϕ𝖢𝖳𝖫({p},𝖴𝗍,,𝖡𝗅,0) of size at most l+1 accepting Kl,{p}, and rejecting Kl,,{p} and Kl,, cannot use the operators 𝐅,𝐆,¬.

Proof sketch.

Consider an equivalent CTL-formula ϕ with |ϕ||ϕ| where negations, if any, occur right before the proposition p. Then, if ϕ uses the operator 𝐆, it cannot distinguish the structures Kl,{p}, and Kl,,. Otherwise, if it uses the operator 𝐅, it cannot distinguish the structures Kl,{p}, and Kl,,{p}. Otherwise, since Kl,{p},,Kl,,{p}, and Kl,, coincide on the first l states, ϕ has to use at least l operators 𝐗. Since |ϕ|l+1, it cannot use a negation. Thus ϕ does not use 𝐅,𝐆,¬, and neither does ϕ.

In fact, a 𝖢𝖳𝖫-formula ϕ𝖢𝖳𝖫({p},𝖴𝗍,,𝖡𝗅,0) of size at most l+1 accepting Kl,{p}, and rejecting Kl,,{p},Kl,, necessarily uses exactly l operators 𝐗 followed by the proposition p. Such a formula is therefore entirely defined by the 𝐗 operators before which it uses the quantifier. This suggests the definition below of the CTL-formula ϕ(l,H) induced by a subset H[1,,l].

Definition 12.

For all H[1,,l], we let ϕ(l,H)𝖢𝖳𝖫({p},𝖴𝗍,,𝖡𝗅,0) denote the 𝖢𝖳𝖫-formula defined by ϕ(l,H):=Q1𝐗Ql𝐗p where, for all 1il, we have Qi{,} and Qi= if and only if iH.

For 1il+1, we let ϕi(l,H):=Qi𝐗Ql𝐗p (with ϕl+1(l,H):=p).

Let us now turn toward Step b. We define a structure K>kl with k+2 different levels, where: the single starting state q0,1 is at the bottommost level; the proposition p only labels the state q𝗐𝗂𝗇 at the topmost level; and every state of the bottom k+1 levels has a successor at the same level and one level higher. That way, going from q0,1 to q𝗐𝗂𝗇 is equivalent to leveling up k+1 times. Furthermore, the top most level can be reached in at most l. An example is depicted in Figure 2. This structure satisfies the lemma below.

Figure 2: The Kripke structure K>25.
Figure 3: The Kripke structure K5,{2,5}.
Lemma 13.

For all H[1,,l], we have K>klϕ(l,H) if and only if |H|>k.

Consider now Step c. For C[1,,l], we define the Kripke structure K(l,C) with {q1,,ql,ql+1,q𝗐𝗂𝗇} as set of states where q𝗐𝗂𝗇 is the only state labeled with p; and for all 1jl, qj branches to qj+1 and, if (and only if) jC, qj also branches to q𝗐𝗂𝗇, as exemplified in Figure 3. Such structures satisfy the lemma below.

Lemma 14.

For all C,H[1,,l], we have K(l,C)ϕ(l,H) if and only if CH.

Proof sketch.

We can show by induction on l+1j1 the property 𝒫(j): qjϕj(l,H) if and only if H[j,,l]C. The lemma is then given by 𝒫(1).

We can finally define the reduction that we consider. We let 𝖨𝗇𝖢𝖳𝖫:=({p},𝒫,𝒩,B), with B:=l+1, 𝒫:={Kl,{p},,Ki1in} and 𝒩:={Kl,,,Kl,,{p},K>kl}, be an input of the decision problem 𝖢𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,,𝖡𝗅,0). By Lemmas 111314, 𝖨𝗇𝖢𝖳𝖫 is a positive instance of the decision problem 𝖢𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,,𝖡𝗅,0) if and only if (l,C,k) is a positive instance of the decision problem 𝖧𝗂𝗍. Theorem 10 follows (in the case n=0).

Assume that 𝐗𝗨𝘁.

In that case, the CTL learning problem is now in 𝖭𝖫.

Theorem 15.

For all sets of operators 𝖴𝗍{𝐅,𝐆,¬}, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and bounds n, the decision problem 𝖢𝖳𝖫𝖫𝖾𝖺𝗋𝗇(𝖴𝗍,,𝖡𝗅,n) is in 𝖭𝖫.

Toward Step A, a crucial observation is that using the operators 𝐅 or 𝐆 twice in a row is useless. This is stated in the lemma below in the context of 𝖠𝖳𝖫-formula because this lemma will be used again in the next subsection.

Lemma 16.

Let IJ, and ϕ be an 𝖠𝖳𝖫-formula. We have:
J𝐅ϕ I𝐅J𝐅ϕJ𝐅I𝐅ϕ I𝐆ϕ I𝐆J𝐆ϕJ𝐆I𝐆ϕ

Proof sketch.

We argue the result for 𝐅, the case of 𝐆 is dual. We have J𝐅ϕI𝐅J𝐅 by definition of 𝐅. Furthermore, if a state q satisfies I𝐅J𝐅ϕ then there is a strategy 𝗌I for the coalition I such that eventually a state satisfying J𝐅ϕ is surely reached. For all such states q, we consider a strategy 𝗌Jq for the coalition J ensuring to eventually visit a state satisfying ϕ. Then, consider a strategy 𝗌J for the coalition J that: mimics 𝗌I (which is possible since IJ) until a state q satisfying J𝐅ϕ is reached, and then switches to the strategy 𝗌Jq. That strategy ensures eventually reaching a state satisfying ϕ. Therefore, I𝐅J𝐅ϕJ𝐅ϕ. This is similar for J𝐅I𝐅ϕ.

From this, we can actually deduce (this is not direct) that there is a bound M such that, for any set of propositions 𝖯𝗋𝗈𝗉 and for all 𝖴𝗍{𝐅,𝐆,¬}, given any 𝖢𝖳𝖫(𝖯𝗋𝗈𝗉,𝖴𝗍,,𝖡𝗅,0)-formula ϕ, there is an equivalent 𝖢𝖳𝖫(𝖯𝗋𝗈𝗉,𝖴𝗍,,𝖡𝗅,0)-formula ϕ, with |ϕ|M. Thus, the number of 𝖢𝖳𝖫-formulas to consider is linear in |𝖯𝗋𝗈𝗉|. As for Step B, consider any such formula ϕ. Since the number of quantifiers it uses is bounded by M and 𝖭𝖫=𝖼𝗈𝖭𝖫, we deduce that checking that it satisfies a Kripke structure can be done in 𝖭𝖫.

Proof of NL-hardness.

In Table 1, we do not state only that CTL learning without the operator 𝐗 is in 𝖭𝖫, but also that it is 𝖭𝖫-hard. Proving this result is actually straightforward. We exhibit a reduction from the problem of reachability in a graph (which is 𝖭𝖫-complete [23]). Given an input (𝒢,s,t) of that problem, with 𝒢 a graph, s the source state and t the target state, we define a positive Kripke structure K that is obtained from 𝒢 by making s its only initial state, and t the only state labeled by the proposition p. Additionally, we consider B:=2 as the bound, and with an additional structure, we ensure that if there is a separating formula, then the formula ϕ:=𝐅p is separating.

4.5 ATL learning

We have seen that CTL learning with the operator 𝐗 is 𝖭𝖯-hard, which implies that it is also the case for ATL learning. Here, we consider the case of ATL learning without the operator 𝐗. First, let us informally explain why the 𝖭𝖯-hardness reduction that we have described above for CTL cannot possibly work without the operator 𝐗. A central aspect of the proof of Lemma 14 is to be able to associate a specific operator in a prospective formula with a specific state in a Kripke structure. That is intrinsically not possible with the operator 𝐅 since this operator looks at arbitrarily distant horizons. At least, this is true with CTL-formulas interpreted on Kripke structures. However, with 𝖠𝖳𝖫-formulas interpreted on turn-based structures, it is possible to “block the horizon” of 𝐅 operators. Indeed, consider the structure of Figure 5, where blue lozenge-shaped states are Agent-1 states, and red square-shaped states are Agent-2’s. Here, one can see that q21,2⊧̸1𝐅p because Agent 2 can enforce to loop on the Agent-2 state q11,2 and not see the state q𝗐𝗂𝗇, labeled by p.

Figure 4: The turn-based structure T4:1,2.
Figure 5: On the left Tp, on the right T𝗇𝗈 2𝐆.

These kinds of turn-based games will be extensively used in the following. In all generality, there are defined as follows: given a pair of agents ij and l, in the turn-based structure Tl:i,j, there are l+1 self-looping states, alternatively belonging to Agents i and j, that can get closer and closer to the self-looping sink q𝗐𝗂𝗇, the only state labeled by p. In fact, such structures are linked to alternating-formulas, defined below.

Definition 17.

An 𝖠𝖳𝖫-formula is positive if it does not use any negation. For a pair of agents ij and l, a positive 𝖠𝖳𝖫-formula ϕ is (i,j)-free if it does not use an operator A𝐅 with i,jA. It is (i,j,l)-alternating if it is (i,j)-free and if there are at least l alternating occurrences of operators Ai𝐅 with iAi and Aj𝐅 with jAj.

Lemma 18.

Consider two agents ij, l, and a positive 𝖠𝖳𝖫-formula ϕ that is (i,j)-free. The formula ϕ accepts the structure Tl:i,j if and only if it is (i,j,l)-alternating.

𝗔𝗧𝗟𝟐 learning with {𝐅,𝐆}𝗨𝘁.

Here, all the turn-based structures that we consider use the set of agents 𝖠𝗀={1,2}. The goal is to show the theorem below.

Theorem 19.

For all sets 𝖴𝗍𝖮𝗉𝖴𝗇, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and bound n, if {𝐅,𝐆}𝖴𝗍 and 𝐗𝖴𝗍, then the decision problem 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇2(𝖴𝗍,,𝖡𝗅,n) is 𝖭𝖯-hard.

In the following, to ease the notations, the strategic operators ,{1},{2},{1,2} will simply be denoted , 1, 2 and 1,2 respectively. Consider an instance (l,C,k) of the hitting set problem. We follow the recipe of Subsection 4.2. Here, we want separating formulas to be promising, i.e. to only use the operators 1𝐅,2𝐅 and 1𝐆. To this end, all the structures we use are self-looping, thus making the operators 𝐅 and 1,2𝐆 useless.

Lemma 20.

For all 𝖠𝖳𝖫-formulas ϕ and self-looping states q, we have: qϕ if and only if q𝐅ϕ if and only if q1,2𝐆ϕ

Proof.

Since q is self-looping the coalition of agents {1,2} has a strategy 𝗌 such that 𝖮𝗎𝗍(q,𝗌)={qω}. The lemma follows from the definition of the operators 𝐅 and 𝐆.

We also consider the two structures Tp,T𝗇𝗈 2𝐆, of Figure 5 satisfying the lemma below.

Lemma 21.

For all 𝖠𝖳𝖫-formulas ϕ𝖠𝖳𝖫({p},𝖴𝗍,,𝖡𝗅,0) accepting Tp,T𝗇𝗈 2𝐆 and rejecting T2l+1:1,2, there is a promising formula ϕ𝖠𝖳𝖫({p},𝖴𝗍,,𝖡𝗅,0) with |ϕ||ϕ| that is equivalent to ϕ on self-looping structures.

Proof sketch.

Consider an 𝖠𝖳𝖫-formula ϕ equivalent to ϕ with |ϕ||ϕ| and with at most one negation occurring before the proposition p. Since ϕ accepts Tp, it follows that it is positive. By Lemma 20, we can remove the operators 1,2𝐆 and 𝐅 from ϕ. Furthermore: ϕ cannot use 𝐆,2𝐆, since it accepts T𝗇𝗈 2𝐆, and it cannot use 1,2𝐅 since it rejects T2l+1:1,2. It is therefore promising.

Figure 6: The structure T𝗇𝗈 1𝐆2.
Figure 7: The structure T2,{1},2.

We will also consider T2l:1,2 as a positive structure, thus allowing us to focus on (1,2,2l)-alternating formulas (recall Lemma 18). Then, we want to associate to a subset H[1,,l] a promising (1,2,2l)-alternating 𝖠𝖳𝖫-formula. To get an intuition, let us consider the turn-based structure T𝗇𝗈 1𝐆t for t=2 of Figure 6. This structure T𝗇𝗈 1𝐆t is analogous to the structure T2t:1,2 except that all Agent-2 states have an additional successor: the state q𝗅𝗈𝗌𝖾 that does not satisfy any positive formula. Back to the structure of Figure 6, because Agent 2 owns the states q3𝐆,q1𝐆, these states do not accept any positive 𝖠𝖳𝖫-formula of the shape 1𝐆ϕ. Therefore, for all q{q4𝐆,q2𝐆} and positive 𝖠𝖳𝖫-formulas ϕ, we have q1𝐅1𝐆2𝐅ϕ if and only if qϕ. This actually implies that a (1,2,2l)-alternating formula ϕ accepts T𝗇𝗈 1𝐆2 if and only if the sequence of operators 1𝐅2𝐅 (without 1𝐆 in between) occurs at least twice in ϕ (to go from q4𝐆 to q2𝐆 and then from q2𝐆 to q𝗐𝗂𝗇). In fact, we consider formulas that only use 1𝐆 operators after 1𝐅 and before 2𝐅, as defined below. Such formulas satisfy the lemma that follows.

Definition 22.

For all H[1,,l], we let ϕ(l,H,2)𝖠𝖳𝖫2({p},𝖴𝗍,,𝖡𝗅,0) denote the 𝖠𝖳𝖫-formula defined by: ϕ(l,H,2):=1𝐅Q12𝐅1𝐅Ql2𝐅p where, for all 1il, we have Qi{ϵ,1𝐆} and Qi=1𝐆 iff iH.

For all 1il+1, we let ϕi(l,H,2):=1𝐅Qi2𝐅1𝐅Ql2𝐅p (with ϕl+1(l,H,2):=p).

Lemma 23.

A promising (1,2,2l)-alternating formula ϕ with |ϕ|3l+1k rejects T𝗇𝗈 1𝐆k+1 if and only if ϕ=ϕ(l,H,2) for some H[1,,l] such that |H|=k.

Proof sketch.

Since ϕ is (1,2,2l)-alternating, it uses at least l operators 1𝐅 and 2𝐅. Thus, it can use at most lk operators 1𝐆. In addition, ϕ accepts T𝗇𝗈 1𝐆k+1 iff there are at least k+1 occurrences of the sequence 1𝐅2𝐅 in ϕ. Thus, ϕ uses each lk remaining operators 1𝐆 between a different pair of successive 1𝐅,2𝐅 iff it rejects T𝗇𝗈 1𝐆k+1.

With Tp,T𝗇𝗈 2𝐆,T2l:1,2 as positive structures and T2l+1:1,2,T𝗇𝗈 1𝐆k+1 as negative structures, we have achieved both Steps a and b. Let us turn to Step c. For all C[1,,l], we define a turn-based structure Tl,C,2. An example is depicted in Figure 7 for l=2. The structure Tl,C,2 features a sequence of states q11,q12,,ql1,ql2 alternating between Agent-1 and Agent-2 states ending in a self-looping sink q𝗅𝗈𝗌𝖾 not labeled by p. However, the Agent-1 states qi1 for which iC have a “testing state” qi𝖳𝖾𝗌𝗍 as successor. That state is self-looping, and may branch to the self-looping sink q𝗅𝗈𝗌𝖾 or to the structure T2(li):1,2. That state is such that qi𝖳𝖾𝗌𝗍Qi2𝐅ϕi+1(l,H,2) iff Qi=ϵ (iff iH). Furthermore, note that it is useless to “wait” at the state qi1 before branching to qi𝖳𝖾𝗌𝗍. Indeed, if for instance Qi=1𝐆 but Qi+1=ϵ, then it may seem that q1𝖳𝖾𝗌𝗍φ, for φ:=Qi+12𝐅ϕi+2(l,H,2) and therefore qi1ϕi(l,H,2)=1𝐅Qi2𝐅1𝐅φ. However, it is not the case because we do not have qi𝖳𝖾𝗌𝗍φ, since ϕi+2(l,H,2) is not (1,2,2(li))-alternating, and thus it does not satisfy the structure T2(li):1,2. Overall, we have the lemma below.

Lemma 24.

For all C,H[1,,l], we have T(l,C)ϕ(l,H,2) if and only if CH.

We have achieved Step c. Then, we let 𝖨𝗇𝖠𝖳𝖫(2):=({p},𝒫,𝒩,B) be an input of the decision problem 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇2(𝖴𝗍,,𝖡𝗅,0) where 𝒫:={Tp,T𝗇𝗈 2𝐆,T2l:1,2,T(l,Ci,2)1in}, 𝒩:={T2l+1:1,2,T𝗇𝗈 1𝐆k+1}, and B:=3l+1k. By Lemmas 2123 and 24, 𝖨𝗇𝖠𝖳𝖫(2) is a positive instance of 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇2(𝖴𝗍,,𝖡𝗅,0) iff (l,C,k) is a positive instance of 𝖧𝗂𝗍.

𝗔𝗧𝗟𝟐 learning with 𝗨𝘁={𝐅} or 𝗨𝘁={𝐆}.

The 𝖠𝖳𝖫2 learning problem is now in 𝖯.

Theorem 25.

For all sets of operators 𝖴𝗍{{𝐅},{𝐆}}, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and bounds n, the decision problem 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇2(𝖴𝗍,,𝖡𝗅,n) is in 𝖯.

We focus on the case 𝖴𝗍={𝐅}, the other is analogous. Towards Step A, consider a formula ϕ𝖠𝖳𝖫2(𝖯𝗋𝗈𝗉,{𝐅},,𝖡𝗅,0) and the only proposition p𝖯𝗋𝗈𝗉 occurring in ϕ. By Lemma 16, we can make the following observations: 1) If the operator 1,2𝐅 occurs in ϕ, then ϕ1,2𝐅p; 2) Otherwise, if the only operator occurring in ϕ is 𝐅 then ϕ𝐅p; 3) Otherwise, ϕ is equivalent to a formula ϕ alternating between the operators 1𝐅 and 2𝐅, with |ϕ||ϕ|. These observations suggest the definition below, which satisfies the lemma that follows.

Definition 26.

For a set of propositions 𝖯𝗋𝗈𝗉, we define the set 𝖠𝖳𝖫𝐅2(𝖯𝗋𝗈𝗉):={𝖰𝗍pp𝖯𝗋𝗈𝗉,𝖰𝗍𝖰𝗎𝖺𝗇𝗍𝖠𝗅𝗍𝐅} where 𝖰𝗎𝖺𝗇𝗍𝖠𝗅𝗍𝐅:={ϵ,𝐅,1,2𝐅,(1𝐅2𝐅),(1𝐅2𝐅)1𝐅,(2𝐅1𝐅),(2𝐅1𝐅)2𝐅}.

Lemma 27.

For a set of propositions 𝖯𝗋𝗈𝗉, and ϕ𝖠𝖳𝖫2(𝖯𝗋𝗈𝗉,{𝐅},,𝖡𝗅,0), there is an 𝖠𝖳𝖫-formula ϕ𝖠𝖳𝖫𝐅2(𝖯𝗋𝗈𝗉) such that ϕϕ and |ϕ||ϕ|.

This concludes Step A since the number of formulas of size at most B in 𝖠𝖳𝖫𝐅2(𝖯𝗋𝗈𝗉) is polynomial in B and |𝖯𝗋𝗈𝗉|. As for Step B, in this case it is trivial since checking that an 𝖠𝖳𝖫-formula satisfies a structure can always be done in polynomial time.

Proof of P-hardness.

In Table 1, we additionally state only that 𝖠𝖳𝖫2 learning with 𝖴𝗍{{𝐅},{𝐆}} is 𝖯-hard. The proof of this fact is actually very similar to the proof that 𝖢𝖳𝖫 learning without the operator 𝐗 is 𝖭𝖫-hard, except that the reduction is made from the problem of reachability in a turn-based game (which is 𝖯-complete [31]).

𝗔𝗧𝗟𝟑 learning with 𝗨𝘁{{𝐅},{𝐆}}.

Let us consider 𝖠𝖳𝖫 learning with one more agent, i.e. 𝖠𝖳𝖫3 learning, still with 𝖴𝗍{{𝐅},{𝐆}}. The turn-based structures that we consider now use the set of agents 𝖠𝗀={1,2,3}. The goal is to show the theorem below.

Theorem 28.

For all sets 𝖴𝗍{{𝐅},{𝐆}}, 𝖡𝗅𝖮𝗉𝖡𝗂𝗇𝗅𝗀, and bound n, the decision problem 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇3(𝖴𝗍,,𝖡𝗅,n) is 𝖭𝖯-hard.

We focus on the case 𝖴𝗍={𝐅} (the case 𝖴𝗍={𝐆} is analogous since the operators 𝐅 and 𝐆 have a dual behavior). Once again, let us consider an instance (l,C,k) of the problem 𝖧𝗂𝗍. We start right away by defining the 𝖠𝖳𝖫3-formula associated to a subset H[1,,l].

Definition 29.

For H[1,,l], we let ϕ(l,H,3) denote the 𝖠𝖳𝖫3-formula defined by ϕ(l,H,3):=1𝐅A1𝐅1𝐅Al𝐅p where, for all 1il, we have Ai{{2},{2,3}} and Ai={2,3}𝐅 if and only if iH.

For 1il+1, we let ϕi(l,H,3):=1𝐅Ai𝐅1𝐅Al𝐅p (with ϕl+1(l,H,3)=p).

Toward Step a, we define T2l+1:1,2,T2(k+1):1,3 as negative structures, thus ensuring that a separating formula does not use an operator A𝐅 with 1,2A, or 1,3A. We also define T2l:1,2 as a positive structure with the bound B:=2l+1. That way, a separating formula is necessarily (1,2,2l)-alternating and only uses the operators 1𝐅,2𝐅, and 2,3𝐅.

Lemma 30.

If a formula ϕ𝖠𝖳𝖫3({{p},{𝐅},,𝖡𝗅,n) with |ϕ|2l+1 accepts T2l:1,2 and rejects T2l+1:1,2,T2(k+1):1,3, then there is some H[1,,l] such that ϕ=ϕ(l,H,3).

Note that, if |H|k+1, then ϕ(l,H,3) is (1,3,2(k+1))-alternating. Therefore, since T2(k+1):1,3 is a negative structure, if ϕ(l,H,3) is separating, then |H|k, i.e. we have also achieved Step b. Let us now turn to Step c. For all C[1,,l], we define the structure Tl,C,3. An example is given in Figure 8 with l=3. This structure Tl,C,3 features a sequence of states q11,q12,,ql1,ql2 alternating between Agent-1 and Agent-2 states ending in a self-looping sink q𝗅𝗈𝗌𝖾. However, the Agent-1 states qi1 for which iC have an Agent-3 “testing state” qi𝖳𝖾𝗌𝗍 as successor. That state is self-looping and also branches to the structure T(li):1,2. Note that, given ri+1, the sub-formula ϕr(l,H,3) is (1,2,lr+1)-alternating, and therefore satisfies the structure T(li):1,2, iff r=i+1. Thus, since qi𝖳𝖾𝗌𝗍 is an Agent-3 state, qi𝖳𝖾𝗌𝗍Ai𝐅ϕi+1(l,H,3) iff 3Ai iff iH. Thus, we have the following lemma.

Figure 8: The turn-based structure T3,{2},3.
Lemma 31.

For all C,H[1,,l], we have T(l,C,3)ϕ(l,H,3) if and only if CH.

This concludes Step c. Overall, we let 𝖨𝗇𝖠𝖳𝖫(3),𝐅:=({p},𝒫,𝒩,B) be an input of the decision problem 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇3({𝐅},,𝖡𝗅,0) where 𝒫:={T2l:1,2,T(l,Ci,3)1in}, 𝒩:={T2l+1:1,2,T2(k+1):1,3}, and B:=2l+1. We have that 𝖨𝗇𝖠𝖳𝖫(3),𝐅 is a positive instance of 𝖠𝖳𝖫𝖫𝖾𝖺𝗋𝗇3({𝐅},,𝖡𝗅,0) if and only if (l,C,k) is a positive instance of 𝖧𝗂𝗍.

5 Future Work

Within our setting, we have covered many cases, as can be seen in Table 1. That is why the complete version of this work [8] is already quite long. However, there are still some cases that we have not tackled. First, there is the case of 𝖠𝖳𝖫2 learning with 𝖴𝗍{{𝐅,¬},{𝐆,¬}}. We believe that it behaves like the case 𝐅,𝐆𝖴𝗍, but the proofs would entail many additional technical details, since replacing 𝐅 with ¬𝐆¬ increases the size of the formulas.

More importantly, when considering a bounded amount of binary operators, we have not allowed binary temporal operators (𝐔,𝐑,𝐖,𝐌). Doing so would enhance the expressivity of the fragment that we consider, and we conjecture that we would obtain the same result as in this paper, with proofs that should be only moderately more involved.

On a more high level perspective, in this paper we have focused solely on solving exactly the learning problems and although we have found some relevant tractable cases, many are untractable. A promising research direction would be to look for tractable approximation algorithms, similarly to what is done in [27].

References

  • [1] Rajeev Alur, Thomas A. Henzinger, and Orna Kupferman. Alternating-time temporal logic. J. ACM, 49(5):672–713, September 2002. doi:10.1145/585265.585270.
  • [2] Dana Angluin. On the complexity of minimum inference of regular sets. Inf. Control., 39(3):337–350, 1978. doi:10.1016/S0019-9958(78)90683-6.
  • [3] M. Fareed Arif, Daniel Larraz, Mitziu Echeverria, Andrew Reynolds, Omar Chowdhury, and Cesare Tinelli. SYSLITE: syntax-guided synthesis of PLTL formulas from finite traces. In FMCAD, pages 93–103. IEEE, 2020. doi:10.34727/2020/ISBN.978-3-85448-042-6_16.
  • [4] Ayca Balkan, Moshe Y. Vardi, and Paulo Tabuada. Mode-target games: Reactive synthesis for control applications. IEEE Trans. Autom. Control., 63(1):196–202, 2018. doi:10.1109/TAC.2017.2722960.
  • [5] Elwyn R. Berlekamp, Robert J. McEliece, and Henk C. A. van Tilborg. On the inherent intractability of certain coding problems (corresp.). IEEE Trans. Inf. Theory, 24(3):384–386, 1978. doi:10.1109/TIT.1978.1055873.
  • [6] Dines Bjørner and Klaus Havelund. 40 years of formal methods - some obstacles and some possibilities? In FM, volume 8442 of Lecture Notes in Computer Science, pages 42–61. Springer, 2014. doi:10.1007/978-3-319-06410-9_4.
  • [7] Giuseppe Bombara, Cristian-Ioan Vasile, Francisco Penedo, Hirotoshi Yasuoka, and Calin Belta. A decision tree approach to data classification using signal temporal logic. In Proceedings of the 19th International Conference on Hybrid Systems: Computation and Control, HSCC ’16, pages 1–10, New York, NY, USA, 2016. Association for Computing Machinery. doi:10.1145/2883817.2883843.
  • [8] Benjamin Bordais, Daniel Neider, and Rajarshi Roy. The complexity of learning temporal properties. CoRR, abs/2408.04486, 2024. doi:10.48550/arXiv.2408.04486.
  • [9] Benjamin Bordais, Daniel Neider, and Rajarshi Roy. Learning branching-time properties in CTL and ATL via constraint solving. In André Platzer, Kristin Yvonne Rozier, Matteo Pradella, and Matteo Rossi, editors, Formal Methods - 26th International Symposium, FM 2024, Milan, Italy, September 9-13, 2024, Proceedings, Part I, volume 14933 of Lecture Notes in Computer Science, pages 304–323. Springer, 2024. doi:10.1007/978-3-031-71162-6_16.
  • [10] Alberto Camacho, Rodrigo Toro Icarte, Toryn Q. Klassen, Richard Anthony Valenzano, and Sheila A. McIlraith. LTL and beyond: Formal languages for reward function specification in reinforcement learning. In Sarit Kraus, editor, Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019, Macao, China, August 10-16, 2019, pages 6065–6073. ijcai.org, 2019. doi:10.24963/IJCAI.2019/840.
  • [11] Alberto Camacho and Sheila A. McIlraith. Learning interpretable models expressed in linear temporal logic. In ICAPS, pages 621–630. AAAI Press, 2019. URL: https://ojs.aaai.org/index.php/ICAPS/article/view/3529.
  • [12] Alberto Camacho, Eleni Triantafillou, Christian J. Muise, Jorge A. Baier, and Sheila A. McIlraith. Non-deterministic planning with temporally extended goals: LTL over finite and infinite traces. In AAAI, pages 3716–3724. AAAI Press, 2017. doi:10.1609/AAAI.V31I1.11058.
  • [13] Alessio Cecconi, Giuseppe De Giacomo, Claudio Di Ciccio, Fabrizio Maria Maggi, and Jan Mendling. Measuring the interestingness of temporal logic behavioral specifications in process mining. Inf. Syst., 107:101920, 2022. doi:10.1016/J.IS.2021.101920.
  • [14] William Chan. Temporal-logic queries. In CAV, volume 1855 of Lecture Notes in Computer Science, pages 450–463. Springer, 2000.
  • [15] Edmund M. Clarke and E. Allen Emerson. Design and synthesis of synchronization skeletons using branching-time temporal logic. In Dexter Kozen, editor, Logics of Programs, Workshop, Yorktown Heights, New York, USA, May 1981, volume 131 of Lecture Notes in Computer Science, pages 52–71. Springer, 1981. doi:10.1007/BFB0025774.
  • [16] Rüdiger Ehlers, Ivan Gavran, and Daniel Neider. Learning properties in LTL ACTL from positive examples only. In 2020 Formal Methods in Computer Aided Design, FMCAD 2020, Haifa, Israel, September 21-24, 2020, pages 104–112. IEEE, 2020. doi:10.34727/2020/ISBN.978-3-85448-042-6_17.
  • [17] Georgios E. Fainekos, Hadas Kress-Gazit, and George J. Pappas. Temporal logic motion planning for mobile robots. In ICRA, pages 2020–2025. IEEE, 2005. doi:10.1109/ROBOT.2005.1570410.
  • [18] Nathanaël Fijalkow and Guillaume Lagarde. The complexity of learning linear temporal formulas from examples. In Jane Chandlee, Rémi Eyraud, Jeff Heinz, Adam Jardine, and Menno van Zaanen, editors, Proceedings of the 15th International Conference on Grammatical Inference, 23-27 August 2021, Virtual Event, volume 153 of Proceedings of Machine Learning Research, pages 237–250. PMLR, 2021. URL: https://proceedings.mlr.press/v153/fijalkow21a.html.
  • [19] Marie Fortin, Boris Konev, Vladislav Ryzhikov, Yury Savateev, Frank Wolter, and Michael Zakharyaschev. Reverse engineering of temporal queries mediated by LTL ontologies. In Proceedings of the Thirty-Second International Joint Conference on Artificial Intelligence, IJCAI 2023, 19th-25th August 2023, Macao, SAR, China, pages 3230–3238. ijcai.org, 2023. doi:10.24963/IJCAI.2023/360.
  • [20] Jean-Raphaël Gaglione, Daniel Neider, Rajarshi Roy, Ufuk Topcu, and Zhe Xu. Maxsat-based temporal logic inference from noisy data. Innov. Syst. Softw. Eng., 18(3):427–442, 2022. doi:10.1007/S11334-022-00444-8.
  • [21] E. Mark Gold. Complexity of automaton identification from given data. Inf. Control., 37(3):302–320, 1978. doi:10.1016/S0019-9958(78)90562-4.
  • [22] Antonio Ielo, Mark Law, Valeria Fionda, Francesco Ricca, Giuseppe De Giacomo, and Alessandra Russo. Towards ilp-based ltlf passive learning. In Inductive Logic Programming: 32nd International Conference, ILP 2023, Bari, Italy, November 13–15, 2023, Proceedings, pages 30–45, Berlin, Heidelberg, 2023. Springer-Verlag. doi:10.1007/978-3-031-49299-0_3.
  • [23] Neil Immerman. Number of quantifiers is better than number of tape cells. J. Comput. Syst. Sci., 22(3):384–406, 1981. doi:10.1016/0022-0000(81)90039-8.
  • [24] Jean Christoph Jung, Vladislav Ryzhikov, Frank Wolter, and Michael Zakharyaschev. Extremal separation problems for temporal instance queries. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI 2024, Jeju, South Korea, August 3-9, 2024, pages 3448–3456. ijcai.org, 2024. URL: https://www.ijcai.org/proceedings/2024/382.
  • [25] Xiao Li, Cristian Ioan Vasile, and Calin Belta. Reinforcement learning with temporal logic rewards. In 2017 IEEE/RSJ International Conference on Intelligent Robots and Systems, IROS 2017, Vancouver, BC, Canada, September 24-28, 2017, pages 3834–3839. IEEE, 2017. doi:10.1109/IROS.2017.8206234.
  • [26] Weilin Luo, Pingjia Liang, Jianfeng Du, Hai Wan, Bo Peng, and Delong Zhang. Bridging ltlf inference to GNN inference for learning ltlf formulae. In AAAI, pages 9849–9857. AAAI Press, 2022. doi:10.1609/AAAI.V36I9.21221.
  • [27] Corto Mascle, Nathanaël Fijalkow, and Guillaume Lagarde. Learning temporal formulas from examples is hard. CoRR, abs/2312.16336, 2023. doi:10.48550/arXiv.2312.16336.
  • [28] Sara Mohammadinejad, Jyotirmoy V. Deshmukh, Aniruddh Gopinath Puranic, Marcell Vazquez-Chanlatte, and Alexandre Donzé. Interpretable classification of time-series data using efficient enumerative techniques. In HSCC ’20: 23rd ACM International Conference on Hybrid Systems: Computation and Control, Sydney, New South Wales, Australia, April 21-24, 2020, pages 9:1–9:10. ACM, 2020. doi:10.1145/3365365.3382218.
  • [29] Daniel Neider and Ivan Gavran. Learning linear temporal properties. In Nikolaj S. Bjørner and Arie Gurfinkel, editors, 2018 Formal Methods in Computer Aided Design, FMCAD 2018, Austin, TX, USA, October 30 - November 2, 2018, pages 1–10. IEEE, 2018. doi:10.23919/FMCAD.2018.8603016.
  • [30] Daniel Neider and Rajarshi Roy. What Is Formal Verification Without Specifications? A Survey on Mining LTL Specifications, pages 109–125. Springer Nature Switzerland, Cham, 2025. doi:10.1007/978-3-031-75778-5_6.
  • [31] C.H. Papadimitriou. Computational Complexity. Theoretical computer science. Addison-Wesley, 1994. URL: https://books.google.de/books?id=JogZAQAAIAAJ.
  • [32] Nir Piterman, Amir Pnueli, and Yaniv Sa’ar. Synthesis of reactive(1) designs. In E. Allen Emerson and Kedar S. Namjoshi, editors, Verification, Model Checking, and Abstract Interpretation, 7th International Conference, VMCAI 2006, Charleston, SC, USA, January 8-10, 2006, Proceedings, volume 3855 of Lecture Notes in Computer Science, pages 364–380. Springer, 2006. doi:10.1007/11609773_24.
  • [33] Amir Pnueli. The temporal logic of programs. In Proc. 18th Annu. Symp. Found. Computer Sci., pages 46–57, 1977. doi:10.1109/SFCS.1977.32.
  • [34] Adrien Pommellet, Daniel Stan, and Simon Scatton. Sat-based learning of computation tree logic. In Christoph Benzmüller, Marijn J. H. Heule, and Renate A. Schmidt, editors, Automated Reasoning - 12th International Joint Conference, IJCAR 2024, Nancy, France, July 3-6, 2024, Proceedings, Part I, volume 14739 of Lecture Notes in Computer Science, pages 366–385. Springer, 2024. doi:10.1007/978-3-031-63498-7_22.
  • [35] Ritam Raha, Rajarshi Roy, Nathanaël Fijalkow, and Daniel Neider. Scalable anytime algorithms for learning fragments of linear temporal logic. In Dana Fisman and Grigore Rosu, editors, Tools and Algorithms for the Construction and Analysis of Systems, pages 263–280, Cham, 2022. Springer International Publishing. doi:10.1007/978-3-030-99524-9_14.
  • [36] Ritam Raha, Rajarshi Roy, Nathanaël Fijalkow, Daniel Neider, and Guillermo A. Pérez. Synthesizing efficiently monitorable formulas in metric temporal logic. In VMCAI (2), volume 14500 of Lecture Notes in Computer Science, pages 264–288. Springer, 2024. doi:10.1007/978-3-031-50521-8_13.
  • [37] Heinz Riener. Exact synthesis of LTL properties from traces. In FDL, pages 1–6. IEEE, 2019. doi:10.1109/FDL.2019.8876900.
  • [38] Rajarshi Roy, Dana Fisman, and Daniel Neider. Learning interpretable models in the property specification language. In IJCAI, pages 2213–2219. ijcai.org, 2020. doi:10.24963/IJCAI.2020/306.
  • [39] Kristin Yvonne Rozier. Specification: The biggest bottleneck in formal methods and autonomy. In VSTTE, volume 9971 of Lecture Notes in Computer Science, pages 8–26, 2016. doi:10.1007/978-3-319-48869-1_2.
  • [40] Dorsa Sadigh, Eric S. Kim, Samuel Coogan, S. Shankar Sastry, and Sanjit A. Seshia. A learning based approach to control synthesis of markov decision processes for linear temporal logic specifications. In 53rd IEEE Conference on Decision and Control, CDC 2014, Los Angeles, CA, USA, December 15-17, 2014, pages 1091–1096. IEEE, 2014. doi:10.1109/CDC.2014.7039527.
  • [41] Mojtaba Valizadeh, Nathanaël Fijalkow, and Martin Berger. LTL learning on gpus. In Arie Gurfinkel and Vijay Ganesh, editors, Computer Aided Verification - 36th International Conference, CAV 2024, Montreal, QC, Canada, July 24-27, 2024, Proceedings, Part III, volume 14683 of Lecture Notes in Computer Science, pages 209–231. Springer, 2024. doi:10.1007/978-3-031-65633-0_10.
  • [42] Hai Wan, Pingjia Liang, Jianfeng Du, Weilin Luo, Rongzhen Ye, and Bo Peng. End-to-end learning of ltlf formulae by faithful ltlf encoding. In AAAI, pages 9071–9079. AAAI Press, 2024. doi:10.1609/AAAI.V38I8.28757.
  • [43] Andrzej Wasylkowski and Andreas Zeller. Mining temporal specifications from object usage. Autom. Softw. Eng., 18(3-4):263–292, 2011. doi:10.1007/S10515-011-0084-1.