Abstract 1 Introduction 2 Preliminaries 3 The Cardinality of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Models 4 The Complexity of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Satisfiability 5 The Complexity of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Model-Checking 6 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦 7 The Least Fixed Point Fragment of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦 8 Related Work 9 Conclusion References

The Complexity of Second-Order HyperLTL

Hadar Frenkel ORCID Bar-Ilan University, Ramat Gan, Israel Martin Zimmermann ORCID Aalborg University, Denmark
Abstract

We determine the complexity of second-order HyperLTL satisfiability, finite-state satisfiability, and model-checking: All three are equivalent to truth in third-order arithmetic.

We also consider two fragments of second-order HyperLTL that have been introduced with the aim to facilitate effective model-checking by restricting the sets one can quantify over. The first one restricts second-order quantification to smallest/largest sets that satisfy a guard while the second one restricts second-order quantification further to least fixed points of (first-order) HyperLTL definable functions. All three problems for the first fragment are still equivalent to truth in third-order arithmetic while satisfiability for the second fragment is Σ11-complete, i.e., only as hard as for (first-order) HyperLTL and therefore much less complex. Finally, finite-state satisfiability and model-checking are in Σ22 and are Σ11-hard, and thus also less complex than for full second-order HyperLTL.

Keywords and phrases:
HyperLTL, Satisfiability, Model-checking
Funding:
Martin Zimmermann: Supported by DIREC – Digital Research Centre Denmark.
Copyright and License:
[Uncaptioned image] © Hadar Frenkel and Martin Zimmermann; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Verification by model checking
; Theory of computation Logic and verification
Related Version:
Full Version: https://arxiv.org/abs/2311.15675 [21]
Acknowledgements:
This work was initiated by a discussion at Dagstuhl Seminar 23391 “The Futures of Reactive Synthesis” and some results were obtained at Dagstuhl Seminar 24111 “Logics for Dependence and Independence: Expressivity and Complexity”. We are grateful to Gaëtan Regaud for finding and fixing a bug in the proof of Theorem 18 and to the reviewers for their detailed and valuable feedback, which improved the paper considerably.
Editors:
Jörg Endrullis and Sylvain Schmitz

1 Introduction

The introduction of hyperlogics [11] for the specification and verification of hyperproperties [12] – properties that relate multiple system executions, has been one of the major success stories of formal verification during the last decade. Logics like HyperLTL and HyperCTL [11], the extensions of LTL [32] and CTL [14] (respectively) with trace quantification, are natural specification languages for information-flow and security properties, have a decidable model-checking problem [17], and hence found many applications in program verification.

However, while expressive enough to express common information-flow properties, they are unable to express other important hyperproperties, e.g., common knowledge in multi-agent systems and asynchronous hyperproperties (witnessed by a plethora of asynchronous extensions of HyperLTL, e.g., [1, 2, 3, 6, 9, 10, 23, 26, 27, 28]). These examples all have in common that they are second-order properties, i.e., they naturally require quantification over sets of traces, while HyperLTL (and HyperCTL) only allows quantification over traces.

In light of this situation, Beutner et al. [4] introduced the logic Hyper2LTL, which extends HyperLTL with second-order quantification, i.e., quantification over sets of traces. They show that the resulting logic, Hyper2LTL, is indeed able to capture common knowledge, asynchronous extensions of HyperLTL, and many other applications.

Consider, e.g., common knowledge in multi-agent systems where each agent i only observes some parts of the system. The agent knows that a statement φ holds if it holds on all traces that are indistinguishable in the agent’s view. We write πiπ if the traces π and π are indistinguishable for agent i. A property φ is common knowledge among all agents if all agents know φ, all agents know that all agents know φ, and so on, i.e., one takes the infinite closure of knowledge among all agents. This infinite closure cannot be expressed using first-order quantification over traces [8], like the one used in HyperLTL. The second-order quantification suggested by Beutner et al. allows us to express common knowledge, as demonstrated by the formula φ𝑐𝑘, which states that φ is common knowledge on all traces of the system (we use a simplified syntax for readability):

φ𝑐𝑘=π.X.πX(πX.π′′.(i=1nπiπ′′)π′′X)πX.φ(π)

The formula φ𝑐𝑘 expresses that for every trace t (instantiating π), there exists a set T (an instantiation of the second-order variable X) such that t is in T, T is closed under the observations of all agents (if t is in T and t′′ is indistinguishable from t for some agent i, then also t′′ is in T), and all traces in T satisfy φ.

However, Beutner et al. also note that this expressiveness comes at a steep price: model-checking Hyper2LTL is highly undecidable, i.e., Σ11-hard. Thus, their main result is a partial model-checking algorithm for a fragment of Hyper2LTL where second-order quantification degenerates to least fixed point computations of HyperLTL definable functions. Their algorithm over- and underapproximates these fixed points and then invokes a HyperLTL model-checking algorithm on these approximations. A prototype implementation of the algorithm is able to model-check properties capturing common knowledge, asynchronous hyperproperties, and distributed computing.

However, one question has been left open: Just how complex is Hyper2LTL verification?

Complexity Classes for Undecidable Problems.

The complexity of undecidable problems is typically captured in terms of the arithmetical and analytical hierarchy, where decision problems (encoded as subsets of ) are classified based on their definability by formulas of higher-order arithmetic, namely by the type of objects one can quantify over and by the number of alternations of such quantifiers. We refer to Roger’s textbook [35] for fully formal definitions and refer to Figure 1 for a visualization.

Figure 1: The arithmetical hierarchy, the analytical hierarchy, and beyond.

The class Σ10 contains the sets of natural numbers of the form

{xx0.xk.ψ(x,x0,,xk)}

where quantifiers range over natural numbers and ψ is a quantifier-free arithmetic formula. Note that this is exactly the class of recursively enumerable sets. The notation Σ10 signifies that there is a single block of existential quantifiers (the subscript 1) ranging over natural numbers (type 0 objects, explaining the superscript 0). Analogously, Σ11 is induced by arithmetic formulas with existential quantification of type 1 objects (sets of natural numbers) and arbitrary (universal and existential) quantification of type 0 objects. So, Σ10 is part of the first level of the arithmetical hierarchy while Σ11 is part of the first level of the analytical hierarchy. In general, level Σn0 (level Πn0) of the arithmetical hierarchy is induced by formulas with at most n1 alternations between existential and universal type 0 quantifiers, starting with an existential (universal) quantifier. Similar hierarchies can be defined for arithmetic of any fixed order by limiting the alternations of the highest-order quantifiers and allowing arbitrary lower-order quantification. In this work, the highest order we are concerned with is three, i.e., quantification over sets of sets of natural numbers.

HyperLTL satisfiability is Σ11-complete [19], HyperLTL finite-state satisfiability is Σ10-complete [16, 20], and, as mentioned above, Hyper2LTL model-checking is Σ11-hard [4], but, prior to this current work, no upper bounds were known for Hyper2LTL.

Another yardstick is truth for order k arithmetic, i.e., the question whether a given sentence of order k arithmetic evaluates to true. In the following, we are in particular interested in the case k=3, i.e., we consider formulas with arbitrary quantification over type 0 objects, type 1 objects, and type 2 objects (sets of sets of natural numbers). Note that these formulas span the whole third hierarchy, as we allow arbitrary nesting of existential and universal third-order quantification.

Our Contributions.

In this work, we determine the exact complexity of Hyper2LTL satisfiability, finite-state satisfiability, and model-checking, for the full logic and the two fragments introduced by Beutner et al. [4], as well as for two variations of the semantics.

An important stepping stone for us is the investigation of the cardinality of models of Hyper2LTL. It is known that every satisfiable HyperLTL sentence has a countable model, and that some have no finite models [18]. This restricts the order of arithmetic that can be simulated in HyperLTL and explains in particular the Σ11-completeness of HyperLTL satisfiability [19]. We show that (unsurprisingly) second-order quantification allows to write formulas that only have uncountable models by generalizing the lower bound construction of HyperLTL to Hyper2LTL. Note that the cardinality of the continuum is a trivial upper bound on the size of models, as they are sets of traces.

With this tool at hand, we are able to show that Hyper2LTL satisfiability is equivalent to truth in third-order arithmetic, i.e., much harder than HyperLTL satisfiability. This increase in complexity is not surprising, as second-order quantification can be expected to increase the complexity considerably. But what might be surprising at first glance is that the problem is not Σ12-complete, i.e., at the same position of the third hierarchy that HyperLTL satisfiability occupies in one full hierarchy below (see Figure 1). However, arbitrary second-order trace quantification corresponds to arbitrary quantification over type 2 objects, which allows to capture the full third hierarchy. Furthermore, we also show that Hyper2LTL finite-state satisfiability is equivalent to truth in third-order arithmetic, and therefore as hard as general satisfiability. This should be contrasted with the situation for HyperLTL described above, where finite-state satisfiability is Σ10-complete (i.e., recursively enumerable) and thus much simpler than general satisfiability, which is Σ11-complete.

Finally, our techniques for Hyper2LTL satisfiability also shed light on the exact complexity of Hyper2LTL model-checking, which we show to be equivalent to truth in third-order arithmetic as well, i.e., all three problems we consider have the same complexity. In particular, this increases the lower bound on Hyper2LTL model-checking from Σ11 to truth in third-order arithmetic. Again, this has be contrasted with the situation for HyperLTL, where model-checking is decidable, albeit Tower-complete [33, 31].

So, quantification over arbitrary sets of traces makes verification very hard. However, Beutner et al. [4] noticed that many of the applications of Hyper2LTL described above do not require full second-order quantification, but can be expressed with restricted forms of second-order quantification. To capture this, they first restrict second-order quantification to smallest/largest sets satisfying a guard (obtaining the fragment Hyper2LTLmm)111In [4] this fragment is termed Hyper2LTLfp. For clarity, since it is not fixed point based, but uses minimality/maximality constraints, we use the subscript “mm” instead of “fp”. and then further restrict those to least fixed points induced by HyperLTL definable operators (obtaining the fragment lfp-Hyper2LTLmm). By construction, these least fixed points are unique, i.e., second-order quantification degenerates to least fixed point computation.

