This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

Complexity Bounds for the Controllability of Temporal Networks with Conditions, Disjunctions, and Uncertainty

Nikhil Bhargava nkb@mit.edu Brian Williams williams@mit.edu Massachusetts Institute of Technology
Room 32-227
32 Vassar St.
Cambridge, MA 02139 USA
Abstract

In temporal planning, many different temporal network formalisms are used to model real world situations. Each of these formalisms has different features which affect how easy it is to determine whether the underlying network of temporal constraints is consistent. While many of the simpler models have been well-studied from a computational complexity perspective, the algorithms developed for advanced models which combine features have very loose complexity bounds. In this paper, we provide tight completeness bounds for strong, weak, and dynamic controllability checking of temporal networks that have conditions, disjunctions, and temporal uncertainty. Our work exposes some of the subtle differences between these different structures and, remarkably, establishes a guarantee that all of these problems are computable in PSPACE.

keywords:
Temporal Planning , Temporal Uncertainty
journal: Artificial Intelligence Journal

1 Introduction

In temporal planning, many different temporal formalisms are used to model real world situations. The choice of any particular type of network in modeling a problem has inherent trade-offs. If a temporal model supports more features, it can model a given scenario with higher fidelity. However, the additional features come at the expense of performance; modelers care about constructing schedules for temporal networks, and the presence of additional feature types can dramatically slow the runtime of scheduling algorithms.

The computational complexities of many of the simpler temporal models have been well-studied, but the same cannot be said of more advanced models. Despite this gap, there has been considerable effort put into constructing improved algorithms for these feature-rich temporal networks [3, 4, 5, 10, 24].

The main contribution of this paper is in providing significantly improved theoretical complexity bounds for computing the controllability of temporal networks with conditions, disjunctions, and temporal uncertainty. The existing bounds for some of these results have been quite loose with most decision problems not known to be better than EXPTIME and some not known to be better than EXPSPACE. We provide completeness results for the strong, weak, and dynamic controllability decision problems across these networks and remarkably prove that all of these problems can be solved in PSPACE. Our results are summarized in Figure 1. We conclude with a discussion of our results, giving practical advice to modelers who are interested in the trade-offs of using different temporal networks and lending insight into the differences between these networks.

Refer to caption
Figure 1: A taxonomic organization of temporal networks considered in this paper, how they relate to one another, and the complexity classes to which their decision problems belong. SC, DC, and WC represent strong controllability, dynamic controllability, and weak controllability, respectively. Results in bold represent novel results proved in this paper.

There are many types of temporal networks beyond those that we focus on in this paper. Many include features related to actor decisions, such as Temporal Plan Networks [13], Temporal Plan Networks with Uncertainty [12], Controllable Conditional Temporal Problems [26], Conditional Simple Temporal Networks with Decisions [2], and Conditional Simple Temporal Networks with Uncertainty and Decisions [27] while others, such as Probabilistic Simple Temporal Networks [8] and their relevant extensions, consider probabilistic temporal bounds. Despite the existence of other networks our work covers a broad area of focus that is under active investigation. Future work in this direction will focus on characterizing, organizing, and providing tighter bounds for controllability in these other types of networks but is outside the scope of this work.

2 Background

In this section, we will introduce the set of temporal networks whose controllability we will analyze in depth, as well as their simpler base counterparts. The set of networks that we focus on is summarized in Figure 1. We divide the discussion of temporal networks into that of base temporal networks, which build on the simplest temporal network representations, and compositional temporal networks, which make use of two or more features in their representation. After describing the temporal networks in detail, we will introduce the complexity classes that make up the polynomial-time hierarchy, as they will be useful in categorizing the complexity of particular controllability classes.

2.1 Base Temporal Networks

2.1.1 Simple Networks

Simple Temporal Networks (STNs) are the most basic temporal network on which all other formalisms are built [6]. STNs are composed of a set of variables and a set of binary constraints limiting the difference between any two variables (e.g. BA[10,20]B-A\in[10,20]). These variables denote individual points in time (henceforth timepoints) and the constraints between them are binary temporal constraints limiting their temporal difference (e.g. event AA must happen between 10 and 20 minutes before event BB).

Refer to caption
Figure 2: (a) An STN as specified by its set of constraints. (b) The same STN represented graphically. (c) The same STN represented using its distance graph formulation.
Definition 1.

STN [6]
An STN is a 2-tuple X,R\langle X,R\rangle where:

  • 1.

    XX is a set of timepoint variables composing the temporal network

  • 2.

    RR is a set of constraints of the form lrxryrurl_{r}\leq x_{r}-y_{r}\leq u_{r}, where xr,yrXx_{r},y_{r}\in X and lr,url_{r},u_{r}\in\mathbb{R}

When we consider the feasibility of an STN, we are generally concerned with whether it is possible to construct a schedule, or an assignment of values from \mathbb{R} to each variable xXx\in X, such that all constraints are satisfied.

Typically, temporal networks are represented graphically where each timepoint is represented as a node and edges between nodes represent the range of possible differences in value between the endpoints as specified by the original constraints (see Figure 2b). We can similarly represent temporal networks by their distance graphs [6] in which case we get a simple graph in which each edge from A to B with weight ww represents the constraint xBxAwx_{B}-x_{A}\leq w, which can be extracted from the original constraints of the temporal network (see Figure 2c). In its distance graph formulation, determining the feasibility of an STN reduces to finding a negative cycle in the graph. In general, we take nn to be the number of timepoints in a temporal networks and mm to be the number of constraints. In the case of STNs, determining feasibility takes at most O(mn)O(mn) time [6]. When describing modifications made by other temporal networks, we will discuss how these changes affect the cost of checking schedule feasibility.

2.1.2 Disjunctive Networks

The first modification we make to STNs is to allow for disjunctions over temporal constraints. In practice, we frequently construct and consider schedules with disjunctive constraints; during a trip to the beach, we know that we want to eat lunch either 30 minutes before swimming or immediately afterwards – not at any moment in between.

The two types of disjunctive networks that are used in practice, Temporal Constraint Satisfaction Problems (TCSPs) and Disjunctive Temporal Networks (DTNs), differ in terms of the types of disjunctive constraints that they admit [6, 19].

Definition 2.

TCSP [6]
An TCSP is a 2-tuple X,R\langle X,R\rangle where:

  • 1.

    XX is a set of timepoint variables composing the temporal network

  • 2.

    RR is a set of simple disjunctive constraints of the form xryrk[lr,k,ur,k]x_{r}-y_{r}\in\bigcup\limits_{k}[l_{r,k},u_{r,k}], where xr,yrXx_{r},y_{r}\in X and lr,k,ur,kl_{r,k},u_{r,k}\in\mathbb{R}

Definition 3.

DTN [19]
An DTN is a 2-tuple X,R\langle X,R\rangle where:

  • 1.

    XX is a set of timepoint variables composing the temporal network

  • 2.

    RR is a set of full disjunctive constraints of the form k(lr,kxr,kyr,kur,k)\bigvee\limits_{k}\left(l_{r,k}\leq x_{r,k}-y_{r,k}\leq u_{r,k}\right), where xr,k,yr,kXx_{r,k},y_{r,k}\in X and lr,k,ur,kl_{r,k},u_{r,k}\in\mathbb{R}

The disjunctive constraints of TCSPs require that every constraint in a given disjunction relates the same pair of timepoints. In contrast, DTNs allow disjunctive constraints to be a disjunction over any constraints that might be found in an STN. In this paper, we will refer to the type of disjunctions allowed by TCSPs as simple disjunctions and the type of disjunctions allowed by DTNs as full disjunctions. Checking the feasibility of both TCSPs and DTNs is known to be NP-complete [6, 19]. It is worth noting that a linear time transformation exists that converts DTNs into equivalent TCSPs [18], but maintaining the distinction between the two is important because, remarkably, as we extend the two types of networks, we see that the computational complexity of solving them begins to diverge.

2.1.3 Conditional Networks

The Conditional Simple Temporal Network (CSTN) represents a different way in which we can augment STNs [22]. CSTNs allow for the introduction and observation of uncontrollable events and the conditional enforcement of constraints based on the observations of those events.

Definition 4.

CSTN [22]
A CSTN is a tuple X,R,P,O\langle X,R,P,O\rangle where:

  • 1.

    XX is a set of timepoint variables composing the temporal network

  • 2.

    RR is a set of constraints of the form ψr(lrxryrur)\psi_{r}\rightarrow\left(l_{r}\leq x_{r}-y_{r}\leq u_{r}\right), where xr,yrXx_{r},y_{r}\in X, ψr\psi_{r} is a label representing a conjunction of propositions or their negations, and lr,url_{r},u_{r}\in\mathbb{R}

  • 3.

    PP is a set of propositions

  • 4.

    OO is a function mapping propositions in PP to the timepoints where their values are observed

To illustrate the usefulness of CSTNs, we provide an example. If we want to schedule the delivery of a package, we may prefer to use a CSTN to encode the urgency of the request; a package that we see marked as urgent, may need to be scheduled in the next 24 hours, but a package that is not marked as such can use a more relaxed schedule that guarantees shipment within the next week. If we have a timepoint AA representing when the package goes out for delivery and BB as the timepoint representing when the package must be delivered, we can encode the urgency using two constraints, if the package is urgent, we have the constraint BA1dB-A\leq 1d with label uu, and if the package is not urgent, we have the constraint BA7dB-A\leq 7d with label ¬u\neg u. What makes scheduling over CSTNs notable is that we may learn about the value of proposition uu, or in this case the urgency of the package, at some unrelated timepoint CC that may differ from the timepoints associated with the constraints they affect. In our given example, CC represents the time at which the customer tells us the package’s urgency. It is possible that the customer indicates that the package is urgent the day before dropping it off, but it is equally possible that the customer tells us the package is urgent several hours after they have already dropped it off. We conditionally enforce labeled constraints by observing the realized values of the propositions and checking whether a constraint’s label, ψr\psi_{r} is true. In the package example, we know that we will only need to enforce one of the two constraints based on what the observed value of uu is at timepoint CC. We use the function OO to encode the timepoints at which specific propositions are observed.

