###### Abstract
From the perspective of an application aimed at serving as a decision-support system for sizable communities such as universities or large companies, each with its own policies:  
* Modeling the policies involved capturing potentially complex interactions among time-delayed ramifications of observations;
* Histories of observations may have to be considered for each individual;
* The application needed to address a continuous stream of observations about both current moments as well as past time periods, due to testing and communication backlogs;
* Past observations may cause the withdrawal of previously held expectations, and thus have to be addressed _non-monotonically_;
* Because the system was intended to be accessed not only by administrators through their workstations but also by community members directly on their smartphones, the system had to be capable of producing a snapshot of a user's readiness state _weeks_ into the future in real time;
* Finally, the system was ultimately intended to be hosted on a large cloud infrastructure where computation may need to be moved from one node to another on very short notice. As a result, it had to be possible to conduct all computations in a stateful manner, so that the state of the computation could be saved and reloaded when execution was moved from a node to another. Consequently, there were a number of important requirements imposed on the reasoning component: the component had to be able to generate and reason about trajectories often exceeding 100 discrete time steps and expected to be 3-5 times longer after deployment; the domain involved the need to represent wall-clock time and durative aspects, either in the form of actions with duration or of (default) fluents with duration; the reasoning component had to be capable of producing a full trajectory in no more than 5 s on average. Preliminary experiments showed that single-shot computation with clingo was problematic, since the execution times for representative examples were frequently well over 5 s and in approximately 20-25% of cases were above the timeout threshold of 1 h. While the use of incremental computations to speed up the computation was attractive, it was made complicated by the fact that straightforward encodings led to the violation of the conditions of the Module Theorem, making it impossible to apply the current incremental technologies. In this paper, we report on an approach whose development was prompted by the application described above. The approach leverages incremental techniques for the computation of long (100 or more discrete time steps) trajectories of a dynamic domain in the presence of durative actions or fluents. The approach leverages an incremental, fix-point computation, which not only ensures the satisfaction of the conditions of the Module Theorem and the applicability of clingo's incremental API, but also yields substantial performance improvements over the non-incremental alternatives. In our experiments, the computations never timed out and the average time was well within the 5 s threshold even on household hardware. This confirms the exceptional capabilities of clingo's support for incremental computations and demonstrates that certain restrictions on the use of such features can be overcome with suitable representation techniques and algorithms. Specifically, the contributions of this paper are: (a) an approach for representing knowledge about the durative aspects of dynamic domains that is suitable for processing with incremental techniques; (b) a set of algorithms that leverage clingo's incremental computation capabilities while avoiding problems related to the conditions of the Module Theorem and substantially improve performance compared to non-incremental approaches; (c) another set of algorithms that build upon the core ones to provide features useful for use in user-facing applications and in cloud-based execution platforms. The paper is organized as follows. We begin by providing an introduction on necessary background concepts.