As an example, consider again φ𝑐𝑘 above. The internal constraint

πX.π′′.(i=1nπiπ′′)π′′X

defines a condition on what traces have to be in the set X, and how they are added gradually to X, a behavior that can be captured by a fixed point computation for the (monotone) operator induced by the formula above. Since the last part πX.φ(π) of φ𝑐𝑘 universally quantifies over all traces in X, and since X is existentially quantified, it is enough to consider the minimal set that satisfies the internal constraint: if some set satisfies a universal condition, then so does the minimal set. This minimal set is exactly the least fixed point of the operator induced by the formula above. Similar behavior is exhibited by many other applications of the logic, which gives the motivation to explore the fragment lfp-Hyper2LTLmm.

Nevertheless, we show that Hyper2LTLmm retains the same complexity as Hyper2LTL, i.e., all three problems are still equivalent to truth in third-order arithmetic: Just restricting to guarded second-order quantification does not decrease the complexity.

For all results mentioned so far, it is irrelevant whether we allow second-order quantifiers to range over sets of traces that may contain traces that are not in the model (standard semantics) or whether we restrict these quantifiers to subsets of the model (closed-world semantics). But if we consider lfp-Hyper2LTLmm satisfiability under closed-world semantics, the complexity finally decreases to Σ11-completeness. Stated differently, one can add least fixed points of HyperLTL definable operators to HyperLTL without increasing the complexity of the satisfiability problem. Finally, for lfp-Hyper2LTLmm finite-state satisfiability and model-checking, we prove Σ22-membership and Σ11 lower bounds for both semantics, thereby confining the complexity to the second level of the third hierarchy.

Table 1 lists our results and compares them to LTL and HyperLTL. Recall that Beutner et al. showed that lfp-Hyper2LTLmm yields (partial) model checking and monitoring algorithms [4, 5]. Our results confirm the usability of the lfp-Hyper2LTLmm fragment also from a theoretical point of view, as all problems relevant for verification have significantly lower complexity (albeit, still highly undecidable).

Table 1: List of our results (in bold) and comparison to related logics. “T3A-equivalent” stands for “equivalent to truth in third-order arithmetic”. Entries marked with an asterisk only hold for closed-world semantics, all others hold for both semantics.
Logic Satisfiability Finite-state satisfiability Model-checking
LTL PSpace-complete PSpace-complete PSpace-complete
HyperLTL Σ11-complete Σ10-complete Tower-complete
𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 T3A-equivalent T3A-equivalent T3A-equivalent
𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦 T3A-equivalent T3A-equivalent T3A-equivalent
𝐥𝐟𝐩-𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦 𝚺𝟏𝟏-complete 𝚺𝟏𝟏-hard/in 𝚺𝟐𝟐 𝚺𝟏𝟏-hard/in 𝚺𝟐𝟐

Proofs omitted due to space restrictions can be found in the full version [21].

2 Preliminaries

We denote the nonnegative integers by . An alphabet is a nonempty finite set. The set of infinite words over an alphabet Σ is denoted by Σω. Let AP be a nonempty finite set of atomic propositions. A trace over AP is an infinite word over the alphabet 2AP. Given a subset APAP, the AP-projection of a trace t(0)t(1)t(2) over AP is the trace (t(0)AP)(t(1)AP)(t(2)AP) over AP.

A transition system 𝔗=(V,E,I,λ) consists of a finite nonempty set V of vertices, a set EV×V of (directed) edges, a set IV of initial vertices, and a labeling λ:V2AP of the vertices by sets of atomic propositions. We assume that every vertex has at least one outgoing edge. A path ρ through 𝔗 is an infinite sequence ρ(0)ρ(1)ρ(2) of vertices with ρ(0)I and (ρ(n),ρ(n+1))E for every n0. The trace of ρ is defined as λ(ρ)=λ(ρ(0))λ(ρ(1))λ(ρ(2)). The set of traces of 𝔗 is Tr(𝔗)={λ(ρ)ρ is a path through 𝔗}.

𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋.

Let 𝒱1 be a set of first-order trace variables (i.e., ranging over traces) and 𝒱2 be a set of second-order trace variables (i.e., ranging over sets of traces) such that 𝒱1𝒱2=. We typically use π (possibly with decorations) to denote first-order variables and X,Y,Z (possibly with decorations) to denote second-order variables. Also, we assume the existence of two distinguished second-order variables Xa,Xd𝒱2 such that Xa refers to the set (2AP)ω of all traces, and Xd refers to the universe of discourse (the set of traces the formula is evaluated over).

The formulas of Hyper2LTL are given by the grammar

φ::=X.φX.φπX.φπX.φψψ::=pπ¬ψψψ𝐗ψψ𝐔ψ

where p ranges over AP, π ranges over 𝒱1, X ranges over 𝒱2, and 𝐗 (next) and 𝐔 (until) are temporal operators. Conjunction (), exclusive disjunction (), implication (), and equivalence () are defined as usual, and the temporal operators eventually (𝐅) and always (𝐆) are derived as 𝐅ψ=¬ψ𝐔ψ and 𝐆ψ=¬𝐅¬ψ. We measure the size of a formula by its number of distinct subformulas.

The semantics of Hyper2LTL is defined with respect to a variable assignment, i.e., a partial mapping Π:𝒱1𝒱2(2AP)ω2(2AP)ω such that

  • if Π(π) for π𝒱1 is defined, then Π(π)(2AP)ω and

  • if Π(X) for X𝒱2 is defined, then Π(X)2(2AP)ω.

Given a variable assignment Π, a variable π𝒱1, and a trace t, we denote by Π[πt] the assignment that coincides with Π on all variables but π, which is mapped to t. Similarly, for a variable X𝒱2, and a set T of traces, Π[XT] is the assignment that coincides with Π everywhere but X, which is mapped to T. Furthermore, Π[j,) denotes the variable assignment mapping every π𝒱1 in Π’s domain to Π(π)(j)Π(π)(j+1)Π(π)(j+2), the suffix of Π(π) starting at position j (the assignment of variables X𝒱2 is not updated).

For a variable assignment Π we define

  • Πpπ if pΠ(π)(0),

  • Π¬ψ if Π⊧̸ψ,

  • Πψ1ψ2 if Πψ1 or Πψ2,

  • Π𝐗ψ if Π[1,)ψ,

  • Πψ1𝐔ψ2 if there is a j0 such that Π[j,)ψ2 and for all 0j<j we have Π[j,)ψ1 ,

  • ΠπX.φ if there exists a trace tΠ(X) such that Π[πt]φ ,

  • ΠπX.φ if for all traces tΠ(X) we have Π[πt]φ,

  • ΠX.φ if there exists a set T(2AP)ω such that Π[XT]φ, and

  • ΠX.φ if for all sets T(2AP)ω we have Π[XT]φ.

Throughout the paper, we use the following shorthands to simplify our formulas:

  • We write π=APπ for a set APAP for the formula 𝐆pAP(pπpπ) expressing that the AP-projection of π and the AP-projection of π are equal.

  • We write πX for the formula πX.π=APπ expressing that the trace π is in X. Note that this shorthand cannot be used under the scope of temporal operators, as we require formulas to be in prenex normal form.

A sentence is a formula in which only the variables Xa,Xd can be free. The variable assignment with empty domain is denoted by Π. We say that a set T of traces satisfies a Hyper2LTL sentence φ, written Tφ, if Π[Xa(2AP)ω,XdT]φ, i.e., if we assign the set of all traces to Xa and the set T to the universe of discourse Xd. In this case, we say that T is a model of φ. A transition system 𝔗 satisfies φ, written 𝔗φ, if Tr(𝔗)φ.

Although Hyper2LTL sentences are required to be in prenex normal form, Hyper2LTL sentences are closed under Boolean combinations, which can easily be seen by transforming such a sentence into an equivalent one in prenex normal form (which might require renaming of variables). Thus, in examples and proofs we will often use Boolean combinations of Hyper2LTL sentences.

 Remark 1.

HyperLTL is the fragment of Hyper2LTL obtained by disallowing second-order quantification and only allowing first-order quantification of the form πXd and πXd, i.e., one can only quantify over traces from the universe of discourse. Hence, we typically simplify our notation to π and π in HyperLTL formulas.

Closed-World Semantics.

Second-order quantification in Hyper2LTL as defined by Beutner et al. [4] (and introduced above) ranges over arbitrary sets of traces (not necessarily from the universe of discourse) and first-order quantification ranges over elements in such sets, i.e., (possibly) again over arbitrary traces. To disallow this, we introduce closed-world semantics for Hyper2LTL, only considering formulas that do not use the variable Xa. We change the semantics of set quantifiers as follows, where the closed-world semantics of atomic propositions, Boolean connectives, temporal operators, and trace quantifiers is defined as before:

  • ΠcwX.φ if there exists a set TΠ(Xd) such that Π[XT]φ, and

  • ΠcwX.φ if for all sets TΠ(Xd) we have Π[XT]φ.

We say that T(2AP)ω satisfies φ under closed-world semantics, if Π[XdT]cwφ. Hence, under closed-world semantics, second-order quantifiers only range over subsets of the universe of discourse. Consequently, first-order quantifiers also range over traces from the universe of discourse.

Lemma 2.

Every Hyper2LTL sentence φ can be translated in polynomial time (in |φ|) into a Hyper2LTL sentence φ such that for all sets T of traces we have that Tcwφ if and only if Tφ (under standard semantics).