Importantly, the true values of propositions are not “scheduled” in the same way that timepoints are. Different instantiations of the same problem may yield different values for the propositions and, correspondingly, result in different constraints that must be enforced during execution. As a result, the scheduling problem for CSTNs is different than the one for STNs, TCSPs, and DTNs. In the previously described temporal networks, we knew the full set of constraints that would be enforced prior to scheduling and as such could satisfy all constraints with an implicitly static schedule. However, with CSTNs, there is no predetermined guarantee about when the scheduler learns about propositions, as the scheduler may have to predetermine a schedule that is robust to any learned proposition values or may have the flexibility to adapt the schedule on the fly. Across these different situations, different decisions may be made with respect to scheduling that may trade off between learning the actual values of propositions early in execution and maintaining a buffer of temporal flexibility. As such, when checking feasibility of CSTNs, we use strong, weak, and dynamic consistency to denote the different models under which the scheduler is guaranteed to learn the actual proposition values [22].

Strong consistency implies there exists a schedule that can be constructed that assigns values to all timepoints in XX, such that for every realization of the values of the propositions in PP, all constraints in RR are satisfied. Strong consistency checking of a CSTN reduces to checking the temporal consistency of the underlying STN and so is computable in O(mn)O(mn) time [22]. A CSTN is weakly consistent if for every assignment of values to the propositions in PP, there exists some schedule can be constructed assigning values to timepoint variables in XX, such that all constraints in RR are satisfied. Weak consistency checking of CSTNs is coNP-complete [22]. Dynamic consistency is concerned with whether it is possible to dynamically construct a schedule where assignment to values in XX happen in order of timepoint values and the true values of propositions pPp\in P are learned only when the corresponding timepoint given by O(p)O(p) is executed. Dynamic consistency checking in CSTNs is PSPACE-complete [1].

2.1.4 Networks with Temporal Uncertainty

All the formalisms we have introduced to this point have one major shortcoming; namely, they assume that the scheduler has absolute control over each and every timepoint. In practice, there exist few scenarios in which an agent has that type of total control. Agents are unable to control how much traffic will affect their morning commute or when it might start to rain. To account for this, we need a way to augment temporal networks to capture the difficulty of planning around uncertain events.

Simple Temporal Networks with Uncertainty (STNUs) extend STNs, allowing us to model events whose timings are outside the control of the scheduler but still closely related to the actions taken by the scheduler [25]. By convention, we say that those events and actions not explicitly chosen by the scheduler are chosen by nature.

Definition 5.

STNU [25]
An STNU is a 4-tuple Xe,Xc,Rr,Rc\langle X_{e},X_{c},R_{r},R_{c}\rangle where:

  • 1.

    XeX_{e} is the set of executable timepoint variables

  • 2.

    XcX_{c} is the set of contingent timepoint variables

  • 3.

    RrR_{r} is the set of requirement constraints of the form lrxryrurl_{r}\leq x_{r}-y_{r}\leq u_{r}, where xr,yrXcXex_{r},y_{r}\in X_{c}\cup X_{e} and lr,url_{r},u_{r}\in\mathbb{R}

  • 4.

    RcR_{c} is the set of contingent constraints of the form 0lrcrerur0\leq l_{r}\leq c_{r}-e_{r}\leq u_{r}, where crXcc_{r}\in X_{c}, erXee_{r}\in X_{e} and lr,url_{r},u_{r}\in\mathbb{R}

In STNUs, timepoints are subdivided into executable and contingent timepoints and constraints are subdivided into requirement and contingent ones. Executable timepoints are the timepoints that the scheduler is responsible for, whereas contingent timepoints are scheduled by nature. Requirements constraints behave like ordinary STN constraints and are free to constrain any pair of timepoints. Contingent constraints, in contrast, represent relations between a starting executable timepoint and an ending contingent timepoint that nature is guaranteed to enforce. By convention, the lower bound of a contingent constraint is required to be non-negative to enforce that the starting timepoint of the constraint, in some sense, causes the ending timepoint. It is worth noting that we require that all contingent constraints begin from an executable timepoint. This does not have an impact on the expressivity of our networks, as it is simple to take a pair of chained contingent links and interrupt them with a simple zero-length requirement constraint, but it will simplify our proof exposition.

For simplicity, we may sometimes refer to a contingent action duration. For a contingent constraint rr, represented as lrcrerurl_{r}\leq c_{r}-e_{r}\leq u_{r}, we say that the duration of rr is the value specified by the difference crerc_{r}-e_{r}. When the contingent timepoints xex_{e} are picked by nature, it is equivalent to nature picking a series of durations for contingent actions, as the set of contingent action durations together with the set of executable timepoints uniquely determines a set of contingent timepoints.

As was the case with CSTNs, when modeling the execution of STNUs, there are events that are outside of the control of the scheduler that force us to consider schedulability in the context of how we eventually learn about nature’s actions. While CSTN feasibility was centered around strong, weak, and dynamic consistency, STNU feasibility is based on strong, weak, and dynamic controllability [25].

We say that an STNU is strongly controllable if there exists a schedule for all executable timepoints XeX_{e}, such that for every possible assignment of values to contingent timepoints in XcX_{c} that satisfy the contingent constraints RcR_{c}, all of the requirement constraints RrR_{r} are satisfied. STNU strong controllability checking, much like STN consistency checking, reduces to detecting the presence of a negative cycle and can be computed in O(mn)O(mn) time [25].

Weak controllability asks whether it is possible to reactively construct a schedule if the durations of the uncertain events are revealed before scheduling begins. In other words, for every fully specified set of contingent action durations that guarantee satisfaction of contingent constraints RcR_{c}, weak controllability asks whether it is always possible to pick a set of executable timepoints XeX_{e} such that all requirement constraints RrR_{r} are satisfied. While checking whether a schedule exists for any one particular realization of the uncertain events reduces to checking STN consistency, checking STNU weak controllability in general is coNP-complete [14].

Dynamic controllability considers the question of whether it is possible to create a just-in-time schedule, where timepoints XeX_{e} and XcX_{c} are chosen interactively in order of their values (with the guarantee that all XcX_{c} are chosen such that all contingent constraints RcR_{c} are satisfied), that guarantees the satisfaction of all requirement constraints RrR_{r}. Dynamic controllability of an STNU can be computed in polynomial time and more recently was shown to have a worst-case O(n3)O(n^{3}) runtime [15, 16].

We will use these same notions of strong, weak, and dynamic controllability when we extend the STNU to include conditions and disjunctions.

2.2 Compositional Temporal Networks

The compositional temporal networks that we choose to focus on in this paper will be the ones that augment STNUs with disjunctions and conditional constraints.

2.2.1 Disjunctions and Temporal Uncertainty

We start by adding disjunctions to STNUs. As was the case with disjunctions added to STNs, when considering disjunctive temporal networks with uncertainty, we consider the effects of allowing both simple and full disjunctions.

Temporal Constraint Satisfaction Problems with Uncertainty (TCSPUs) augment STNUs by adding simple disjunctions over constraints.

Definition 6.

TCSPU [24]
A TCSPU is a 4-tuple Xe,Xc,Rr,Rc\langle X_{e},X_{c},R_{r},R_{c}\rangle where:

  • 1.

    XeX_{e} is the set of executable timepoint variables

  • 2.

    XcX_{c} is the set of contingent timepoint variables

  • 3.

    RrR_{r} is the set of simple disjunctive temporal constraints over XcXeX_{c}\cup X_{e}

  • 4.

    RcR_{c} is the set of simple disjunctive contingent constraints

By augmenting a TCSPU with full disjunctions over temporal constraints, we get Disjunctive Temporal Networks with Uncertainty (DTNUs) [23].

Definition 7.

DTNU [17]
An DTNU is a 4-tuple Xe,Xc,Rr,Rc\langle X_{e},X_{c},R_{r},R_{c}\rangle where:

  • 1.

    XeX_{e} is the set of executable timepoint variables

  • 2.

    XcX_{c} is the set of contingent timepoint variables

  • 3.

    RrR_{r} is the set of full disjunctive temporal constraints over XcXeX_{c}\cup X_{e}

  • 4.

    RcR_{c} is the set of simple disjunctive contingent constraints

It is worth noting that for DTNUs, all disjunctive contingent constraints are simple. Most models of temporal uncertainty assume that the duration of a contingent link is independent of any action taken by the scheduler. Accordingly, allowing disjunctive constraints to span different contingent links or to span contingent and requirement links would violate the spirit of this approach.

The concepts of strong, weak, and dynamic controllability as defined for STNUs scale immediately to temporal networks with disjunctions. However, the introduction of disjunctions makes the act of computing controllability much more difficult. The best available algorithms for deciding strong controllability of temporal networks with uncertainty and disjunction are in EXPSPACE [17]. Dynamic and weak controllability of these networks can be computed in exponential time, but these approaches also use exponential space. It is unknown whether any form of controllability checking for DTNUs or TCSPUs can be done in polynomial space [3, 23].

2.2.2 Conditions and Temporal Uncertainty

Extending STNUs with conditional constraints gives us Conditional Simple Temporal Networks with Uncertainty (CSTNUs) [9].

Definition 8.