Thus, all complexity upper bounds we derive for standard semantics also hold for closed-world semantics and all lower bounds for closed-world semantics hold for standard semantics.

 Remark 3.

Let φ be an Xa-free Hyper2LTL sentence over AP. We have (2AP)ωφ (under standard semantics) if and only if (2AP)ωcwφ, as the second-order quantifiers range in both cases over subsets of (2AP)ω, which implies that the trace quantifiers in both cases range over traces from (2AP)ω.

Arithmetic.

To capture the complexity of undecidable problems, we consider formulas of arithmetic, i.e., predicate logic with signature (+,,<,), evaluated over the structure (,+,,<,). A type 0 object is a natural number in , a type 1 object is a subset of , and a type 2 object is a set of subsets of .

Our benchmark is third-order arithmetic, i.e., predicate logic with quantification over type 0, type 1, and type 2 objects. In the following, we use lower-case roman letters (possibly with decorations) for first-order variables, upper-case roman letters (possibly with decorations) for second-order variables, and upper-case calligraphic roman letters (possibly with decorations) for third-order variables. Note that every fixed natural number is definable in first-order arithmetic, so we freely use them as syntactic sugar. Truth of third-order arithmetic is the following problem: given a sentence φ of third-order arithmetic, does (,+,,<,) satisfy φ?

Arithmetic formulas with a single free first-order variable define sets of natural numbers. We are interested in the classes

  • Σ11 containing sets of the form {xX1.Xk.ψ(x,X1,,Xk)}, where ψ is a formula of arithmetic with arbitrary quantification over type 0 objects (but no second-order quantifiers), and

  • Σ22 containing sets of the following form, where ψ is a formula of arithmetic with arbitrary quantification over type 0 and type 1 objects (but no third-order quantifiers): {x𝒳12.𝒳k2.𝒴12.𝒴k2.ψ(x,𝒳1,,𝒳k,𝒴1,,𝒴k)}.

3 The Cardinality of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Models

In this section, we investigate the cardinality of models of satisfiable Hyper2LTL sentences, i.e., the number of traces in the model.

We begin by stating a (trivial) upper bound, which follows from the fact that models are sets of traces. Here, 𝔠 denotes the cardinality of the continuum (equivalently, the cardinality of 2 and of (2AP)ω for any finite nonempty AP).

Proposition 4.

Every satisfiable Hyper2LTL sentence has a model of cardinality at most 𝔠.

In this section, we show that this trivial upper bound is tight.

 Remark 5.

There is a very simple, albeit equally unsatisfactory way to obtain the desired lower bound: Consider πXa.πXd expressing that every trace in the set of all traces is also in the universe of discourse, i.e., (2AP)ω is its only model over AP. However, this crucially relies on the fact that Xa is, by definition, interpreted as the set of all traces. In fact, the formula does not even use second-order quantification.

We show how to construct a sentence that has only uncountable models, and which retains that property under closed-world semantics (which in particular means it cannot use Xa). This should be compared with HyperLTL, where every satisfiable sentence has a countable model [18]: Unsurprisingly, the addition of (even closed-world) second-order quantification increases the cardinality of minimal models, even without cheating.

Example 6.

We begin by recalling a construction of Finkbeiner and Zimmermann giving a satisfiable HyperLTL sentence ψ that has no finite models [18]. The sentence intuitively posits the existence of a unique trace for every natural number n. Our lower bound for Hyper2LTL builds upon that construction.

Fix AP={x} and consider the conjunction ψ=ψ1ψ2ψ3 of the following three formulas:

  1. 1.

    ψ1=π.¬xπ𝐔(xπ𝐗𝐆¬xπ): every trace in a model is of the form n{x}ω for some n, i.e., every model is a subset of {n{x}ωn}.

  2. 2.

    ψ2=π.xπ: the trace 0{x}ω is in every model.

  3. 3.

    ψ3=π.π.𝐅(xπ𝐗xπ): if n{x}ω is in a model for some n, then also n+1{x}ω.

Then, ψ has exactly one model (over AP), namely {n{x}ωn}.

A trace of the form n{x}ω encodes the natural number n and ψ expresses that every model contains the encodings of all natural numbers and nothing else. But we can of course also encode sets of natural numbers with traces as follows: a trace t over a set of atomic propositions containing x encodes the set {nxt(n)}. In the following, we show that second-order quantification allows us to express the existence of the encodings of all subsets of natural numbers by requiring that for every subset S (quantified as the set {n{x}ωnS} of traces) there is a trace t encoding S, which means x is in t(n) if and only if S contains a trace in which x holds at position n. This equivalence can be expressed in Hyper2LTL. For technical reasons, we do not capture the equivalence directly but instead use encodings of both the natural numbers that are in S and the natural numbers that are not in S.

Theorem 7.

There is a satisfiable Xa-free Hyper2LTL sentence that only has models of cardinality 𝔠 (both under standard and closed-world semantics).

Proof.

We first prove that there is a satisfiable Xa-free Hyper2LTL sentence φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠 whose unique model (under standard semantics) has cardinality 𝔠. To this end, we fix AP={+,-,s,x} and consider the conjunction φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠=φ0φ4 of the following formulas:

  • φ0=πXd.p{+,-,s}𝐆(pπp{+,-,s}{p}¬pπ): In each trace of a model, one of the propositions in {+,-,s} holds at every position and the other two propositions in {+,-,s} hold at none of the positions. Consequently, we speak in the following about type p traces for p{+,-,s}.

  • φ1=πXd.(+π-π)¬xπ𝐔(xπ𝐗𝐆¬xπ): Type p traces for p{+,-} in the model have the form {p}n{x,p}{p}ω for some n.

  • φ2=p{+,-}πXd.pπxπ: for both p{+,-}, the type p trace {p}0{x,p}{p}ω is in every model.

  • φ3=p{+,-}πXd.πXd.pπ(pπ𝐅(xπ𝐗xπ)): for both p{+,-}, if the type p trace {p}n{x,p}{p}ω is in a model for some n, then also {p}n+1{x,p}{p}ω.

The formulas φ1,φ2,φ3 are similar to the formulas ψ1,ψ2,ψ3 from Example 6. So, every model of φ0φ3 contains {{+}n{x,+}{+}ωn} and {{-}n{x,-}{-}ωn} as subsets, and no other type + or type - traces.

Now, consider a set T of traces over AP (recall that second-order quantification ranges over arbitrary sets, not only over subsets of the universe of discourse). We say that T is contradiction-free if there is no n such that {+}n{x,+}{+}ωT and {-}n{x,-}{-}ωT. Furthermore, a trace t over AP is consistent with a contradiction-free T if

(C1)

{+}n{x,+}{+}ωT implies xt(n) and

(C2)

{-}n{x,-}{-}ωT implies xt(n).

Note that T does not necessarily specify the truth value of x in every position of t, i.e., in those positions n where neither {+}n{x,+}{+}ω nor {-}n{x,-}{-}ω are in T. Nevertheless, for every trace t over {x} there is a contradiction-free T such that the {x}-projection of every trace t over AP that is consistent with T is equal to t. Thus, each of the uncountably many traces over {x} is induced by some subset of the model.

  • Hence, we define φ4 as the formula

    X. [πX.πX.(+π-π)¬𝐅(xπxπ)]X is contradiction-free
    π′′Xd.π′′′X.sπ′′(+π′′′𝐅(xπ′′′xπ′′))(C1)(-π′′′𝐅(xπ′′′¬xπ′′))(C2),

    expressing that for every contradiction-free set of traces T, there is a type s trace t′′ in the model (note that π′′ is required to be in Xd) that is consistent with T.

While φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠 is not in prenex normal form, it can easily be turned into an equivalent formula in prenex normal form (at the cost of readability).

Now, the set

T𝑎𝑙𝑙𝑆𝑒𝑡𝑠= {{+}n{x,+}{+}ωn}{{-}n{x,-}{-}ωn}
{(t(0){s})(t(1){s})(t(2){s})t(2{x})ω}

of traces satisfies φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠. On the other hand, every model of φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠 must indeed contain T𝑎𝑙𝑙𝑆𝑒𝑡𝑠 as a subset, as φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠 requires the existence of all of its traces in the model. Finally, due to φ0 and φ1, a model (over AP) cannot contain any traces that are not in T𝑎𝑙𝑙𝑆𝑒𝑡𝑠, i.e., T𝑎𝑙𝑙𝑆𝑒𝑡𝑠 is the unique model of φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠.

To conclude, we just remark that

{(t(0){s})(t(1){s})(t(2){s})t(2{x})ω}T𝑎𝑙𝑙𝑆𝑒𝑡𝑠

has indeed cardinality 𝔠, as (2{x})ω has cardinality 𝔠.

Finally, let us consider closed-world semantics. We can restrict the second-order quantifier in φ4 (the only one in φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠) to subsets of the universe of discourse, as the set T={{+}n{x,+}{+}ωn}{{-}n{x,-}{-}ωn} of traces (which is a subset of every model) is already rich enough to encode every subset of by an appropriate contradiction-free subset of T. Thus, φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠 has the unique model T𝑎𝑙𝑙𝑆𝑒𝑡𝑠 even under closed-world semantics.

4 The Complexity of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Satisfiability

A Hyper2LTL sentence is satisfiable if it has a model. The Hyper2LTL satisfiability problem asks, given a Hyper2LTL sentence φ, whether φ is satisfiable. In this section, we determine tight bounds on the complexity of Hyper2LTL satisfiability and some of its variants.

Recall that in Section 3, we encoded sets of natural numbers as traces over a set of propositions containing x and encoded natural numbers as singleton sets. The proof of Theorem 7 relies on constructing a sentence that requires each of its models to encode every subset of by a trace in the model. Hence, sets of traces can encode sets of sets of natural numbers, i.e., type 2 objects.