CSTNU [5]
A CSTNU is a tuple Xe,Xc,Re,P,O\langle X_{e},X_{c},R_{e},P,O\rangle where:

  • 1.

    XeX_{e} is a set of executable timepoint variables

  • 2.

    XcX_{c} is a set of contingent timepoint variables

  • 3.

    RrR_{r} is a set of requirement constraints of the form ψr(lrxryrur)\psi_{r}\rightarrow\left(l_{r}\leq x_{r}-y_{r}\leq u_{r}\right), where xr,yrXeXcx_{r},y_{r}\in X_{e}\cup X_{c}, ψr\psi_{r} is a label representing a conjunction of propositions or their negations, and lr,url_{r},u_{r}\in\mathbb{R}

  • 4.

    RcR_{c} is a set of contingent constraints of the form 0lrcrerur0\leq l_{r}\leq c_{r}-e_{r}\leq u_{r}, where crXc,erXec_{r}\in X_{c},e_{r}\in X_{e} and lr,url_{r},u_{r}\in\mathbb{R}

  • 5.

    PP is a set of propositions

  • 6.

    OO is a function mapping propositions in PP to the timepoints where their values are observed

With CSTNUs, we now have two sources of external uncertainty, the observed values of propositions and the realized durations of contingent links. While we could evaluate consistency and controllability conditions separately (e.g. checking whether a network is strongly consistent while being dynamically controllable), we typically consider the two jointly. In other words, we assume that both the durations of contingent links and the values of the propositions are either never observed, all observed before execution, or observed along the way when we evaluate strong, weak, and dynamic controllability, respectively. Dynamic controllability of CSTNUs belongs to EXPTIME [3], but the complexity of checking strong and weak controllability are still open questions.

2.2.3 Conditions, Disjunctions, and Temporal Uncertainty

Finally, we combine conditions, disjunctions, and temporal uncertainty in a single network to get Conditional Disjunctive Temporal Networks with Uncertainty (CDTNUs).

Definition 9.

CDTNU
A CDTNU is a tuple Xe,Xc,Re,P,O\langle X_{e},X_{c},R_{e},P,O\rangle where:

  • 1.

    XeX_{e} is a set of executable timepoint variables

  • 2.

    XcX_{c} is a set of contingent timepoint variables

  • 3.

    ReR_{e} is a set of requirement constraints of the form
    kψr,k(lr,kxr,kyr,kur,k)\bigvee\limits_{k}\psi_{r,k}\rightarrow\left(l_{r,k}\leq x_{r,k}-y_{r,k}\leq u_{r,k}\right), where xr,k,yr,kXx_{r,k},y_{r,k}\in X, ψr,k\psi_{r,k} is a label representing a conjunction of propositions or their negations, and lr,k,ur,kl_{r,k},u_{r,k}\in\mathbb{R}

  • 4.

    RcR_{c} is a set of simple disjunctive contingent constraints

  • 5.

    PP is a set of propositions

  • 6.

    OO is a function mapping propositions in PP to the timepoints where their values are observed

We can apply the same techniques as those found in CSTNUs and DTNUs to show that dynamic controllability of CDTNUs can be computed in EXPTIME [3]. Algorithms for strong and weak controllability of CDTNUs have not yet been developed.

2.3 Polynomial Time Hierarchy

Before we continue to the actual complexity results it is useful to introduce the polynomial-time hierarchy [20], as it will allow us to more precisely characterize the difficulty of some of our controllability problems.

The classes ΣkP\Sigma_{k}^{P} and ΠkP\Pi_{k}^{P} are defined recursively. We start with Σ1P=\Sigma_{1}^{P}= NP and Π1P=\Pi_{1}^{P}= coNP and define Σk+1P\Sigma_{k+1}^{P} as NPΣkP{}^{\Sigma_{k}^{P}} and Πk+1P\Pi_{k+1}^{P} as coNPΣkP{}^{\Sigma_{k}^{P}}, where ABA^{B} represents the set of problems that can be solved in complexity class AA if an oracle for a BB-complete problem is provided.

In this paper, we will pay close attention to the complexity classes Σ2P\Sigma_{2}^{P} and Π2P\Pi_{2}^{P} and will make heavy use of the fact that ΣkP=\Sigma_{k}^{P}= coΠkP\Pi_{k}^{P} and that \forall\exists3SAT is a Π2P\Pi_{2}^{P}-complete problem, where \forall\exists3SAT is the problem of determining whether for a given 3-CNF Φ(x,y)\Phi(\vec{x},\vec{y}) it is the case that for all y\vec{y}, there exists x\vec{x}, such that Φ(x,y)\Phi(\vec{x},\vec{y}) is true [20]. ΣkP\Sigma_{k}^{P} and ΠkP\Pi_{k}^{P} are also known to be fully contained within PSPACE, meaning that membership to any complexity class in the polynomial-time hierarchy guarantees the existence of a deterministic algorithm that uses at most polynomial space.

3 Complexity

While complexity results for the base temporal networks we have described are well-known, very few tight bounds exist for the networks derived from their composition, despite the fact that much work has been done to develop algorithms for them. Many of their hardness lower-bounds can be inherited from the base temporal networks, but it is an open question whether or not they are tight.

In this section, we will prove complexity class completeness results for each of strong, weak, and dynamic controllability for each network, updating the hardness lower-bounds as needed before demonstrating membership to the appropriate class. When describing the controllability decision problems, we will use the prefixes SC-, WC-, and DC- to refer to checking the strong, weak, and dynamic controllability of the denoted temporal network, respectively.

3.1 Hardness Results

We start by providing tighter hardness lower-bounds for the controllability problems across temporal networks. Existing results for CSTNs give us appropriate lower-bounds for CSTNUs, but for the temporal networks with disjunction and uncertainty, we need tighter analysis than the NP-hardness provided by TCSPs and DTNs.

Lemma 1.

Checking the weak controllability of a TCSPU is Π2P\Pi_{2}^{P}-hard.

Proof.

To show WC-TCSPU is Π2P\Pi_{2}^{P}-hard, we will provide a reduction from \forall\exists3SAT. In other words, we want to construct a TCSPU TT such that a formula y,x:ϕ(x,y)\forall\vec{y},\exists\vec{x}:\phi(\vec{x},\vec{y}) is weakly controllable if and only if TT is weakly controllable, where x,y\vec{x},\vec{y} are vectors of boolean values, and ϕ\phi is a 3-CNF formula.

We start by defining our timepoints, starting with a reference timepoint ZZ. For each xix_{i}, we construct timepoint txit_{x_{i}} with disjunctive constraint txiZ[0,0][1,1]t_{x_{i}}-Z\in[0,0]\cup[1,1]. For each yjy_{j}, we also construct timepoint tyjt_{y_{j}} with contingent constraint tyjZ[0,0][1,1]t_{y_{j}}-Z\in[0,0]\cup[1,1]. These timepoints will represent the initial values chosen against which we will evaluate ϕ\phi with 0 corresponding to an assignment of false and 1 corresponding to true.

For convenience, we also add timepoints corresponding to the negations of each variable. tx¯it_{\overline{x}_{i}} has two corresponding constraints, tx¯iZ[0,0][1,1]t_{\overline{x}_{i}}-Z\in[0,0]\cup[1,1] and tx¯itxi[1,1][1,1]t_{\overline{x}_{i}}-t_{x_{i}}\in[-1,-1]\cup[1,1]. This ensures that tx¯it_{\overline{x}_{i}} takes on a different value than txit_{x_{i}}. Similarly, we add new timepoints ty¯jt_{\overline{y}_{j}} with requirement links ty¯jZ[0,0][1,1]t_{\overline{y}_{j}}-Z\in[0,0]\cup[1,1] and ty¯jtyj[1,1][1,1]t_{\overline{y}_{j}}-t_{y_{j}}\in[-1,-1]\cup[1,1]. We will rely on the fact that we are evaluating weak controllability to ensure that we set the timepoints for the negated variables in response to the values assigned by nature.

We now move on to encoding each individual clause of ϕ\phi into our TCSPU TT. Our approach is going to be highly inspired by the reduction from 3SAT to the 3-coloring problem on graphs and the reduction from 3-coloring to computing feasibility of a TCSP [6]. We will emulate the three colors by requiring all timepoints to occur at time 0, 1, or 2 and enforce that two nodes ti,tjt_{i},t_{j} differ in value by requiring that titj{2,1,1,2}t_{i}-t_{j}\in\{-2,-1,1,2\}.

Refer to caption
Figure 3: A gadget used in the proof that WC-TCSPU is Π2P\Pi_{2}^{P}-hard. The AkA_{k} timepoints can each take on any value from {0,1,2}\{0,1,2\}. The value Ak,6A_{k,6} represents the disjunction of Gk,1,Gk,2,Gk,3G_{k,1},G_{k,2},G_{k,3} and is constrained to equal one.

For each clause ckc_{k} of ψ\psi, we create a new gadget whose output represents the truth value of ckc_{k} (see Figure 3). Each timepoint Gk,lG_{k,l} represents the truth value of literal ll of clause ckc_{k}. We require that the value matches the initially assigned value of literal qq by adding the constraint Gk,ltq=0G_{k,l}-t_{q}=0. The layout of timepoints AkA_{k} weakly emulate an or-gate, where Ak,6A_{k,6} is the output and constrained to have a value of 1. For any values of the timepoints GkG_{k}, it is possible to assign all of the timepoints AkA_{k} such that Ak,6=1A_{k,6}=1 except for when Gk,1=Gk,2=Gk,3=0G_{k,1}=G_{k,2}=G_{k,3}=0. As a result, it is possible to choose a set of values for the timepoints to satisfy the constraints of the gadget so long as at least one literal of the original clause ckc_{k} is true.

Taken together, if there exists an assignment of values to timepoints such that each gadget’s constraints are satisfied, then for whichever particular y\vec{y} we start with, then x:ϕ(x,y)\exists\vec{x}:\phi(\vec{x},\vec{y}). When checking weak controllability, all executable timepoints are assigned values after the contingent timepoints, so as we have constructed it, TT is weakly controllable if and only if y,x:ϕ(x,y)\forall\vec{y},\exists\vec{x}:\phi(\vec{x},\vec{y}). Thus, WC-TCSPU is Π2P\Pi_{2}^{P}-hard. ∎

Lemma 2.

Checking the dynamic controllability of a TCSPU is PSPACE-hard.

Proof.

To show that DC-TCSPU is PSPACE-hard, we provide a reduction from TQBF, which is known to be PSPACE-complete, to DC-TCSPU. In particular, for a problem of the form x1y1xnyn:ϕ(x,y)\exists x_{1}\forall y_{1}...\exists x_{n}\forall y_{n}:\phi(\vec{x},\vec{y}), we can construct a TCSPU TT such that TT is dynamically controllable if and only if x1y1xnyn:ϕ(x,y)\exists x_{1}\forall y_{1}...\exists x_{n}\forall y_{n}:\phi(\vec{x},\vec{y}), where ϕ\phi is a 3-CNF formula.

Ideally, we would employ a strategy similar to our transformation for WC-TCSPU in Lemma 1, but in that construction, many of the clausal gadget timepoints can occur before the contingent timepoints they relate to are assigned by nature. Because dynamic controllability requires timepoints to be assigned reactively in a just-in-time manner, we must make sure that all values of y\vec{y} are encoded and specified by the network before we do any subsequent computation.

We start by encoding the alternating choice of xix_{i} and yiy_{i} as represented by the values decided by the scheduler and nature. We start with an anchor point OO and for each xix_{i} and yiy_{i}, we create timepoints τxi,s\tau_{x_{i},s}, τxi,e\tau_{x_{i},e}, τyi,s\tau_{y_{i},s}, and τyi,e\tau_{y_{i},e}. For each xix_{i}, we create a requirement constraint of τxi,eτxi,s[0,0][1,1]\tau_{x_{i},e}-\tau_{x_{i},s}\in[0,0]\cup[1,1], and for each yiy_{i}, we create a contingent constraint of τyi,eτyi,s[0,0][1,1]\tau_{y_{i},e}-\tau_{y_{i},s}\in[0,0]\cup[1,1]. This enforces that the difference between the start and end values is either 0 or 1, corresponding to an assignment of false or true in the original formula. To ensure that the values are chosen in order when evaluated in a dynamic controllability setting, we require that τxi,sO=2i2\tau_{x_{i},s}-O=2i-2 and that τyi,sO=2i1\tau_{y_{i},s}-O=2i-1. This gives us the exact alternating pattern as described by the original formula, and what remains is to evaluate the truth condition.

Our strategy for evaluating the truth of the formula is to replicate the same structures used by the constructed TCSPU in Lemma 1. We create a secondary anchor point ZZ with ZO=2n+2Z-O=2n+2 to ensure that ZZ happens after all boolean values have been assigned, and then create new timepoints corresponding to the values of x\vec{x} and y\vec{y} that are anchored at ZZ instead of at different times during the execution. For each xix_{i}, we create txit_{x_{i}} with the constraint txiτxi,e=2(ni)+4t_{x_{i}}-\tau_{x_{i},e}=2(n-i)+4, and for each yiy_{i}, we create tyit_{y_{i}} with the constraint tyiτyi,e=2(ni)+3t_{y_{i}}-\tau_{y_{i},e}=2(n-i)+3. The rest of the construction, namely the construction of the negated literal values and the clausal gadgets, remains the same, and by the same reasoning, we see that it is possible for a given assignment, it is possible for all constraints to be respected if and only if ϕ\phi is satisfied by that assignment of values. Since the initial timepoints are set up such that when the entire network is dynamically controllable the values of timepoints are chosen in the same order as the quantification of the original TQBF formula, we know that TT is dynamically controllable if and only if x1y1xnyn:ϕ(x,y)\exists x_{1}\forall y_{1}...\exists x_{n}\forall y_{n}:\phi(\vec{x},\vec{y}). Because the new network can be constructed in polynomial time, we have a polynomial time reduction from TQBF to DC-TCSPU, so DC-TCSPU is PSPACE-hard.

Lemma 3.

Checking the strong controllability of a DTNU is Σ2P\Sigma_{2}^{P}-hard.

Proof.

To prove that SC-DTNU is Σ2P\Sigma_{2}^{P}-hard, we will reduce the complement of \forall\exists3SAT, a Π2P\Pi_{2}^{P}-complete problem, to SC-DTNU.

An example problem of \forall\exists3SAT is of the form x,y:ϕ(x,y)\forall\vec{x},\exists\vec{y}:\phi(\vec{x},\vec{y}), where x,y\vec{x},\vec{y} are vectors of boolean values and ϕ\phi is a 3-CNF formula. The complementary problem is x,y:ψ(x,y)\exists\vec{x},\forall\vec{y}:\psi(\vec{x},\vec{y}), where ψ\psi is a 3-DNF formula representing the negation of ϕ\phi. Given the input problem, we construct a corresponding DTNU DD that is strongly controllable if and only if the complementary formula ψ\psi is true (if the original formula ϕ\phi is false).

First we define the timepoints of DD. We start with a reference timepoint ZZ, which represents the first point to be executed. For each xixx_{i}\in\vec{x}, we add points txit_{x_{i}} and tx¯it_{\overline{x}_{i}} to represent the value of xix_{i} and its negation during some candidate assignment to our formula. We do the same thing for y\vec{y} adding tyjt_{y_{j}} and ty¯jt_{\overline{y}_{j}} for each yjyy_{j}\in\vec{y}. We also introduce a new gadget per clause of ψ\psi (see Figures 4 and 5) and in each gadget, we introduce ten new timepoints. Timepoints Gk,1G_{k,1}, Gk,2G_{k,2}, and Gk,3G_{k,3} represent the values of each literal of clause kk and timepoint Gk,andG_{k,and} represents the value of the conjunction of those literals. For each clause, we also add Ak,1A_{k,1}, Ak,2A_{k,2}, Ak,3A_{k,3}, Ak,4A_{k,4}, Ak,5A_{k,5}, and Ak,6A_{k,6} which are used collectively to simulate an and clause. By appropriately adding contingent and requirement links between these timepoints, we will get a DTNU that is controllable if and only if the original formula ψ\psi is true.

We start by adding constraints to encode the initial assignment of values. For each txit_{x_{i}} we add a simple disjunctive constraint requiring that txiZ[0,0][1,1]t_{x_{i}}-Z\in[0,0]\cup[1,1]. Similarly, for each tyjt_{y_{j}}, we add a disjunctive contingent constraint enforcing tyjZ[0,0][1,1]t_{y_{j}}-Z\in[0,0]\cup[1,1]. The choice of values for these initial timepoints maps directly back to an assignment of values in the 3-DNF formula ψ\psi with 0 representing false and 1 representing true.

We also enforce the values of the negations of these variables for convenience, with the same simple disjunctive constraint requiring tx¯iZ[0,0][1,1]t_{\overline{x}_{i}}-Z\in[0,0]\cup[1,1] and the disjunctive contingent constraint enforcing ty¯jZ[0,0][1,1]t_{\overline{y}_{j}}-Z\in[0,0]\cup[1,1]. To ensure that xix_{i} and its negation take on values we also add the requirement that txitx¯i[1,1][1,1]t_{x_{i}}-t_{\overline{x}_{i}}\in\cup[-1,-1]\cup[1,1]. We will discuss our strategy for ensuring that the values of tyjt_{y_{j}} and ty¯jt_{\overline{y}_{j}} differ below.

We now move on to the constraints associated with the clausal gadgets. Gk,lG_{k,l} represents the truth value of the lthl^{th} element of clause kk, and Gk,andG_{k,and} represents the truth value of the entire clause; each timepoint, Gk,G_{k,*}, that is newly created for the gadget is initialized using a contingent constraint enforcing GZ[0,0][1,1]G-Z\in[0,0]\cup[1,1]. We also create a disjunctive constraint across all gadgets, such that if for any kk, Gk,andZ=1G_{k,and}-Z=1, then the constraint is satisfied. We call this disjunctive constraint the goal constraint. This has an immediate correspondence to the notion that the entire formula ψ\psi is satisfied if any of its constituent clauses is satisfied.

Refer to caption
Figure 4: A description of the disjunctive goal links found in each gadget used in the proof that SC-DTNU is Σ2P\Sigma_{2}^{P}-hard. The AkA_{k} timepoints can each take on any value from {0,1,2}\{0,1,2\}. The value Ak,6A_{k,6} will only be precluded from taking on a value of 0 when all of Gk,1,Gk,2,Gk,3G_{k,1},G_{k,2},G_{k,3} are 1. The disjunctive constraints of this gadget are all individual parts of the larger collective disjunctive goal constraint.
Refer to caption
Figure 5: A description of the contingent links found in each gadget used in the proof that SC-DTNU is Σ2P\Sigma_{2}^{P}-hard. The links between ZZ and each Gk,lG_{k,l} are contingent links but are constrained to be equal in length to the original xix_{i}, yjy_{j} they relate to using the shared disjunctive goal constraint.

Our current construction makes heavy use of contingent constraints, and while we may want the timepoints in our gadgets to represent certain values, their values are chosen by nature, meaning we have no way to directly control their values.

However, we do have control over the constraints of DD and, in particular, the disjunctive constraint that spans the gadgets. We can think of checking strong controllability as a two-player game, where the scheduler goes first and nature goes second. Nature’s goal is to construct an assignment such that some constraint is violated. Upon closer examination, we see that in our construction, the only constraint that can be affected by the contingent link durations chosen by nature is the goal constraint. If there exist certain combinations of contingent link durations that we want to preclude from our evaluation, we can do so by adding additional disjunct to the goal constraint that are satisfied when those contingent links take on those durations. In this way, any contingent link values that do not conform to our desired structure make DD trivially controllable, and controllability then reduces to controllability under our desired set of constraints across contingent links.