Another important ingredient in the following proof is the implementation of addition and multiplication in HyperLTL. Let AP𝑎𝑟𝑖𝑡ℎ={arg1,arg2,res,add,mult} and let T(+,) be the set of all traces t(2AP𝑎𝑟𝑖𝑡ℎ)ω such that:

  • there are unique n1,n2,n3 with arg1t(n1), arg2t(n2), and rest(n3), and

  • either addt(n) and multt(n) for all n, and n1+n2=n3, or multt(n) and addt(n) for all n, and n1n2=n3.

Proposition 8 (Theorem 5.5 of [20]).

There is a satisfiable HyperLTL sentence φ(+,) such that the AP𝑎𝑟𝑖𝑡ℎ-projection of every model of φ(+,) is T(+,).

Combining the capability of quantifying over type 0, type 1, and type 2 objects and the encoding of addition and multiplication, we show that Hyper2LTL and truth in third-order arithmetic have the same complexity.

Theorem 9.

The Hyper2LTL satisfiability problem is polynomial-time equivalent to truth in third-order arithmetic. The lower bound holds even for Xa-free sentences.

Proof.

We begin with the lower bound by reducing truth in third-order arithmetic to Hyper2LTL satisfiability: we present a polynomial-time translation from sentences φ of third-order arithmetic to Hyper2LTL sentences φ such that (,+,,<,)φ if and only if φ is satisfiable.

Given a third-order sentence φ, we define

φ=X𝑎𝑙𝑙𝑆𝑒𝑡𝑠.X𝑎𝑟𝑖𝑡ℎ.(φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠[Xd/X𝑎𝑙𝑙𝑆𝑒𝑡𝑠]φ(+,)ℎ𝑦𝑝(φ))

where

  • φ𝑎𝑙𝑙𝑆𝑒𝑡𝑠[Xd/X𝑎𝑙𝑙𝑆𝑒𝑡𝑠] is the Hyper2LTL sentence from the proof of Theorem 7 where every occurrence of Xd is replaced by X𝑎𝑙𝑙𝑆𝑒𝑡𝑠 and thus enforces every subset of to be encoded in the interpretation of X𝑎𝑙𝑙𝑆𝑒𝑡𝑠 (as introduced in the proof of Theorem 7),

  • φ(+,) is the Hyper2LTL formula obtained from the HyperLTL formula φ(+,) by replacing each quantifier π (π, respectively) by πX𝑎𝑟𝑖𝑡ℎ (πX𝑎𝑟𝑖𝑡ℎ, respectively) and thus enforces that X𝑎𝑟𝑖𝑡ℎ is interpreted by a set whose AP𝑎𝑟𝑖𝑡ℎ-projection is T(+,), and

where ℎ𝑦𝑝(φ) is defined inductively as follows:

  • For third-order variables 𝒴,

    ℎ𝑦𝑝(𝒴.ψ)=X𝒴.(πX𝒴.πX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.(π={+,-,s,x}π)sπ)ℎ𝑦𝑝(ψ).
  • For third-order variables 𝒴,

    ℎ𝑦𝑝(𝒴.ψ)=X𝒴.(πX𝒴.πX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.(π={+,-,s,x}π)sπ)ℎ𝑦𝑝(ψ).
  • For second-order variables Y, ℎ𝑦𝑝(Y.ψ)=πYX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.sπYℎ𝑦𝑝(ψ).

  • For second-order variables Y, ℎ𝑦𝑝(Y.ψ)=πYX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.sπYℎ𝑦𝑝(ψ).

  • For first-order variables y,

    ℎ𝑦𝑝(y.ψ)=πyX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.sπy[(¬xπy)𝐔(xπy𝐗𝐆¬xπy)]ℎ𝑦𝑝(ψ).
  • For first-order variables y,

    ℎ𝑦𝑝(y.ψ)=πyX𝑎𝑙𝑙𝑆𝑒𝑡𝑠.(sπy[(¬xπy)𝐔(xπy𝐗𝐆¬xπy)])ℎ𝑦𝑝(ψ).
  • ℎ𝑦𝑝(ψ1ψ2)=ℎ𝑦𝑝(ψ1)ℎ𝑦𝑝(ψ2).

  • ℎ𝑦𝑝(¬ψ)=¬ℎ𝑦𝑝(ψ).

  • For second-order variables Y and third-order variables 𝒴,

    ℎ𝑦𝑝(Y𝒴)=πX𝒴.πY={x}π.
  • For first-order variables y and second-order variables Y, ℎ𝑦𝑝(yY)=𝐅(xπyxπY).

  • For first-order variables y,y, ℎ𝑦𝑝(y<y)=𝐅(xπy𝐗𝐅xπy).

  • For first-order variables y1,y2,y,

    ℎ𝑦𝑝(y1+y2=y)=πX𝑎𝑟𝑖𝑡ℎ.addπ𝐅(arg1πxπy1)𝐅(arg2πxπy2)𝐅(resπxπy).
  • For first-order variables y1,y2,y,

    ℎ𝑦𝑝(y1y2=y)=πX𝑎𝑟𝑖𝑡ℎ.multπ𝐅(arg1πxπy1)𝐅(arg2πxπy2)𝐅(resπxπy).

While φ is not in prenex normal form, it can easily be brought into prenex normal form, as there are no quantifiers under the scope of a temporal operator.

As we are evaluating φ w.r.t. standard semantics and the variable Xd (interpreted with the model) does not occur in φ, satisfaction of φ is independent of the model, i.e., for all sets T,T of traces, Tφ if and only if Tφ. So, let us fix some set T of traces. An induction shows that (,+,,<,) satisfies φ if and only if T satisfies φ. Altogether we obtain the desired equivalence between (,+,,<,)φ and φ being satisfiable.

For the upper bound, we conversely reduce Hyper2LTL satisfiability to truth in third-order arithmetic: we present a polynomial-time translation from Hyper2LTL sentences φ to sentences φ of third-order arithmetic such that φ is satisfiable if and only if (,+,,<,)φ. Here, we assume AP to be fixed, so that we can use |AP| as a constant in our formulas (which is definable in arithmetic).

Let 𝑝𝑎𝑖𝑟:× denote Cantor’s pairing function defined as 𝑝𝑎𝑖𝑟(i,j)=12(i+j)(i+j+1)+j, which is a bijection. Furthermore, fix some bijection e:AP{0,1,,|AP|1}. Then, we encode a trace t(2AP)ω by the set St={𝑝𝑎𝑖𝑟(j,e(p))j and pt(j)}. As 𝑝𝑎𝑖𝑟 is a bijection, we have that tt implies StSt. While not every subset of encodes some trace t, the first-order formula

φ𝑖𝑠𝑇𝑟𝑎𝑐𝑒(Y)=x.y.y|AP|𝑝𝑎𝑖𝑟(x,y)Y

checks if a set does encode a trace. Here, we use 𝑝𝑎𝑖𝑟 as syntactic sugar, which is possible as the definition of 𝑝𝑎𝑖𝑟 only uses addition and multiplication.

As (certain) sets of natural numbers encode traces, sets of (certain) sets of natural numbers encode sets of traces. This is sufficient to reduce Hyper2LTL to third-order arithmetic, which allows the quantification over sets of sets of natural numbers. Before we present the translation, we need to introduce some more auxiliary formulas:

  • Let 𝒴 be a third-order variable (i.e., 𝒴 ranges over sets of sets of natural numbers). Then, the formula

    φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴)=Y.Y𝒴φ𝑖𝑠𝑇𝑟𝑎𝑐𝑒(Y)

    checks if a set of sets of natural numbers only contains sets encoding a trace.

  • Further, the formula

    φ𝑎𝑙𝑙𝑇𝑟𝑎𝑐𝑒𝑠(𝒴)=φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴)Y.φ𝑖𝑠𝑇𝑟𝑎𝑐𝑒(Y)Y𝒴

    checks if a set of sets of natural numbers contains exactly the sets encoding a trace.

Now, we are ready to define our encoding of Hyper2LTL in third-order arithmetic. Given a Hyper2LTL sentence φ, let

φ=𝒴a.𝒴d.φ𝑎𝑙𝑙𝑇𝑟𝑎𝑐𝑒𝑠(𝒴a)φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴d)(𝑎𝑟(φ))(0)

where 𝑎𝑟(φ) is defined inductively as presented below. Note that φ requires 𝒴a to contain exactly the encodings of all traces (i.e., it corresponds to the distinguished Hyper2LTL variable Xa in the following translation) and 𝒴d is an existentially quantified set of trace encodings (i.e., it corresponds to the distinguished Hyper2LTL variable Xd in the following translation).

In the inductive definition of 𝑎𝑟(φ), we will employ a free first-order variable i to denote the position at which the formula is to be evaluated to capture the semantics of the temporal operators. As seen above, in φ, this free variable is set to zero in correspondence with the Hyper2LTL semantics.

  • 𝑎𝑟(X.ψ)=𝒴X.φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴X)𝑎𝑟(ψ). Here, the free variable of 𝑎𝑟(X.ψ) is the free variable of 𝑎𝑟(ψ).

  • 𝑎𝑟(X.ψ)=𝒴X.φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴X)𝑎𝑟(ψ). Here, the free variable of 𝑎𝑟(X.ψ) is the free variable of 𝑎𝑟(ψ).

  • 𝑎𝑟(πX.ψ)=Yπ.Yπ𝒴X𝑎𝑟(ψ). Here, the free variable of 𝑎𝑟(πX.ψ) is the free variable of 𝑎𝑟(ψ).

  • 𝑎𝑟(πX.ψ)=Yπ.Yπ𝒴X𝑎𝑟(ψ). Here, the free variable of 𝑎𝑟(πX.ψ) is the free variable of 𝑎𝑟(ψ).

  • 𝑎𝑟(ψ1ψ2)=𝑎𝑟(ψ1)𝑎𝑟(ψ2). Here, we require that the free variables of 𝑎𝑟(ψ1) and 𝑎𝑟(ψ2) are the same (which can always be achieved by variable renaming), which is then also the free variable of 𝑎𝑟(ψ1ψ2).

  • 𝑎𝑟(¬ψ)=¬𝑎𝑟(ψ). Here, the free variable of 𝑎𝑟(¬ψ) is the free variable of ¬𝑎𝑟(ψ).

  • 𝑎𝑟(𝐗ψ)=i(i=i+1)𝑎𝑟(ψ), where i is the free variable of 𝑎𝑟(ψ) and i is the free variable of 𝑎𝑟(𝐗ψ).

  • 𝑎𝑟(ψ1𝐔ψ2)=i2.i2i𝑎𝑟(ψ2)i1.(ii1i1<i2)𝑎𝑟(ψ1), where ij is the free variable of 𝑎𝑟(ψj), and i is the free variable of 𝑎𝑟(ψ1𝐔ψ2).

  • 𝑎𝑟(pπ)=𝑝𝑎𝑖𝑟(i,e(p))Yπ, i.e., i is the free variable of 𝑎𝑟(pπ).