First, we need to make sure that the timepoints tyjt_{y_{j}} and ty¯jt_{\overline{y}_{j}} take on different values. We can ensure this by adding tyjty¯j=0t_{y_{j}}-t_{\overline{y}_{j}}=0 to our goal constraint; if nature gives tyjt_{y_{j}} and ty¯jt_{\overline{y}_{j}} the same value, then we trivially ignore this case. Similarly, since we want Gk,lG_{k,l} to take on the same value as the literal qq it represents, we augment our disjunctive goal constraint with Gk,ltq[1,1]G_{k,l}-t_{q}\in[-1,-1] and Gk,ltq[1,1]G_{k,l}-t_{q}\in[1,1] where tqt_{q} is the timepoint associated with literal qq. As a result, if the clausal representation of the variable differs from our assignment, our network is trivially controllable.

We enforce the conjunction of the elements of each clause by augmenting our goal constraint with Gk,andGk,l1G_{k,and}-G_{k,l}\geq 1 for each Gk,lG_{k,l} of our clause gadget. Since each timepoint of our gadget can take on a value of 0 or 1, this constraint will only be satisfied if some literal value is 0 while Gk,andG_{k,and} has a value of 1. In these situations, Gk,andG_{k,and} does not represent the conjunction of the literals of clause kk, and our network then becomes trivially controllable.

Unfortunately, our network still does not perfectly encode the conjunction seen in a DNF clause. It is possible for each Gk,lG_{k,l} to take on a value of 1 while Gk,andG_{k,and} is assigned a value of 0. As a result, it may be the case that the original problem, xyψ(x,y)\exists\vec{x}\forall\vec{y}\psi(\vec{x},\vec{y}) is true but each Gk,andG_{k,and} is set to 0, meaning that the network is not strongly controllable.

To fix this, we must augment our gadget to enforce that identical inputs have the same output. This is the reason for introducing timepoints Ak,mA_{k,m}, and these timepoints’ values are set by new contingent links that enforce Ak,mZ[0,0][1,1][2,2]A_{k,m}-Z\in[0,0]\cup[1,1]\cup[2,2]. Through an exhaustive enumeration of possible values, we can confirm that whenever Gk,1,Gk,2,Gk,3G_{k,1},G_{k,2},G_{k,3} are all 1, either Ak,6A_{k,6} will be 1 or one of the disjuncts of the goal constraints (see Figure 4) will be satisfied. In this case, when we add Ak,6Gk,and1A_{k,6}-G_{k,and}\geq 1 to the goal constraint, we know that when Gk,1,Gk,2,Gk,3G_{k,1},G_{k,2},G_{k,3} are all equal to 1, DD is controllable, as either Gk,and=1G_{k,and}=1, meaning Gk,andZ=1G_{k,and}-Z=1, which satisfies the goal constraint, or Gk,and=0G_{k,and}=0, implying Ak,6Gk,and=1A_{k,6}-G_{k,and}=1, which also satisfies the goal constraint.

Before continuing, we need to confirm that the addition of the new sub-gadget does not introduce any new problems. For all other values of Gk,1G_{k,1}, Gk,2G_{k,2}, and Gk,3G_{k,3}, we know it is possible for Ak,6A_{k,6} to take on a value of 0. Since Ak,6A_{k,6} is the only timepoint of the or-gate that is related to other values by the goal constraint and setting it to 0 does not satisfy the goal constraint, we know that if Gk,1,Gk,2,Gk,3G_{k,1},G_{k,2},G_{k,3} are not all 1, then there exists a choice of values by nature such that the goal constraint is not satisfied by gadget kk.

Our transformation is complete and because there is one gadget per clause in ψ\psi and each gadget is of constant size, we see that the transformation takes polynomial time. What remains is to show that DD is strongly controllable if and only if xyψ(x,y)\exists\vec{x}\forall\vec{y}\psi(\vec{x},\vec{y}) is true. This is evident from our construction.

If DD is strongly controllable, there must be some set of assignment to values txit_{x_{i}} such that no possible assignment of values to the other timepoints violates any of the constraints. We can prove this by contradiction, assuming that although our choice of txit_{x_{i}} guarantees the satisfaction of all other constraints in DD, there is no choice of x\vec{x} that guarantees satisfaction of yψ(x,y)\forall\vec{y}\psi(\vec{x},\vec{y}). Let x\vec{x} be specified such that xix_{i} is true if and only if txi=1t_{x_{i}}=1. If ψ\psi is not guaranteed to be satisfied, there must be some y\vec{y} such that ψ(x,y)\psi(\vec{x},\vec{y}) is false. Returning to DD, assume that nature specifies tyjt_{y_{j}} such that tyj=1t_{y_{j}}=1 if and only if yjy_{j} is true. Since DD is strongly controllable, we know that some disjunctive goal constraint is satisfied no matter the assignment of contingent timepoint variables. Let’s assume that all ty¯jt_{\overline{y}_{j}} are chosen such that they represent the negation of their corresponding tyjt_{y_{j}}, that all Ak,mA_{k,m} of the gadgets are chosen such that the disjunctive constraints involved between all Gk,lG_{k,l} and Ak,mA_{k,m} are not satisfied, and that all Gk,andG_{k,and} are chosen to be 0. The only remaining disjunctive constraints are those involving each Gk,andG_{k,and}. For any particular kk, setting Gk,andG_{k,and} to 0 only satisfies a constraint if Ak,6A_{k,6} is 1, so given all these assumptions, at least one Ak,6A_{k,6} must be set to 1 (otherwise the system would be uncontrollable). As we demonstrated earlier, Ak,6A_{k,6} is only constrained to be 1 when all of Gk,1G_{k,1}, Gk,2G_{k,2}, and Gk,3G_{k,3} are also 1. But those three values correspond exactly to literals in a clause of ψ(x,y)\psi(\vec{x},\vec{y}). If all three are 1, then we have a true clause and because ψ\psi is a 3-DNF formula, this means that ψ\psi is true. We have a contradiction. Therefore if DD is controllable, xyψ(x,y)\exists\vec{x}\forall\vec{y}\psi(\vec{x},\vec{y}).

To conclude we show the reverse direction, that if xyψ(x,y)\exists\vec{x}\forall\vec{y}\psi(\vec{x},\vec{y}) is true, then DD is strongly controllable. Let x\vec{x} be the assignment of variables that guarantees yψ(x,y)\forall\vec{y}\psi(\vec{x},\vec{y}); we show how we can use x\vec{x} to show that DD is strongly controllable. We will pick our txit_{x_{i}} such that txi=1t_{x_{i}}=1 if and only if xix_{i} is true and will pick our tx¯it_{\overline{x}_{i}} such that tx¯itxit_{\overline{x}_{i}}\neq t_{x_{i}}. Again we will proceed with proof by contradiction, assuming that DD is not strongly controllable. Our choice of txit_{x_{i}} and tx¯it_{\overline{x}_{i}} satisfy all constraints except the disjunctive goal constraint, so there must be a choice of contingent timepoints that violate the disjunctive goal constraint. We know setting Gk,and=1G_{k,and}=1 satisfies the goal constraint, so all Gk,and=0G_{k,and}=0. By proxy, for all kk, Ak,6=0A_{k,6}=0 to ensure that the goal constraint is not satisfied because of the link between Ak,6A_{k,6} and Gk,andG_{k,and}. Because Ak,6=0A_{k,6}=0, it must be the case that for each gadget, at least one of Gk,1G_{k,1}, Gk,2G_{k,2}, or Gk,3G_{k,3} must equal zero. In order for the goal disjunctive constraint to remain unsatisfied, each Gk,lG_{k,l} must maintain the same value as some txit_{x_{i}}, tx¯it_{\overline{x}_{i}}, tyjt_{y_{j}}, or ty¯jt_{\overline{y}_{j}} based on the values of the clauses of ϕ\phi. This forces a particular assignment of values to tyjt_{y_{j}} which we can map back to some y\vec{y}. For that particular assignment, we know that ψ(x,y)\psi(\vec{x},\vec{y}) is true, or that there is some clause kk^{\prime} with all literals set to true. This contradicts the fact that for all kk, at least one of Gk,1G_{k,1}, Gk,2G_{k,2}, or Gk,3G_{k,3} must be zero. Thus, DD must be strongly controllable, and we have proven that SC-DTNU is Σ2P\Sigma_{2}^{P}-hard.

3.2 Completeness

We now move on to proving completeness for the controllability problems on each temporal network. Our general approach for characterizing the complexity of controllability problems will be to map an inputted temporal network to a corresponding system of conditional linear inequalities that encode the same constraints. We will then use existential and universal quantifiers over the variables to dictate which type of controllability is being determined.

Our transformation proceeds as follows. We can imagine the execution of a temporal network as being a game played between two agents, the scheduler and nature, where the scheduler assigns times to executable timepoints and nature assigns times to contingent timepoints. In general the question of determining controllability will reduce to the problem of evaluating a quantified linear system and our techniques draw inspiration from and are related to approaches in those areas [7, 21].

For notational convenience, we will split our variables into x\vec{x} and y\vec{y} for those assigned by the scheduler and nature, respectively. For each executable timepoint eie_{i}, we create a new variable xix_{i}, and for each contingent timepoint cic_{i}, we create a new variable yiy_{i}.

We create a one-to-one mapping between the set of temporal network constraints and the new linear inequalities. First, we replace all executable timepoints eie_{i} with the corresponding xix_{i}. With the contingent timepoints, however, we need to be more careful. For each contingent timepoint cic_{i}, we find the contingent constraint that restricts it of the form lcciejucl_{c}\leq c_{i}-e_{j}\leq u_{c}. We then replace each instance of cic_{i} in our constraints with yi+xjy_{i}+x_{j}. Our reason for doing this has to do with the nature of contingent constraints. In temporal networks, there is a guarantee that nature respects the contingent constraint bounds in relation to its corresponding starting executable timepoint. So while free constraints relate timepoints in terms of the absolute time of their occurrence, contingent constraints require nature to respect relative timings of events. If the durations of contingent constraints are to be known before scheduling begins, as is the case with weak controllability, then the constructed system of linear inequalities will fail to map to the base temporal network if nature is asked to pick the precise times of contingent events.

After the substitutions, each constraint is a combination of conditional linear inequalities of the form ψa[xy]b\psi\rightarrow\vec{a}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b, where bb is some constant, ψ\psi is a (possibly empty) precondition for the enforcement of the constraint, and a\vec{a} represents the coefficients of the constraints where each coefficient is either -1, 0, or 1. Since all constraints are relative, without loss of generality, we can say that the earliest event happens at time t=0t=0, meaning we can safely require that x0\vec{x}\geq 0. When we quantify over variables to pick controllability, we require that each xix_{i} has an existential quantifier and each yiy_{i} has a for-all quantifier drawn from the union of the ranges [l1,u1],,[ld,ud][l_{1},u_{1}],...,[l_{d},u_{d}], where ljl_{j} and uju_{j} are retrieved from one of cic_{i}’s corresponding contingent constraints.

When evaluating controllability for disjunctive networks, it is useful to consider each contingent range separately, and so we will define Ω\Omega as a mapping from each variable yiy_{i} and one of its possible continuous ranges. In general, we will use the shorthand Ω\forall\Omega to indicate that we are considering all possible mappings and yΩ\forall\vec{y}\in\Omega to specify that we are drawing our y\vec{y} from one particular mapping. Our choice of the ordering of the quantifiers will dictate which type of controllability will be considered. We also must consider how conditions affect our model, and will define Ψ\Psi as the full set of conditions that can be observed by the scheduler when our temporal networks include conditional constraints.

It is also worth noting that whenever we consider a vector of values xc\vec{x_{c}} that represent a solution to our scheduling problem, we assume that the representation of xc\vec{x_{c}} is polynomial in the size of the original input. While we are agnostic to which particular representation is used, we do still require a fixed number of bits required to represent each individual number. The implication of this is that between any two numbers, there are a finite number of intermediate values that can be represented.

The rest of our analysis is divided into an analysis of strong controllability over temporal networks, weak controllability over temporal networks, and dynamic controllability over temporal networks.

3.2.1 Strong Controllability

Theorem 4.

Checking strong controllability of a CSTNU is in P.

Proof.

We start by encoding the SC-CSTNU problem in our described format:

xyΨ:iψiai[xy]bi\exists\vec{x}\forall\vec{y}\forall\Psi:\bigwedge\limits_{i}\psi_{i}\rightarrow\vec{a_{i}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{i}

Because ϕ\forall\bigwedge\phi is the same as ϕ\bigwedge\forall\phi, we can rewrite our problem as:

xyiΨ:ψiai[xy]bi\exists\vec{x}\forall\vec{y}\bigwedge\limits_{i}\forall\Psi:\psi_{i}\rightarrow\vec{a_{i}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{i}

Since the inner equation must hold for all Ψ\Psi, it must also hold when ψi\psi_{i} is true, allowing us to eliminate the conditionals:

xyi:ai[xy]bi\exists\vec{x}\forall\vec{y}\bigwedge\limits_{i}:\vec{a_{i}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{i}

But of course, this is exactly the encoding for checking strong controllability of an STNU. Since STNU strong controllability is verifiable in polynomial time [25], our work demonstrates that strong controllability of a CSTNU can be determined in polynomial time through reduction to an STNU. ∎

Theorem 5.

Checking the strong controllability of TCSPUs is NP-complete.

Proof.

We know that checking the feasibility of a TCSP is NP-hard [6], and because TCSPUs are a generalization of TCSPs, it follows that SC-TCSPU is NP-hard. To prove completeness, we show that SC-TCSPU \in NP.

In a TCSPU, all disjunctive requirement links span the same pair of variables, meaning that every requirement link is of the form titj[l1,u1][lk,uk]t_{i}-t_{j}\in[l_{1},u_{1}]\cup...\cup[l_{k},u_{k}], where for every p<qp<q, up<lqu_{p}<l_{q}. This allows us to rewrite all individual constraints as:

titjl1(p=2ktitjup1titjlp)t_{i}-t_{j}\geq l_{1}\wedge\left(\bigwedge\limits_{p=2}^{k}t_{i}-t_{j}\leq u_{p-1}\vee t_{i}-t_{j}\geq l_{p}\right)\wedge
titjukt_{i}-t_{j}\leq u_{k}

Now when we encode strong controllability of a TCSPU, we can write the formula as:

xy:ijaij[xy]bij\exists\vec{x}\forall\vec{y}:\bigwedge\limits_{i}\bigvee\limits_{j}\vec{a_{ij}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{ij}
xiy:jaij[xy]bij\exists\vec{x}\bigwedge\limits_{i}\forall\vec{y}:\bigvee\limits_{j}\vec{a_{ij}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{ij}
xi¬y:jaij[xy]>bij\exists\vec{x}\bigwedge\limits_{i}\neg\exists\vec{y}:\bigwedge\limits_{j}\vec{a_{ij}}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}>b_{ij}

For any fixed x^\hat{x} and ii, we can solve the problem y:j[x^T;yT]aij>bij\exists\vec{y}:\bigwedge\limits_{j}[\hat{x}^{T};\vec{y}^{T}]\cdot\vec{a_{ij}}>b_{ij} in polynomial time. We know that linear programs can be optimized in polynomial time [11], and so to derive an answer for our original problem, we solve the linear program j[aijT;1][x^yϵ]bij\bigwedge\limits_{j}[\vec{a_{ij}}^{T};-1]\begin{bmatrix}\hat{x}\\ \vec{y}\\ \epsilon\end{bmatrix}\geq b_{ij} maximizing ϵ\epsilon. If no solution exists, then there is no valid y\vec{y}. If a solution exists with ϵ0\epsilon\leq 0, then there was some constraint for which [x^T;yT]aij>bij[\hat{x}^{T};\vec{y}^{T}]\cdot\vec{a_{ij}}>b_{ij} did not hold as there was a non-positive margin required to make all inequalities hold. Thus, only if ϵ>0\epsilon>0, do we say that there exists a y\vec{y} satisfying our original constraints.

This immediately implies that we have a routine for verifying a certificate for SC-TCSPU in polynomial time. Given a certificate x^\hat{x}, then for each of the constraints ii, we run our subroutine for determining whether a y\vec{y} exists that satisfies the specified sub-constraints. Since the verification algorithm runs in polynomial time, we know that SC-TCSPU \in NP, and that SC-TCSPU is NP-complete. ∎

Theorem 6.

Checking the strong controllability of DTNUs and CDTNUs are Σ2P\Sigma_{2}^{P}-complete.

Proof.

We know that checking the strong controllability of a DTNU is Σ2P\Sigma_{2}^{P}-hard from Lemma 3 and because CDTNUs generalize DTNUs, SC-CDTNU is also Σ2P\Sigma_{2}^{P}-hard. To demonstrate that both are Σ2P\Sigma_{2}^{P}-complete, we show that checking the strong controllability of a CDTNU is in Σ2P\Sigma_{2}^{P}.

To do so, we show that with an NP oracle we can verify that a CDTNU is strongly controllable in polynomial time. We start with an encoding of our problem:

xΨΩyΩ:ijψijkaijk[xy]bijk\exists\vec{x}\forall\Psi\forall\Omega\forall\vec{y}\in\Omega:\bigwedge\limits_{i}\bigvee\limits_{j}\psi_{ij}\rightarrow\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{ijk}

and we let our certificate be the assignment of values to all executable timepoints, x^\hat{x}. Given this certificate, an NP-oracle is capable of evaluating:

ΨΩyΩ:¬ijψijkaijk[x^y]bijk\exists\Psi\exists\Omega\exists\vec{y}\in\Omega:\neg\bigwedge\limits_{i}\bigvee\limits_{j}\psi_{ij}\rightarrow\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\hat{x}\\ \vec{y}\end{bmatrix}\leq b_{ijk}

We can see this simply, as when we provide a certificate comprised of Ψ^,Ω^,y^\hat{\Psi},\hat{\Omega},\hat{y}, it takes linear time to verify whether the conditional constraints are all satisfied.

Thus, when given a candidate assignment x^\hat{x}, we can use an NP-oracle to evaluate the negation of the remainder of the formula. If the negation has no solution, then we know that the original formula is true, and we have a way to verify SC-CDTNU in polynomial time. Thus, SC-CDTNU Σ2P\in\Sigma_{2}^{P}, so SC-DTNU and SC-CDTNU are Σ2P\Sigma_{2}^{P}-complete. ∎

3.2.2 Weak Controllability

Next, we move on to evaluating the complexity of weak controllability in temporal networks.

Theorem 7.

Checking the weak controllability of CSTNUs is coNP-complete.

Proof.

Checking the weak controllability of STNUs is coNP-complete [14], so similarly checking the weak controllability of CSTNUs must be coNP-hard. To demonstrate that WC-CSTNU is coNP-complete, we must show that WC-CSTNU \in coNP. We see this clearly when we look at the quantified linear system we get when evaluating a CSTNU’s weak controllability:

Ψyx:iψiai[xy]bi\forall\Psi\forall\vec{y}\exists\vec{x}:\bigwedge\limits_{i}\psi_{i}\rightarrow\vec{a}_{i}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{i}

To show that WC-CSTNU is in coNP, we show that its complement problem is in NP, or that we can verify the following formula in polynomial time:

Ψy¬x:iψiai[xy]bi\exists\Psi\exists\vec{y}\neg\exists\vec{x}:\bigwedge\limits_{i}\psi_{i}\rightarrow\vec{a}_{i}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{i}

In this instance, we take as our certificate a particular choice of Ψ^\hat{\Psi} and y^\hat{y}. We can verify these values directly:

¬x:i:Ψ^ψiψiai[xy^]bi\neg\exists\vec{x}:\bigwedge\limits_{i:\hat{\Psi}\vDash\psi_{i}}\psi_{i}\rightarrow\vec{a}_{i}\cdot\begin{bmatrix}\vec{x}\\ \hat{y}\end{bmatrix}\leq b_{i}
¬x:i:Ψ^ψiai[xy^]bi\neg\exists\vec{x}:\bigwedge\limits_{i:\hat{\Psi}\vDash\psi_{i}}\vec{a}_{i}\cdot\begin{bmatrix}\vec{x}\\ \hat{y}\end{bmatrix}\leq b_{i}

Of course, we can evaluate all linear inequalities simultaneously through the evaluation of a linear program:

¬x:AΨ^[xy^]bΨ^\neg\exists\vec{x}:A_{\hat{\Psi}}\begin{bmatrix}\vec{x}\\ \hat{y}\end{bmatrix}\leq\vec{b}_{\hat{\Psi}}

Since linear programs can be evaluated in polynomial time [11], we can verify the complement of WC-CSTNU in polynomial time, meaning that WC-CSTNU \in coNP and is coNP-complete. ∎

Theorem 8.

Checking the weak controllability of TCSPUs, DTNUs, and CDTNUs are Π2P\Pi_{2}^{P}-complete.

Proof.

By Lemma 1, we know that computing the weak controllability of TCSPUs are Π2P\Pi_{2}^{P}-hard, meaning computing WC-DTNU and WC-CDTNU are both also Π2P\Pi_{2}^{P}-hard. To show that all three are Π2P\Pi_{2}^{P}-complete, we must show that WC-CDTNU Π2P\in\Pi_{2}^{P}. We start with the quantified formula representation of weak controllability in a CDTNU:

ΨΩyΩx:ijψij(kaijk[xy]bijk)\forall\Psi\forall\Omega\forall\vec{y}\in\Omega\exists\vec{x}:\bigwedge\limits_{i}\bigvee\limits_{j}\psi_{ij}\rightarrow\left(\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{ijk}\right)

For our purposes, it will be useful to show that the complementary problem is in Σ2P\Sigma_{2}^{P}:

ΨΩy¬x:ijψij(kaijk[xy]bijk)\exists\Psi\exists\Omega\exists\vec{y}\neg\exists\vec{x}:\bigwedge\limits_{i}\bigvee\limits_{j}\psi_{ij}\rightarrow\left(\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\vec{x}\\ \vec{y}\end{bmatrix}\leq b_{ijk}\right)

To prove that solving the above formula is in Σ2P\Sigma_{2}^{P}, we show that with an NP-oracle, we can construct a verification algorithm that runs in polynomial time. Our verifier will take in the certificate composed of Ψ^,Ω^,y^\hat{\Psi},\hat{\Omega},\hat{y}, leaving the subproblem:

¬x:ij:Ψ^ψijψij(kaijk[xy^]bijk)\neg\exists\vec{x}:\bigwedge\limits_{i}\bigvee\limits_{j:\hat{\Psi}\vDash\psi_{ij}}\psi_{ij}\rightarrow\left(\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\vec{x}\\ \hat{y}\end{bmatrix}\leq b_{ijk}\right)
¬x:ij:Ψ^ψijkaijk[xy^]bijk\neg\exists\vec{x}:\bigwedge\limits_{i}\bigvee\limits_{j:\hat{\Psi}\vDash\psi_{ij}}\bigwedge\limits_{k}\vec{a}_{ijk}\cdot\begin{bmatrix}\vec{x}\\ \hat{y}\end{bmatrix}\leq b_{ijk}

The unnegated version of this problem is clearly in NP. Given a certificate x^\hat{x}, we can verify whether or not the formula holds in linear time. As a result, with an NP-oracle, we can solve the presented subproblem, meaning that our complement problem is in Σ2P\Sigma_{2}^{P} and our original problem is thus in Π2P\Pi_{2}^{P}. This proves that WC-TCSPU, WC-DTNU, and WC-CDTNU are Π2P\Pi_{2}^{P}-complete. ∎

3.2.3 Dynamic Controllability

Finally, we show that checking dynamic controllability for any temporal network with uncertainty and either disjunctions or conditional constraints is PSPACE-complete.

Theorem 9.

Checking the dynamic controllability of CSTNUs, TCSPUs, DTNUs, and CDTNUs are PSPACE-complete.

Proof.

We know from Lemma 2 that DC-TCSPU is PSPACE-hard, meaning that checking the dynamic controllability of DTNUs and CDTNUs must also be PSPACE-hard. Similarly because checking the dynamic controllability of CSTNs is PSPACE-hard [1], DC-CSTNU must also be PSPACE-hard. In order to show that determining dynamic controllability for any of these four networks in PSPACE-complete, we provide an algorithm for checking the dynamic controllability of CDTNUs which requires polynomial space (see Algorithm 1).

Input: A list of timepoints with assigned values, TT;
A list of active contingent links, AA;
A set of yet-to-be-executed timepoints EE;
The input CDTNU GG;
The current time, τ\tau
Output: Whether the CDTNU is dynamically controllable.
CheckDC:
1 if E.empty()E.empty() then
2 for realizationA.realizationsFrom(τ)realization\in A.realizationsFrom(\tau) do
3    if !G.isConsistent(T.extend(realization))!G.isConsistent(T.extend(realization)) then
4       return falsefalse;
5       
6 return truetrue;
7 
8for tEt\in E do
9 for τ[τ,G.tMax]\tau^{\prime}\in[\tau,G.tMax] do
10    allSatisfiedtrueallSatisfied\leftarrow true;
11    for realizationA.realizationsFrom(τ)realization\in A.realizationsFrom(\tau) do
12       earliestrealization.earliest()earliest\leftarrow realization.earliest();
13       if early.timeτearly.time\leq\tau^{\prime} then
14           if !CheckDC(T{earliest},T\cup\{earliest\},
15          A.nextContingents(earliest),A.nextContingents(earliest),
16          E,E,
17          G,G,
18          earliest.timeearliest.time) then
19             allSatisfiedfalseallSatisfied\leftarrow false;
20               break;
21             
22       else
23           if !CheckDC(T{TimepointAssignment(t,τ)},T\cup\{\textsc{TimepointAssignment}(t,\tau^{\prime})\},
24          A.nextContingents(TimepointAssignment(t,τ)),A.nextContingents(\textsc{TimepointAssignment}(t,\tau^{\prime})),
25          Et,E\setminus t,
26          G,G,
27          τ\tau^{\prime}) then
28             allSatisfiedfalseallSatisfied\leftarrow false;
29               break;
30             
31    if allSatisfiedallSatisfied then
32       return truetrue;
33       
34return falsefalse;
Algorithm 1 PSPACE algorithm for checking DC-CDTNU.

Before we explain the details of the algorithm, we need to extend some concepts to describe a partially executed CDTNU, as our algorithm for determining dynamic controllability will recursively act on partially executed networks. We say that timepoints are scheduled if they have been assigned a specific value, whether by the scheduler or by nature. We say that a contingent link is active if its starting timepoint has been scheduled but its ending timepoint has not. Finally, given a group of active contingent links, we say that the set of all realizations from some time τ\tau is the set of all possible times at which the contingent links could end with none of them ending sooner than τ\tau. We can now move on to describing the function of the algorithm before demonstrating that it uses at most polynomial space.

The algorithm works by recursively simulating all possible strategies used by an agent in a dynamically controllable setting. As input, it takes in a list of timepoints whose values have already been scheduled (either by the scheduler or by nature), a list of active contingent links, a list of unexecuted timepoints, the CDTNU, and the current time. While there are still executable timepoints that need to be scheduled, the algorithm searches for one that guarantees a valid dynamically controllable strategy.

In the context of dynamic controllability, an agent only has one of two possible actions: they can either unconditionally schedule an action or schedule an action to occur so long as no other contingent timepoint occurs in the interim. We model this behavior by modeling all scheduling actions as interruptible by contingent timepoints. In other words, if a contingent timepoints occurs before an event we unconditionally scheduled, we still give the agent the choice to adapt their strategy. In the case of an unconditionally scheduled action, they would just reaffirm their previous choice.

To model all strategies, we iterate over all possible timepoints that can be scheduled (line 6) and all possible times at which they can be scheduled (line 7). If at least one scheduling of a timepoint given the input parameters is valid, then we know that the CDTNU is dynamically controllable. When there are no active contingent links that might be scheduled before the timepoint that we chose to schedule, we can recurse on that assignment to get an answer (line 20-26), but in the case that there are contingent links that may occur earlier, we have to respond to them in turn (lines 9-18). If all possible realizations of contingent link values still guarantee that the CDTNU is consistent, then we know that the system is dynamically controllable.

Now, we show that the algorithm uses at most polynomial space. If we have no more timepoints to schedule, then we stay in lines 1-5 of the algorithm, which checks consistency over all possible realizations of the remaining contingent links. Checking consistency is a polynomial time operation, as it just requires iterating through each constraint and verifying that it is satisfied. While we have to do this for exponentially many realizations, we do not need to remember each particular realization; we merely need to remember the current realization and know how to increment to the next one. As a result, handling all realizations also takes polynomial space.

In the event that we do have executable timepoints to schedule, we operate over lines 6-29. Iterating over each timepoint at line 6 takes polynomial space, and when we iterate over all τ\tau^{\prime} at line 7, we have a finite but exponentially large number of values to choose from but only need polynomially many bits to represent that choice. At line 9, we handle realizations in the same way as we did at line 2, meaning we only need polynomial space, and then we have the remaining recursive calls. If we look at the number of possible stack frames, we see that every time we recursively call CheckDC, we add a new timepoint to TT, correspondingly removing it from either AA (line 13) or EE (line 22). The set EE never grows, and because every contingent link’s ending timepoint is unique, we will never add the same timepoint to AA twice. This means that after at most |XeXb||X_{e}\cup X_{b}| recursive calls, we will eventually reach a state where EE is empty, and our recursive calls will terminate. This preserves our guarantee that we use polynomial space, meaning that Algorithm 1 decides DC-CDTNU and is in PSPACE. Thus, deciding dynamic controllability for CSTNUs, TCSPUs, DTNUs, and CDTNUs are all PSPACE-complete. ∎

4 Discussion and Conclusions

Our work provides novel complexity results that are much tighter than existing bounds and require at most polynomial space for strong, weak, and dynamic controllability of several distinct types of temporal networks; this work is summarized in Figure 1. Beyond the contribution of the relevant proofs, the value of these results is that it gives modelers insight into which types of features have a significant impact on the runtime complexity of a problem. Many of these insights are not immediately obvious, and in the remainder of this section we discuss a few of them.

First we consider CSTNUs. CSTNUs are a generalization of CSTNs and STNUs and share much in common with their predecessors. In particular, strong controllability of CSTNUs, being in P, can be computed quite efficiently. Our proof for Theorem 4 actually proves a stronger result that a CSTNU is strongly controllable if and only if the corresponding STNU derived by making all constraints unconditional is strongly controllable. This implies that strong controllability of CSTNUs can be computed in O(mn)O(mn) time, which is as fast as it takes to compute the feasibility of a simple STN. When we turn to weak and dynamic controllability, we see that checking the controllability of a CSTNU is in the same class as checking controllability of a CSTN. From the perspective of the modeler, this implies that there is a surprisingly low cost to adding uncertainty to a temporal constraint model that already uses conditional constraints.

While CSTNU controllability checking matches the complexity of CSTN controllability checking, it only matches the controllability checking complexity of strong and weak controllability for STNUs. In fact, dynamic controllability checking across all types of networks, with the exception of STNUs, is PSPACE-complete. In scheduling problems, modelers must often make the trade-off between using strong controllability, which is often easier to compute, and dynamic controllability, which gives more flexibility during execution but is more expensive. In instances where dynamic controllability is deemed necessary, there is a significant advantage to relaxing the underlying temporal model, eliminating conditional and disjunctive constraints, to use an STNU. It is still quite surprising that despite the fact that STNU dynamic controllability can be determined in polynomial time, every other modification makes computing dynamic controllability PSPACE-complete.

A final area worth discussing is the effect of temporal disjunctions. The two temporal network models that use disjunctions without temporal uncertainty are TCSPs and DTNs; TCSPs have simple disjunctions, only requiring disjunctions over a single link, while DTNs have full disjunctions, allowing disjunctions to span multiple links. Since determining feasibility for both network structures is NP-complete, intuition would suggest that after adding uncertainty the complexity of checking controllability for TCSPUs and DTNUs would also be the same. While this is the case for weak and dynamic controllability, we do see a difference in strong controllability, meaning that strong controllability is easier to compute in TCSPUs than it is in DTNUs, assuming NP Σ2P\neq\Sigma_{2}^{P}, implying there is a meaningful difference between the two types of disjunctions.

As we look forward, there are still many areas worthy of future research efforts. One, in particular, is the development of novel algorithms for determining the controllability of these networks. Our work establishes bounds on the complexity of computing controllability but does minimal work to provide algorithms for doing so. In practice, our proofs admit the trivial polynomial-space strategy of recursive enumeration of certificates but these algorithms are likely impractical. Our new theoretical bounds open up the challenge of finding novel algorithms that are reasonable for practical use while still respecting polynomial time bounds.

Acknowledgments

This research was funded in part by the Toyota Research Institute under grant number LP-C000765-SR.

Bibliography

References

  • Cairo and Rizzi [2016] Cairo, M., and Rizzi, R. 2016. Dynamic controllability of conditional simple temporal networks is pspace-complete. In The 23rd International Symposium on Temporal Representation and Reasoning (TIME), 90–99. IEEE.
  • Cairo et al. [2017] Cairo, M.; Combi, C.; Comin, C.; Hunsberger, L.; Posenato, R.; Rizzi, R.; and Zavatteri, M. 2017. Incorporating decision nodes into conditional simple temporal networks. In LIPIcs-Leibniz International Proceedings in Informatics, volume 90. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik.
  • Cimatti et al. [2014] Cimatti, A.; Hunsberger, L.; Micheli, A.; Posenato, R.; and Roveri, M. 2014. Sound and complete algorithms for checking the dynamic controllability of temporal networks with uncertainty, disjunction and observation. In The 21st International Symposium onTemporal Representation and Reasoning (TIME), 27–36. IEEE.
  • Cimatti, Micheli, and Roveri [2016] Cimatti, A.; Micheli, A.; and Roveri, M. 2016. Dynamic controllability of disjunctive temporal networks: Validation and synthesis of executable strategies. In Association for the Advancement of Artificial Intelligence (AAAI), 3116–3122.
  • Combi, Hunsberger, and Posenato [2013] Combi, C.; Hunsberger, L.; and Posenato, R. 2013. An algorithm for checking the dynamic controllability of a conditional simple temporal network with uncertainty. In The 5th International Conference on Agents and Artificial Intelligence, volume 1,  1.
  • Dechter, Meiri, and Pearl [1991] Dechter, R.; Meiri, I.; and Pearl, J. 1991. Temporal constraint networks. Artificial Intelligence 49(1-3):61–95.
  • Eirinakis et al. [2014] Eirinakis, P.; Ruggieri, S.; Subramani, K.; and Wojciechowski, P. 2014. On quantified linear implications. Annals of Mathematics and Artificial Intelligence 71(4):301–325.
  • Fang, Yu, and Williams [2014] Fang, C.; Yu, P.; and Williams, B. C. 2014. Chance-constrained probabilistic simple temporal problems. In Association for the Advancement of Artificial Intelligence (AAAI).
  • Hunsberger, Posenato, and Combi [2012] Hunsberger, L.; Posenato, R.; and Combi, C. 2012. The dynamic controllability of conditional stns with uncertainty. arXiv preprint arXiv:1212.2005.
  • Hunsberger [2016] Hunsberger, L. 2016. Efficient execution of dynamically controllable simple temporal networks with uncertainty. Acta Informatica 53(2):89–147.
  • Karmarkar [1984] Karmarkar, N. 1984. A new polynomial-time algorithm for linear programming. In Proceedings of the 16th Annual ACM Symposium on Theory of Computing, 302–311. ACM.
  • Karpas et al. [2015] Karpas, E.; Levine, S. J.; Yu, P.; and Williams, B. C. 2015. Robust execution of plans for human-robot teams. In International Conference on Automated Planning and Scheduling, 342–346.
  • Kim, Williams, and Abramson [2001] Kim, P.; Williams, B. C.; and Abramson, M. 2001. Executing reactive, model-based programs through graph-based temporal planning. In International Joint Conference on Artificial Intelligence (IJCAI-01), 487–493.
  • Morris and Muscettola [1999] Morris, P., and Muscettola, N. 1999. Managing temporal uncertainty through waypoint controllability. In International Joint Conference on Artificial Intelligence (IJCAI-99), 1253–1258.
  • Morris and Muscettola [2005] Morris, P., and Muscettola, N. 2005. Temporal dynamic controllability revisited. In Association for the Advancement of Artificial Intelligence (AAAI), 1193–1198.
  • Morris [2014] Morris, P. 2014. Dynamic controllability and dispatchability relationships. In International Conference on AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems, 464–479. Springer.
  • Peintner, Venable, and Yorke-Smith [2007] Peintner, B.; Venable, K. B.; and Yorke-Smith, N. 2007. Strong controllability of disjunctive temporal problems with uncertainty. In International Conference on Principles and Practice of Constraint Programming, 856–863. Springer.
  • Planken [2007] Planken, L. 2007. Temporal reasoning problems and algorithms for solving them.
  • Stergiou and Koubarakis [2000] Stergiou, K., and Koubarakis, M. 2000. Backtracking algorithms for disjunctions of temporal constraints. Artificial Intelligence 120(1):81–117.
  • Stockmeyer [1976] Stockmeyer, L. J. 1976. The polynomial-time hierarchy. Theoretical Computer Science 3(1):1–22.
  • Subramani [2007] Subramani, K. 2007. On a decision procedure for quantified linear programs. Annals of Mathematics and Artificial Intelligence 51(1):55–77.
  • Tsamardinos, Vidal, and Pollack [2003] Tsamardinos, I.; Vidal, T.; and Pollack, M. E. 2003. Ctp: A new constraint-based formalism for conditional, temporal planning. Constraints 8(4):365–388.
  • Venable and Yorke-Smith [2005] Venable, K. B., and Yorke-Smith, N. 2005. Disjunctive temporal planning with uncertainty. In International Joint Conference on Artificial Intelligence (IJCAI-05), 1721–1722.
  • Venable et al. [2010] Venable, K. B.; Volpato, M.; Peintner, B.; and Yorke-Smith, N. 2010. Weak and dynamic controllability of temporal problems with disjunctions and uncertainty. In Workshop on Constraint Satisfaction Techniques for Planning & Scheduling, 50–59.
  • Vidal and Fargier [1999] Vidal, T., and Fargier, H. 1999. Handling contingency in temporal constraint networks: from consistency to controllabilities. Journal of Experimental & Theoretical Artificial Intelligence 11(1):23–45.
  • Yu and Williams [2013] Yu, P., and Williams, B. C. 2013. Continuously relaxing over-constrained conditional temporal problems through generalized conflict learning and resolution. In International Joint Conference on Artificial Intelligence (IJCAI-13), 2429–2436.
  • Zavatteri [2017] Zavatteri, M. 2017. Conditional simple temporal networks with uncertainty and decisions. In LIPIcs-Leibniz International Proceedings in Informatics, volume 90. Schloss Dagstuhl-Leibniz-Zentrum fuer Informatik.