Now, an induction shows that Π[Xa(2AP)ω,XdT]φ if and only if (,+,,<,) satisfies (𝑎𝑟(φ))(0) when the variable 𝒴a is interpreted by the encoding of (2AP)ω and 𝒴d is interpreted by the encoding of T. Hence, φ is indeed satisfiable if and only if (,+,,<,) satisfies φ.

In the lower bound proof above, we have turned a sentence φ of third-order arithmetic into a Hyper2LTL sentence φ such that (,+,,<,)φ if and only if φ is satisfiable. In fact, we have constructed φ such that if it is satisfiable, then every set of traces satisfies it, in particular (2AP)ω. Recall that Remark 3 states that (2AP)ω satisfies φ under standard semantics if and only if (2AP)ω satisfies φ under closed-world semantics. Thus, altogether we obtain that (,+,,<,)φ if and only if φ is satisfiable under closed-world semantics, i.e, the lower bound holds even under closed-world semantics. Together with Lemma 2, this settles the complexity of Hyper2LTL satisfiability under closed-world semantics.

Corollary 10.

The Hyper2LTL satisfiability problem under closed-world semantics is polynomial-time equivalent to truth in third-order arithmetic.

The Hyper2LTL finite-state satisfiability problem asks, given a Hyper2LTL sentence φ, whether there is a finite transition system satisfying φ. Note that we do not ask for a finite set T of traces satisfying φ. In fact, the set of traces of the finite transition system may still be infinite or even uncountable. Nevertheless, the problem is potentially simpler, as there are only countably many finite transition systems (and their sets of traces are much simpler). However, we show that the finite-state satisfiability problem is as hard as the general satisfiability problem, as Hyper2LTL allows the quantification over arbitrary (sets of) traces, i.e., restricting the universe of discourse to the traces of a finite transition system does not restrict second-order quantification at all (as the set of all traces is represented by a finite transition system). This has to be contrasted with the finite-state satisfiability problem for HyperLTL (defined analogously), which is Σ10-complete (a.k.a. recursively enumerable), as HyperLTL model-checking of finite transition systems is decidable [11].

Theorem 11.

The Hyper2LTL finite-state satisfiability problem is polynomial-time equivalent to truth in third-order arithmetic. The lower bound holds even for Xa-free sentences.

Proof.

For the lower bound under standard semantics, we reduce truth in third-order arithmetic to Hyper2LTL finite-state satisfiability: we present a polynomial-time translation from sentences φ of third-order arithmetic to Hyper2LTL sentences φ such that (,+,, <,)φ if and only if φ is satisfied by a finite transition system.

So, let φ be a sentence of third-order arithmetic. Recall that in the proof of Theorem 9, we have shown how to construct from φ the Hyper2LTL sentence φ such that the following three statements are equivalent:

  • (,+,,<,)φ.

  • φ is satisfiable.

  • φ is satisfied all sets T of traces (and in particular by some finite-state transition system).

Thus, the lower bound follows from Theorem 9.

For the upper bound, we conversely reduce Hyper2LTL finite-state satisfiability to truth in third-order arithmetic: we present a polynomial-time translation from Hyper2LTL sentences φ to sentences φ′′ of third-order arithmetic such that φ is satisfied by a finite transition system if and only if (,+,,<,)φ′′.

Recall that in the proof of Theorem 9, we have constructed a sentence

φ=𝒴a.𝒴d.φ𝑎𝑙𝑙𝑇𝑟𝑎𝑐𝑒𝑠(𝒴a)φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴d)(𝑎𝑟(φ))(0)

of third-order arithmetic where 𝒴a represents the distinguished Hyper2LTL variable Xa, 𝒴d represents the distinguished Hyper2LTL variable Xd, and where 𝑎𝑟(φ) is the encoding of φ in Hyper2LTL.

To encode the general satisfiability problem it was sufficient to express that 𝒴d only contains traces. Here, we now require that 𝒴d contains exactly the traces of some finite transition system, which can easily be expressed in second-order arithmetic222With a little more effort, and a little less readability, first-order suffices for this task, as finite transition systems can be encoded by natural numbers. as follows.

We begin with a formula φ𝑖𝑠𝑇𝑆(n,E,I,) expressing that the second-order variables E, I, and encode a transition system with set {0,1,,n1} of vertices. Our encoding will make extensive use of the pairing function introduced in the proof of Theorem 9. Formally, we define φ𝑖𝑠𝑇𝑆(n,E,I,) as the conjunction of the following formulas (where all quantifiers are first-order and we use 𝑝𝑎𝑖𝑟 as syntactic sugar):

  • n>0: the transition system is nonempty.

  • y.yEv.v.(v<nv<ny=𝑝𝑎𝑖𝑟(v,v)): edges are pairs of vertices.

  • v.v<nv.(v<n𝑝𝑎𝑖𝑟(v,v)E): every vertex has a successor.

  • v.vIv<n: the set of initial vertices is a subset of the set of all vertices.

  • y.yv.p.(v<np<|AP|y=𝑝𝑎𝑖𝑟(v,p)): the labeling of v by p is encoded by the pair (v,p). Here, we again assume AP to be fixed and therefore can use |AP| as a constant.

Next, we define φ𝑖𝑠𝑃𝑎𝑡ℎ(P,n,E,I), expressing that the second-order variable P encodes a path through the transition system encoded by n, E, and I, as the conjunction of the following formulas:

  • j.v.(v<n𝑝𝑎𝑖𝑟(j,v)P¬v.(vv𝑝𝑎𝑖𝑟(j,v)P)): the fact that at position j the path visits vertex v is encoded by the pair (j,v). Exactly one vertex is visited at each position.

  • v.vI𝑝𝑎𝑖𝑟(0,v)P: the path starts in an initial vertex.

  • j.v.v.𝑝𝑎𝑖𝑟(j,v)P𝑝𝑎𝑖𝑟(j+1,v)P𝑝𝑎𝑖𝑟(v,v)E: successive vertices in the path are indeed connected by an edge.

Finally, we define φ𝑡𝑟𝑎𝑐𝑒𝑂𝑓(T,P,), expressing that the second-order variable T encodes the trace (using the encoding from the proof of Theorem 9) of the path encoded by the second-order variable P, as the following formula:

  • j.p.𝑝𝑎𝑖𝑟(j,p)T(v.𝑝𝑎𝑖𝑟(j,v)P𝑝𝑎𝑖𝑟(v,p)): a proposition holds in the trace at position j if and only if it is in the labeling of the j-th vertex of the path.

Now, we define the sentence φ′′ as

𝒴a.𝒴d. φ𝑎𝑙𝑙𝑇𝑟𝑎𝑐𝑒𝑠(𝒴a)φ𝑜𝑛𝑙𝑦𝑇𝑟𝑎𝑐𝑒𝑠(𝒴d)
[n.E.I..φ𝑖𝑠𝑇𝑆(n,E,I,)there exists a transition system 𝔗
(T.T𝒴dP.(φ𝑖𝑠𝑃𝑎𝑡ℎ(P,n,E,I)φ𝑡𝑟𝑎𝑐𝑒𝑂𝑓(T,P,)))𝒴d contains only traces of paths through 𝔗
(P.(φ𝑖𝑠𝑃𝑎𝑡ℎ(P,n,E,I)T.T𝒴dφ𝑡𝑟𝑎𝑐𝑒𝑂𝑓(T,P,)))𝒴d contains all traces of paths through 𝔗.](𝑎𝑟(φ))(0),

which holds in (,+,,<,) if and only if φ is satisfied by a finite transition system.

Again, the lower bound proof can easily be extended to the case of closed-world semantics, using the same arguments as in the case of general satisfiability.

Corollary 12.

The Hyper2LTL finite-state satisfiability problem under closed-world semantics is polynomial-time equivalent to truth in third-order arithmetic.

5 The Complexity of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋 Model-Checking

The Hyper2LTL model-checking problem asks, given a finite transition system 𝔗 and a Hyper2LTL sentence φ, whether 𝔗φ. Beutner et al. [4] have shown that Hyper2LTL model-checking is Σ11-hard, but there is no known upper bound in the literature. We improve the lower bound considerably, i.e., also to truth in third-order arithmetic, and show that this bound is tight. This is the first upper bound on the problem’s complexity.

Theorem 13.

The Hyper2LTL model-checking problem is polynomial-time equivalent to truth in third-order arithmetic. The lower bound already holds for Xa-free sentences.

Proof.

For the lower bound, we reduce truth in third-order arithmetic to the Hyper2LTL model-checking problem: we present a polynomial-time translation from sentences φ of third-order arithmetic to pairs (𝔗,φ) of a finite transition system 𝔗 and a Hyper2LTL sentence φ such that (,+,,<,)φ if and only if 𝔗φ.

In the proof of Theorem 9 we have, given a sentence φ of third-order arithmetic, constructed a Hyper2LTL sentence φ such that (,+,,<,)φ if and only if every set T of traces satisfies φ (i.e., satisfaction is independent of the model). Thus, we obtain the lower bound by mapping φ to φ and 𝔗, where 𝔗 is some fixed transition system.

For the upper bound, we reduce the Hyper2LTL model-checking problem to truth in third-order arithmetic: we present a polynomial-time translation from pairs (𝔗,φ) of a finite transition system and a Hyper2LTL sentence φ to sentences φ of third-order arithmetic such that 𝔗φ if and only if (,+,,<,)φ.

In the proof of Theorem 11, we have constructed, from a Hyper2LTL sentence φ, a sentence φ of third-order arithmetic that expresses the existence of a finite transition system that satisfies φ. We obtain the desired upper bound by modifying φ to replace the existential quantification of the transition system by hardcoding 𝔗 instead.

Again, the lower bound proof can easily be extended to closed-world semantics, using the same arguments as in the case of satisfiability.

Corollary 14.

The Hyper2LTL model-checking problem under closed-world semantics is polynomial-time equivalent to truth in third-order arithmetic.

6 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦

As we have seen, unrestricted second-order quantification makes Hyper2LTL very expressive and therefore highly undecidable. But restricted forms of second-order quantification are sufficient for many application areas. Beutner et al. [4] introduced Hyper2LTLmm, a fragment333In [4] this fragment is termed Hyper2LTLfp. of Hyper2LTL in which second-order quantification ranges over smallest/largest sets that satisfy a given guard. For example, the formula (X,,φ1).φ2 expresses that there is a set T of traces that satisfies both φ1 and φ2, and T is a smallest set that satisfies φ1 (i.e., φ1 is the guard). This fragment is expressive enough to express common knowledge, asynchronous hyperproperties, and causality in reactive systems [4].

The formulas of Hyper2LTLmm are given by the grammar

φ ::=(X,,φ).φ(X,,φ).φπX.φπX.φψ
ψ ::=pπ¬ψψψ𝐗ψψ𝐔ψ

where p ranges over AP, π ranges over 𝒱1, X ranges over 𝒱2, and {,}, i.e., the only modification concerns the syntax of second-order quantification.

Accordingly, the semantics of Hyper2LTLmm is similar to that of Hyper2LTL but for the second-order quantifiers, for which we define (for {,}):

  • Π(X,,φ1).φ2 if there exists a set Tsol(Π,(X,,φ1)) such that Π[XT]φ2

  • Π(X,,φ1).φ2 if for all sets Tsol(Π,(X,,φ1)) we have Π[XT]φ2

Here, sol(Π,(X,,φ1)) is the set of all minimal/maximal models of the formula φ1, which is defined as follows:

sol(Π,(X,,φ1))={T(2AP)ωΠ[XT]φ1 and Π[XT]⊧̸φ1 for all TT}
sol(Π,(X,,φ1))={T(2AP)ωΠ[XT]φ1 and Π[XT]⊧̸φ1 for all TT}

Note that sol(Π,(X,,φ1)) may be empty, may be a singleton, or may contain multiple sets, which then are pairwise incomparable.

Let us also define closed-world semantics for Hyper2LTLmm. Here, we again disallow the use of the variable Xa and change the semantics of set quantification to

  • Πcw(X,,φ1).φ2 if there exists a set Tsolcw(Π,(X,,φ1)) such that Π[XT]φ2, and

  • Πcw(X,,φ1).φ2 if for all sets Tsolcw(Π,(X,,φ1)) we have Π[XT]φ2,

where solcw(Π,(X,,φ1)) and solcw(Π,(X,,φ1)) are defined as follows:

solcw(Π,(X,,φ1))={TΠ(Xd) Π[XT]cwφ1
and Π[XT]⊧̸cwφ1 for all TT}
solcw(Π,(X,,φ1))={TΠ(Xd) Π[XT]cwφ1
and Π[XT]⊧̸cwφ1 for all Π(Xd)TT}.

Note that solcw(Π,(X,,φ1)) may still be empty, may be a singleton, or may contain multiple sets, but all sets in it are now incomparable subsets of Π(Xd).

A Hyper2LTLmm formula is a sentence if it does not have any free variables except for Xa and Xd (also in the guards). Models are defined as for Hyper2LTL.

Proposition 15 (Proposition 1 of [4]).

Every Hyper2LTLmm sentence φ can be translated in polynomial time (in |φ|) into a Hyper2LTL sentence φ such that for all sets T of traces we have that Tφ if and only if Tφ.444The polynomial-time claim is not made in [4], but follows from the construction when using appropriate data structures for formulas.

The same claim is also true for closed-world semantics, using the same proof.

 Remark 16.

Every Hyper2LTLmm sentence φ can be translated in polynomial time (in |φ|) into a Hyper2LTL sentence φ such that for all sets T of traces we have that Tcwφ if and only if Tcwφ.

Thus, every complexity upper bound for Hyper2LTL also holds for Hyper2LTLmm and every lower bound for Hyper2LTLmm also holds for Hyper2LTL. In the following, we show that lower bounds can also be transferred in the other direction, i.e., from Hyper2LTL to Hyper2LTLmm. Thus, contrary to the design goal of Hyper2LTLmm, it is in general not more feasible than full Hyper2LTL.

We begin again by studying the cardinality of models of Hyper2LTLmm sentences, which will be the key technical tool for our complexity results. Again, as such formulas are evaluated over sets of traces, whose cardinality is bounded by 𝔠, there is a trivial upper bound. Our main result is that this bound is tight even for the restricted setting of Hyper2LTLmm. The proof is similar to the one of Theorem 7, we just have to modify φ4 so that the universal second-order quantifier only ranges over maximal contradiction-free sets.

Theorem 17.

There is a satisfiable Xa-free Hyper2LTLmm sentence that only has models of cardinality 𝔠 (under standard and closed-world semantics).

Now, let us describe how we settle the complexity of Hyper2LTLmm satisfiability and model-checking: Recall that Hyper2LTL allows set quantification over arbitrary sets of traces while Hyper2LTLmm restricts quantification to minimal/maximal sets of traces that satisfy a guard formula. By using a sentence φ𝔠 as guard that has only models of cardinality 𝔠, the minimal sets satisfying the guard have cardinality 𝔠. Thus, we can obtain every possible set over propositions not used by φ𝔠 as the projection of a subset of a minimal set satisfying the guard φ𝔠. Thus, quantification of arbitrary sets of traces can be mimicked by quantification of minimal and maximal sets satisfying a guard.

Theorem 18.

Hyper2LTLmm satisfiability, finite-state satisfiability, and model-checking are polynomial-time equivalent to truth in third-order arithmetic. The lower bounds hold even for Xa-free sentences.

Let us conclude by mentioning that Theorem 18 can again be extended to Hyper2LTLmm under closed-world semantics, using the same arguments as for full Hyper2LTL.

Corollary 19.

Hyper2LTLmm satisfiability, finite-state satisfiability, and model-checking under closed-world semantics are polynomial-time equivalent to truth in third-order arithmetic.

7 The Least Fixed Point Fragment of 𝐇𝐲𝐩𝐞𝐫𝟐𝐋𝐓𝐋𝐦𝐦

We have seen that even restricting second-order quantification to smallest/largest sets that satisfy a guard formula is essentially as expressive as full Hyper2LTL, and thus as difficult. However, Beutner et al. [4] note that applications like common knowledge and asynchronous hyperproperties do not even require quantification over smallest/largest sets satisfying a guard, they “only” require quantification over least fixed points of HyperLTL definable functions. This finally yields a fragment with (considerably) lower complexity: we show that satisfiability under closed-world semantics is Σ11-complete while finite-state satisfiability and model-checking are in Σ22 and Σ11-hard (under both semantics). For satisfiability under closed-world semantics, this matches the complexity of HyperLTL satisfiability.

A Hyper2LTLmm sentence using only minimality constraints has the form

φ=γ1.Q1(Y1,,φ1con).γ2.Q2(Y2,,φ2con).γk.Qk(Yk,,φkcon).γk+1.ψ

satisfying the following properties:

  • Each γj is a block γj=Qj1+1πj1+1Xj1+1QjπjXj of trace quantifiers (with 0=0). As φ is a sentence, this implies that we have {Xj+1,,Xj}{Xa,Xd,Y1,,Yj1}.

  • The free variables of ψjcon are among the trace variables quantified in the γj and Xa,Xd,Y1,,Yj.

  • ψ is a quantifier-free formula. Again, as φ is a sentence, the free variables of ψ are among the trace variables quantified in the γj.

Now, φ is an lfp-Hyper2LTLmm sentence555Our definition here differs slightly from the one of [4] in that we allow to express the existence of some traces in the fixed point (via the subformulas π˙iYj). All examples and applications of [4] are also of this form., if additionally each φjcon has the form

φjcon=π˙1Yjπ˙nYjπ¨1Z1.π¨nZn.ψjstepπ¨mYj

for some n0, n1, where 1mn, and where we have

  • {π˙1,,π˙n}{π1,,πj},

  • {Z1,,Zn}{Xa,Xd,Y1,,Yj}, and

  • ψjstep is quantifier-free with free variables among π¨1,,π¨n,π1,,πj.

As always, φjcon can be brought into the required prenex normal form.

Let us give some intuition for the definition. To this end, fix some j{1,2,,k} and a variable assignment Π whose domain contains at least all variables quantified before Yj, i.e., all Yj and all variables in the γj for j<j, as well as Xa and Xd. Then,

φjcon=π˙1Yjπ˙nYj(π¨1Z1.π¨nZn.ψjstepπ¨mYj)

induces the monotonic function fΠ,j:2(2AP)ω2(2AP)ω defined as

fΠ,j(S)=S{Π(π˙1),,Π(π˙n)}{Π(π¨m)Π=Π[π¨1t1,,π¨ntn] for tiΠ(Zi) if ZiYj and tiS if Zi=Yj s.t. Πψjstep}.

We define S0=, S+1=fΠ,j(S), and

lfp(Π,j)=S,

which is the least fixed point of fΠ,j. Due to the minimality constraint on Yj in φ, lfp(Π,j) is the unique set in sol(Π,(Yj,,φjcon)). Hence, an induction shows that lfp(Π,j) only depends on the values Π(π) for trace variables π quantified before Yj as well as the values Π(Xd) and Π(Xa), but not on the values Π(Yj) for j<j (as they are unique).

Thus, as sol(Π,(Yj,,φjcon)) is a singleton, it is irrelevant whether Qj is an existential or a universal quantifier. Instead of interpreting second-order quantification as existential or universal, here one should understand it as a deterministic least fixed point computation: choices for the trace variables and the two distinguished second-order variables uniquely determine the set of traces that a second-order quantifier assigns to a second-order variable.

 Remark 20.

Note that the traces that are added to a fixed point assigned to Yj either come from another Yj with j<j, from the model (via Xd), or from the set of all traces (via Xa). Thus, for Xa-free formulas, all second-order quantifiers range over (unique) subsets of the model, i.e., there is no need for an explicit definition of closed-world semantics. The analogue of closed-world semantics for lfp-Hyper2LTLmm is to restrict oneself to Xa-free sentences.

In the remainder of this section, we study the complexity of lfp-Hyper2LTLmm. For satisfiability, the key step is again to study the size of models of satisfiable sentences. For Xa-free lfp-Hyper2LTLmm, as for HyperLTL, we are able to show that each satisfiable sentence has a countable model. The following result is proven by generalizing the proof for the analogous result for HyperLTL [18] showing that every model T of a HyperLTL sentence φ contains a countable RT that is closed under the application of Skolem functions. This implies that R is also a model of φ.

Lemma 21.

Every satisfiable Xa-free lfp-Hyper2LTLmm sentence has a countable model.

Proof Sketch.

Let φ=γ1Q1(Y1,,φ1con).γ2Q2(Y2,,φ2con).γkQ2(Yk,,φkcon).γk+1.ψ be a satisfiable lfp-Hyper2LTLmm sentence where

φjcon=π˙1Yjπ˙nYjπ¨1Z1.π¨nZn.ψjstepπ¨mYj.

We assume w.l.o.g. that each trace variable is quantified at most once in φ. This implies that for each trace variable π quantified in some γj or in some φjcon, there is a unique second-order variable Xπ such that π ranges over Xπ.

Membership of traces in least fixed points assigned to the variables Yj can be characterized by trees labeled by traces that make the inductive construction of the stages of the least fixed points explicit. Intuitively, consider the formula φjcon above inducing the unique least fixed point lfp(Π,j) that Yj ranges over. It expresses that a trace t is in the fixed point either because it is of the form Π(π˙i) for some i{1,,n} where π˙i is a trace variable quantified before the quantification of Yj, or t is in the fixed point because there are traces t1,,tn such that assigning them to the π¨i satisfies ψjstep and t=tm. Thus, the traces t1,,tn witness that t is in the fixed point. However, each ti must be selected from Π(Zi), which, if Zi=Yj for some j, again needs witnesses. Thus, a witness is in general a tree whose vertices are labeled by traces and indexes in {1,2,ldots,k} indicating in which fixed point the trace is in.

As φ is satisfiable, there exists a set T of traces such that Tφ. We show that there is a countable RT with Rφ. Intuitively, we show that the smallest set R that is closed under the application of the Skolem functions and that contains the traces labeling witness trees (for the fixed points computed w.r.t. T) for the traces in R has the desired properties.

The full proof requires additional notation, e.g., a formalization of the notion of witness trees, and can be found in the full version [21].

Before we continue with our complexity results, let us briefly mention that the formula from Remark 5 on Page 5 shows that the restriction to Xa-free sentences is essential to obtain the upper bound above.

With this upper bound, we can express the existence of (w.l.o.g.) countable models of a given Xa-free sentence φ via arithmetic formulas that only use existential quantification of type 1 objects (sets of natural numbers), which are rich enough to express countable sets T of traces and objects (e.g., Skolem functions and more) witnessing that T satisfies φ. This places satisfiability in Σ11 while the matching lower bound already holds for HyperLTL [19].

Theorem 22.

lfp-Hyper2LTLmm satisfiability for Xa-free sentences is Σ11-complete.

Proof Sketch.

The Σ11 lower bound already holds for HyperLTL satisfiability [19], as HyperLTL is a fragment of Xa-free lfp-Hyper2LTLmm (see Remark 1). Hence, we focus in the following on the upper bound, which is a generalization of the corresponding upper bound for HyperLTL [19].

Let φ be an Xa-free lfp-Hyper2LTLmm sentence. From Lemma 21, φ is satisfiable if and only if it has a countable model T. Thus, to prove that the lfp-Hyper2LTLmm satisfiability problem for Xa-free sentences is in Σ11, we express the existence of a countable set T of traces and a witness that T is indeed a model of φ.

As we want to show a Σ11 upper bound, we have to express the existence of a countable model by a sentence of arithmetic with existential quantification over sets of natural numbers and existential and universal quantification over natural numbers. A bit more in detail, since we only have to work with countable sets (as second-order quantifiers in φ range over subsets of the countable model), we can use natural numbers to “name” traces. Thus, a countable set of traces is a mapping from × (names and positions) to 2AP, which can be encoded by a set of natural numbers. Then, we can encode the existence of the following type 1 objects:

  • Variable assignments, such that membership of their assigned traces into respective fixed point sets can be captured in first-order arithmetic.

  • Functions for the existentially quantified first-order variables of φ, which can be verified to be Skolem functions (in first-order arithmetic).

  • Functions expressing the satisfaction of subformulas of φ.

Furthermore, first-order arithmetic can express that the variable assignments indeed map set variables to least fixed points.

Altogether, this allows us to capture the satisfiability of lfp-Hyper2LTLmm in Σ11.

Finally, we consider finite-state satisfiability and model-checking. Note that we have to deal with uncountable sets of traces in both problems, as the sets of traces of finite transition systems may be uncountable. The lower bounds are proven by reductions from a variant of the recurrent tiling problem [24] while the upper bounds are obtained by expressing least fixed points in second-order arithmetic.

Theorem 23.

lfp-Hyper2LTLmm finite-state satisfiability and model-checking are both in Σ22 and Σ11-hard, where the lower bounds already hold for Xa-free sentences.

8 Related Work

As mentioned in Section 1, the complexity problems for HyperLTL were thoroughly studied [16, 19, 20]. For Hyper2LTL, Beutner et al. mainly focused on the algorithmic aspects by providing model checking [4] and monitoring [5] algorithms, and did not study the respective complexity problems in depth.

Logics related to Hyper2LTL are asynchronous and epistemic logics. Much research has been done regarding epistemic properties [13, 15, 29, 36] and their relations to hyperproperties [8]. However, most of this work concerns expressiveness and decidability results (e.g., [7]), and not complexity analysis for the undecidable fragments. This is similar for asynchronous hyperlogics [1, 2, 3, 6, 9, 10, 23, 26, 27, 28], where most work concerns decidability results and expressive power, but not complexity analysis.

Another related logic is TeamLTL [28], a hyperlogic for the specification of dependence and independence. Lück [30] studied similar problems to those we study in this paper and showed that, in general, satisfiability and model checking of TeamLTL with Boolean negation is equivalent to truth in third-order arithmetic. Kontinen and Sandström [25] generalize this result and show that any logic between TeamLTL with Boolean negation and second-order logic inherits the same complexity results. Kontinen et al. [26] study set semantics for asynchronous TeamLTL, and provide positive complexity and decidability results. Gutsfeld et al. [22] study an extension of TeamLTL to express refined notions of asynchronicity and analyze the expressiveness and complexity of their logic, proving it also highly undecidable. While TeamLTL is closely related to Hyper2LTL, the exact relation between them is still unknown.

9 Conclusion

We have investigated and settled the complexity of satisfiability, finite-state satisfiability, and model-checking for Hyper2LTL and Hyper2LTLmm and (almost) settled it for lfp-Hyper2LTLmm. For the former two, all three problems are equivalent to truth in third-order arithmetic, and therefore (not surprisingly) much harder than the corresponding problems for HyperLTL, which are “only” Σ11-complete, Σ10-complete, and Tower-complete, respectively. This shows that the addition of second-order quantification increases the already high complexity of HyperLTL significantly. However, for the fragment lfp-Hyper2LTLmm, in which second-order quantification degenerates to least fixed point computations, the complexity is much lower: satisfiability under closed-world semantics is Σ11-complete and finite-state satisfiability as well as model-checking are in Σ22.

Recently, Regaud and Zimmermann [34] have solved several problems left open in this work, e.g., they settled the complexity of Hyper2LTLmm with only minimality constraints or only maximality constraints, the complexity of lfp-Hyper2LTLmm under standard semantics, and closed the gaps in our results for lfp-Hyper2LTLmm finite-state satisfiability and model-checking. Furthermore, they settled the complexity of all three decision problems we consider here for HyperQPTL [33].

References

  • [1] Ezio Bartocci, Thomas A. Henzinger, Dejan Nickovic, and Ana Oliveira da Costa. Hypernode automata. In Guillermo A. Pérez and Jean-François Raskin, editors, CONCUR 2023, volume 279 of LIPIcs, pages 21:1–21:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.CONCUR.2023.21.
  • [2] Jan Baumeister, Norine Coenen, Borzoo Bonakdarpour, Bernd Finkbeiner, and César Sánchez. A temporal logic for asynchronous hyperproperties. In Alexandra Silva and K. Rustan M. Leino, editors, CAV 2021, Part I, volume 12759 of LNCS, pages 694–717. Springer, 2021. doi:10.1007/978-3-030-81685-8_33.
  • [3] Raven Beutner and Bernd Finkbeiner. HyperATL: A logic for hyperproperties in multi-agent systems. Log. Methods Comput. Sci., 19(2), 2023. doi:10.46298/LMCS-19(2:13)2023.
  • [4] Raven Beutner, Bernd Finkbeiner, Hadar Frenkel, and Niklas Metzger. Second-order hyperproperties. In Constantin Enea and Akash Lal, editors, CAV 2023, Part II, volume 13965 of LNCS, pages 309–332. Springer, 2023. doi:10.1007/978-3-031-37703-7_15.
  • [5] Raven Beutner, Bernd Finkbeiner, Hadar Frenkel, and Niklas Metzger. Monitoring second-order hyperproperties. In Mehdi Dastani, Jaime Simão Sichman, Natasha Alechina, and Virginia Dignum, editors, AAMAS 2024, pages 180–188. International Foundation for Autonomous Agents and Multiagent Systems / ACM, 2024. doi:10.5555/3635637.3662865.
  • [6] Alberto Bombardelli, Laura Bozzelli, César Sánchez, and Stefano Tonetta. Unifying asynchronous logics for hyperproperties. arXiv, 2404.16778, 2024. doi:10.48550/arXiv.2404.16778.
  • [7] Laura Bozzelli, Bastien Maubert, and Aniello Murano. On the complexity of model checking knowledge and time. ACM Trans. Comput. Log., 25(1):8:1–8:42, 2024. doi:10.1145/3637212.
  • [8] Laura Bozzelli, Bastien Maubert, and Sophie Pinchinat. Unifying hyper and epistemic temporal logics. In Andrew M. Pitts, editor, FoSSaCS 2015, volume 9034 of LNCS, pages 167–182. Springer, 2015. doi:10.1007/978-3-662-46678-0_11.
  • [9] Laura Bozzelli, Adriano Peron, and César Sánchez. Asynchronous extensions of HyperLTL. In LICS 2021, pages 1–13. IEEE, 2021. doi:10.1109/LICS52264.2021.9470583.
  • [10] Laura Bozzelli, Adriano Peron, and César Sánchez. Expressiveness and decidability of temporal logics for asynchronous hyperproperties. In Bartek Klin, Slawomir Lasota, and Anca Muscholl, editors, CONCUR 2022, volume 243 of LIPIcs, pages 27:1–27:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.CONCUR.2022.27.
  • [11] Michael R. Clarkson, Bernd Finkbeiner, Masoud Koleini, Kristopher K. Micinski, Markus N. Rabe, and César Sánchez. Temporal logics for hyperproperties. In Martín Abadi and Steve Kremer, editors, POST 2014, volume 8414 of LNCS, pages 265–284. Springer, 2014. doi:10.1007/978-3-642-54792-8_15.
  • [12] Michael R. Clarkson and Fred B. Schneider. Hyperproperties. J. Comput. Secur., 18(6):1157–1210, 2010. doi:10.3233/JCS-2009-0393.
  • [13] Catalin Dima. Revisiting satisfiability and model-checking for CTLK with synchrony and perfect recall. In Michael Fisher, Fariba Sadri, and Michael Thielscher, editors, CLIMA IX, volume 5405 of LNCS, pages 117–131. Springer, 2008. doi:10.1007/978-3-642-02734-5_8.
  • [14] E. Allen Emerson and Joseph Y. Halpern. ”sometimes” and ”not never” revisited: on branching versus linear time temporal logic. J. ACM, 33(1):151–178, 1986. doi:10.1145/4904.4999.
  • [15] Ronald Fagin, Joseph Y. Halpern, Yoram Moses, and Moshe Y. Vardi. Reasoning About Knowledge. MIT Press, 1995. doi:10.7551/MITPRESS/5803.001.0001.
  • [16] Bernd Finkbeiner and Christopher Hahn. Deciding hyperproperties. In Josée Desharnais and Radha Jagadeesan, editors, CONCUR 2016, volume 59 of LIPIcs, pages 13:1–13:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPIcs.CONCUR.2016.13.
  • [17] Bernd Finkbeiner, Markus N. Rabe, and César Sánchez. Algorithms for Model Checking HyperLTL and HyperCTL. In Daniel Kroening and Corina S. Pasareanu, editors, CAV 2015, Part I, volume 9206 of LNCS, pages 30–48. Springer, 2015. doi:10.1007/978-3-319-21690-4_3.
  • [18] Bernd Finkbeiner and Martin Zimmermann. The First-Order Logic of Hyperproperties. In STACS 2017, volume 66 of LIPIcs, pages 30:1–30:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2017. doi:10.4230/LIPIcs.STACS.2017.30.
  • [19] Marie Fortin, Louwe B. Kuijer, Patrick Totzke, and Martin Zimmermann. HyperLTL satisfiability is Σ11-complete, HyperCTL* satisfiability is Σ12-complete. In Filippo Bonchi and Simon J. Puglisi, editors, MFCS 2021, volume 202 of LIPIcs, pages 47:1–47:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.MFCS.2021.47.
  • [20] Marie Fortin, Louwe B. Kuijer, Patrick Totzke, and Martin Zimmermann. HyperLTL satisfiability is highly undecidable, HyperCTL* is even harder. arXiv, 2303.16699, 2023. Journal version of [19]. Under submission. doi:10.48550/arXiv.2303.16699.
  • [21] Hadar Frenkel and Martin Zimmermann. The complexity of second-order HyperLTL. arXiv, 2311.15675, 2023. doi:10.48550/arXiv.2311.15675.
  • [22] Jens Oliver Gutsfeld, Arne Meier, Christoph Ohrem, and Jonni Virtema. Temporal team semantics revisited. In Christel Baier and Dana Fisman, editors, LICS 2022, pages 44:1–44:13. ACM, 2022. doi:10.1145/3531130.3533360.
  • [23] Jens Oliver Gutsfeld, Markus Müller-Olm, and Christoph Ohrem. Automata and fixpoints for asynchronous hyperproperties. Proc. ACM Program. Lang., 5(POPL):1–29, 2021. doi:10.1145/3434319.
  • [24] David Harel. Recurring Dominoes: Making the Highly Undecidable Highly Understandable. North-Holland Mathematical Studies, 102:51–71, 1985. doi:10.1016/S0304-0208(08)73075-5.
  • [25] Juha Kontinen and Max Sandström. On the expressive power of TeamLTL and first-order team logic over hyperproperties. In Alexandra Silva, Renata Wassermann, and Ruy J. G. B. de Queiroz, editors, WoLLIC 2021, volume 13038 of LNCS, pages 302–318. Springer, 2021. doi:10.1007/978-3-030-88853-4_19.
  • [26] Juha Kontinen, Max Sandström, and Jonni Virtema. Set semantics for asynchronous TeamLTL: Expressivity and complexity. In Jérôme Leroux, Sylvain Lombardy, and David Peleg, editors, MFCS 2023, volume 272 of LIPIcs, pages 60:1–60:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.MFCS.2023.60.
  • [27] Juha Kontinen, Max Sandström, and Jonni Virtema. A remark on the expressivity of asynchronous TeamLTL and HyperLTL. In Arne Meier and Magdalena Ortiz, editors, FoIKS 2024, volume 14589 of LNCS, pages 275–286. Springer, 2024. doi:10.1007/978-3-031-56940-1_15.
  • [28] Andreas Krebs, Arne Meier, Jonni Virtema, and Martin Zimmermann. Team semantics for the specification and verification of hyperproperties. In Igor Potapov, Paul G. Spirakis, and James Worrell, editors, MFCS 2018, volume 117 of LIPIcs, pages 10:1–10:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.MFCS.2018.10.
  • [29] Alessio Lomuscio and Franco Raimondi. The complexity of model checking concurrent programs against CTLK specifications. In Hideyuki Nakashima, Michael P. Wellman, Gerhard Weiss, and Peter Stone, editors, AAMAS 2006, pages 548–550. ACM, 2006. doi:10.1145/1160633.1160733.
  • [30] Martin Lück. On the complexity of linear temporal logic with team semantics. Theor. Comput. Sci., 837:1–25, 2020. doi:10.1016/j.tcs.2020.04.019.
  • [31] Corto Mascle and Martin Zimmermann. The keys to decidable HyperLTL satisfiability: Small models or very simple formulas. In Maribel Fernández and Anca Muscholl, editors, CSL 2020, volume 152 of LIPIcs, pages 29:1–29:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.CSL.2020.29.
  • [32] Amir Pnueli. The temporal logic of programs. In FOCS 1977, pages 46–57. IEEE, October 1977. doi:10.1109/SFCS.1977.32.
  • [33] Markus N. Rabe. A temporal logic approach to information-flow control. PhD thesis, Saarland University, 2016. URL: http://scidok.sulb.uni-saarland.de/volltexte/2016/6387/.
  • [34] Gaëtan Regaud and Martin Zimmermann. The complexity of fragments of second-order HyperLTL, 2025. Under preparation.
  • [35] Hartley Rogers. Theory of Recursive Functions and Effective Computability. MIT Press, Cambridge, MA, USA, 1987.
  • [36] Ron van der Meyden and Nikolay V. Shilov. Model checking knowledge and time in systems with perfect recall (extended abstract). In C. Pandu Rangan, Venkatesh Raman, and Ramaswamy Ramanujam, editors, FSTTCS 1999, volume 1738 of LNCS, pages 432–445. Springer, 1999. doi:10.1007/3-540-46691-6_35.