TLDR
- Hybrid plans mix two kinds of change. Actions and events alter discrete facts; processes and durative actions let real-valued quantities evolve through time.
- CASP divides the labour. Answer-set rules choose a discrete history while a constraint solver supplies compatible times and numerical values.
- A state acquires duration. Every logical step has start and end times, Boolean fluents change at boundaries, and numerical fluents may flow between them.
- Exogenous change is compulsory. PDDL+ events and processes follow must semantics: when their conditions become true, a plan cannot simply decline them.
- Endpoint checks need validation. A candidate may satisfy sampled constraints yet violate an invariant between samples, so VAL detects the miss and the encoding is expanded.
A planner must choose actions while the represented world keeps moving
Classical planning advances through symbolic states. PDDL+ adds real time, numerical trajectories, persistent processes and forced events. A useful plan must therefore coordinate intentional choices with dynamics that are not choices.
A classical operator may say that loading a parcel makes loaded true. The change is discrete and attributed to an action under the planner’s control. A hybrid domain also describes fuel draining, temperature rising, a vehicle accelerating or liquid flowing. Those values evolve during an interval, even when the planner schedules no new action. The modelling problem is no longer a sequence of snapshots alone; it is a sequence of snapshots connected by continuous motion.
PDDL+ organises that mixture through instantaneous actions, durative actions, processes and events. Actions are controllable. An event represents exogenous discrete change and fires as soon as its preconditions hold. A process produces continuous change while its preconditions remain true. A durative action has start, invariant and end conditions, start and end effects, and possibly continuous effects. Plans list the controllable actions as triples of start time, action and duration; processes and events do not appear as voluntary entries.
The paper asks whether this language can be handled by constraint answer-set programming, or CASP. Answer-set programming is suited to combinatorial choice, defaults, inertia and non-monotonic rules. Constraint programming is suited to real-valued equations and inequalities. CASP connects the two: an answer set identifies a collection of numerical constraints, and a compatible assignment must satisfy them.
This division is attractive because hybrid planning itself has a similar seam. The discrete side asks which actions occur, which propositions hold and which processes are active. The continuous side asks whether start times, end times and numerical trajectories can coexist. The paper does not claim that the seam makes hybrid planning easy. It gives a formal encoding and an implemented case study showing that the two reasoning styles can cooperate.
Worked example 1 · refuelling while fuel drains
A generator consumes one unit of fuel per second while a refuelling action adds fuel. The planner chooses when refuelling starts and ends. The generator process is not optional: while its conditions hold, its negative contribution accumulates. A valid solution needs both a logical schedule and numerical values proving that fuel never violates its invariant.
Causal probe 1 · why not sample the world as ordinary states?
Sampling alone can conceal a violation between samples. Two legal endpoint values do not prove that a non-linear trajectory stayed within a bound. PDDL+ semantics concerns the interval; the encoding therefore needs a validation stage beyond its initial discrete checks.
An answer set chooses a structure; a numerical assignment makes it feasible
CASP is not ASP with arithmetic decoration. Its solution has two linked components: a stable answer set and a constraint assignment satisfying precisely the numerical constraints selected by that answer set.
The paper first recalls answer-set semantics. Rules may include classical negation and default negation. A candidate set determines a reduct: rules defeated by default-negated literals are removed, remaining default negations disappear, and the candidate must be a minimal closed set of the resulting definite programme. This gives ASP its non-monotonic character. Choice rules compactly express bounded selections, while denials exclude combinations whose bodies hold.
Constraint programming begins from variables, domains and constraints. A solution assigns each variable a value from its domain and satisfies every constraint. CASP joins the systems by permitting numerical constraints in rule heads. A mapping τ replaces each numerical constraint with a legal ASP atom. The ASP solver can then reason about whether the atom belongs in an answer set, without itself solving the equation.
For an answer set A, γ(A) selects the atoms that denote numerical constraints, and τ⁻¹ maps them back. A CASP solution is a pair ⟨A, α⟩: A is an answer set of the translated programme τ(Π), and α solves the constraint set denoted by A. Neither half suffices alone. A stable discrete story might demand inconsistent times; feasible numbers might correspond to no stable logical history.
This matters for explanation. An atom such as occurs(drop(ball),2) belongs to the combinatorial account. A requirement such as height at the end of step 2 > 0 belongs to the numerical account activated by that atom. The answer-set component says which requirements apply; the constraint component says whether there is a real-valued witness.
Worked example 2 · one chosen action activates one inequality
Suppose dropping the ball is permitted only above ground. If the answer set includes occurs(drop,2), the encoding also selects v_final(height,2) > 0. A candidate with height zero is rejected by the numerical solver even if its action atoms are otherwise stable.
Causal probe 2 · which solver is responsible for causality?
Neither component monopolises it. Rules connect actions, fluents and constraints; stable-model semantics selects a supported discrete history; the constraint solver witnesses its numeric consistency. The translation establishes the causal organisation that both engines enforce.
The translation gives every symbolic state a beginning, an end and room for flow
The key representational move is to keep integer planning steps while attaching global real times to their boundaries. A discrete index orders happenings; an interval between its times carries continuous evolution.
At step i, numerical variables tstart(i) and tend(i) mark the interval. A Boolean fluent f is represented by holds(f,i) or its classical negation. A numerical fluent n has two values, v_initial(n,i) and v_final(n,i). The occurrence of action a at the end of the interval is represented by occurs(a,i). The next state begins where the previous one ends: both global time and fluent values propagate across adjacent boundaries.
This representation deliberately treats Boolean and numerical change differently. Boolean fluents remain fixed while time flows within a state and change at transitions. Numerical fluents may differ between the beginning and end. An instantaneous action occurs at the global time identified with the end of its current state. That convention lets a finite sequence of indexed steps describe a schedule over real time.
Preconditions on Boolean fluents become denials: an action and a contradicting condition may not coexist. Numerical preconditions become constraints activated by the action occurrence. Boolean effects derive holds literals at the next step. A numerical assignment effect constrains the next state’s initial value. Increase and decrease effects are represented through separate contribution variables rather than silently overwriting one another.
States having duration is an encoding device, not a claim that the world truly changes only at integer indices. Global time stays real-valued. The indices partition a candidate trajectory into intervals around action boundaries and relevant checks. This separation between sequence position and clock time is what permits ASP grounding over finitely many steps while a numerical solver places those steps on a continuous axis.
Worked example 3 · the third step need not mean three seconds
Let step 2 begin at 1.4 seconds and end at 4.9 seconds. An action at step 2 occurs at 4.9, not at integer time 2. During the 3.5-second interval, a numerical fluent may follow an encoded contribution, while every Boolean fluent remains unchanged until the boundary.
Causal probe 3 · why keep discrete indices if time is real?
The index gives the logical solver a finite combinatorial skeleton: before, after, holds and occurs. The time variables let the constraint solver stretch that skeleton into a feasible schedule. Removing either organisation loses a useful form of structure.
Actions, durations, processes and events become different patterns of rules and constraints
The translation is compositional enough to expose the distinct obligations of each PDDL+ construct. Controlled actions may be chosen; duration must connect a start with an end; processes and events must occur when enabled.
An instantaneous action is the simplest case. Boolean preconditions rule out occurrences in incompatible states. Numerical preconditions activate inequalities over the current interval’s final values. Its Boolean effects derive facts for the next state; a direct numerical effect constrains that next state’s initial value. Inertia carries unaffected Boolean and numerical fluents across boundaries.
A durative action d becomes start(d) and end(d). Start conditions and effects attach to the first action; end conditions and effects attach to the second. Starting makes inprogr(d) true, and overall conditions constrain every encoded interval while it remains true. A rule ensures that exactly one later end follows a start. If duration is δ, then the end boundary time minus the recorded start time must equal δ.
Continuous effects operate through contributions. If refuelling raises fuel at one unit per second, its contribution during interval i equals tend(i) − tstart(i) whenever refuelling is in progress. Multiple sources contribute separately and are summed into the final value. A default rule keeps a numerical fluent unchanged when no active source makes it abnormal; separate defaults set inactive contributions to zero.
Processes resemble durative actions and events resemble instantaneous actions, but the triggering rule changes. PDDL+ gives them must semantics. Once Boolean preconditions hold, the encoding chooses either to start the process or to identify a false numerical precondition. The latter alternative is legitimate only when a corresponding constraint proves that condition false. Thus the programme may not evade an enabled process by mere non-selection.
Worked example 4 · a fall cannot be declined
If a ball is not held and its height is positive, falling must begin. The answer-set programme may include start(falling), or claim that height > 0 is false. The numerical solver accepts the second branch only with height ≤ 0. When height is 3, falling is forced.
Causal probe 4 · why introduce “is_false” atoms?
ASP cannot directly infer the truth of an arbitrary numerical comparison. The auxiliary atom gives the logical search an explicit branch, while a numerical constraint certifies that branch. It preserves must semantics across the solver boundary.
Continuous change is assembled from named sources instead of hidden updates
The encoding treats each increase or decrease as a contribution from a source. The final value is the initial value plus the sum of active contributions, making simultaneous influences explicit.
For numerical fluent n, source s and step i, v(contrib(n,s),i) denotes how much s changes n during the interval. An active refuelling action may contribute a positive duration-scaled amount. A generator process may contribute a negative amount. The general update sums every relevant source. This avoids making effect order decide the result and gives the numerical solver one combined equation.
Default persistence requires care. If no continuous source changes a fluent, its final value equals its initial value. The paper represents exceptions with an ab atom: active processes or durative actions make the fluent abnormal for the interval and block simple persistence. Contributions themselves default to zero when inactive. The two defaults separate “nothing changes this fluent” from “this particular source contributes nothing”.
Non-linear change can be expressed because the numerical terms need not be linear. The generator benchmark uses Torricelli’s law, where flow velocity depends on the square root of liquid height. That ability distinguishes the case study from encodings restricted to linear dynamics, although it also makes the choice and performance of the underlying numerical solver consequential.
Multiple intervals can represent one long action. A start time is recorded when the action begins; every in-progress interval receives its continuous contribution; the end occurrence must satisfy the specified duration. For repeated instances of the same durative action, the paper notes that an additional start-time argument can distinguish independent copies.
Worked example 5 · two sources share one fuel equation
Fuel begins at 8. During a two-second interval, refuelling adds 3 units per second and generation removes 1. The source contributions are +6 and −2. The final value is 8 + 6 − 2 = 12. Neither source overwrites the other, and their simultaneous effect remains inspectable.
Causal probe 5 · why is source identity useful?
It preserves modularity. Adding a leak introduces another contribution rather than rewriting every existing update. It also lets rules activate or default each source independently before the constraint solver adds them.
An event is exogenous because the model forbids the planner from postponing it
The crucial distinction is not whether an event was predicted. It is whether the planner controls its occurrence. Under must semantics, truth of the enabling conditions determines the trigger.
Ordinary action choice says that an applicable action may occur. Process and event choice cannot mean the same thing. If a pressure-relief event is enabled at a threshold, a plan that simply omits it would describe a world different from the domain. The encoding therefore couples a choice rule to certificates for false numerical conditions. When every enabling condition is true, all escape certificates become inconsistent and the start or event atom is forced.
Timing matters. “As soon as” is stronger than “at some later step”. A discretised encoding recognises relevant happenings at state boundaries. It must ensure that an enabled autonomous change is represented at the boundary where its preconditions become true, and validation must protect the continuous interval against a threshold crossed between encoded points.
The generator experiments illustrate the computational cost of compulsory behaviour. One encoding-level heuristic observes syntactically that the generate process must begin at time zero and asserts that start immediately. A further, domain-independent estimator sometimes avoids a constraint-solver call by deriving numerical estimates. The heuristic variant often performed best, while the estimator’s benefit varied. This is evidence about particular encodings and solvers, not a universal ranking of reasoning styles.
Must semantics also clarifies agency. A plan includes chosen actions, but the resulting trajectory includes more than chosen consequences. Continuous processes and events impose transitions the agent must anticipate. Planning competence therefore includes predicting and accommodating autonomous dynamics, not treating every future occurrence as an intention.
Worked example 6 · a relief valve at pressure ten
Pressure rises at two units per second from four. The threshold ten is reached after three seconds. If the event condition is pressure ≥ 10, a candidate that delays relief until second four violates must semantics. The trigger time is dictated by the trajectory, not selected for convenience.
Causal probe 6 · does “must” mean deterministic outcome?
No. It fixes the obligation to trigger when conditions hold. The subsequent world can still involve alternative actions, interacting events or multiple feasible numeric assignments. Compulsory occurrence is not complete determinism.
A candidate trajectory is provisional until its continuous invariants survive validation
Checking an invariant only at the beginning and end of an interval is insufficient in general. The extended EZCSP architecture sends each candidate plan to VAL and repairs the encoding at any detected violation time.
The base translation checks invariants at discretised timepoints: the beginnings and ends of encoded states in which a durative action or process is active. That can be complete for some simple trajectories, but non-linear change may leave and re-enter the legal region between endpoints. The paper is explicit that soundness relies on a discretise-and-validate strategy rather than endpoint checks alone.
EZCSP operates iteratively. A grounding tool produces the ground programme. An ASP solver finds a candidate answer set. A constraint translator and numerical solver test the selected constraint problem. If that succeeds, a plan extractor reconstructs PDDL+ action times and durations. The added validation module asks VAL whether that candidate is valid under the continuous domain semantics.
If VAL reports an invariant violation and its timepoint, a plan expander adds numerical variables for the involved fluents at that time and constraints enforcing the invariant there. The constraint problem is solved again. The paper notes that only the CSP solutions need recomputation after this expansion. The loop continues until no invariant is violated. The benchmark plans happened not to trigger expansion because VAL found all of them valid; the mechanism is nevertheless part of the soundness account.
Validation is not cosmetic post-processing. It can reject a discrete structure whose endpoints look feasible. Nor is refinement merely “use a finer grid everywhere”. It inserts information at the witnessed violation, preserving the original finite model where it was adequate. The approach resembles counterexample-guided refinement: a checker exposes exactly where an abstraction was too coarse, and the next solve blocks that missed behaviour.
Worked example 7 · legal endpoints, illegal middle
Let x(t)=4t(2−t) over t∈[0,2], with invariant x≤3. The encoded endpoints are both zero and pass. The maximum occurs at t=1, where x=4. A continuous validator rejects the candidate; adding t=1 to the encoding makes the violation visible to the next solve.
Causal probe 7 · why not trust the constraint solver?
The solver can perfectly satisfy the constraints it receives. The problem is representational omission: the initial encoding may not include every interior invariant obligation. Validation checks the richer semantics, then turns a discovered omission into a new constraint.
Can the sampled plan survive the interval?
Choose a trajectory and an initial sampling policy. The laboratory separates the sampled CASP check from an exact teaching validator, then shows the refinement point or compulsory event implied by the trajectory.
A small choice rule changes the translated model from description into search
After encoding domain and problem, the planning module permits actions and durative starts at bounded discrete steps. Solutions then correspond to plans up to that maximum step.
The domain translation describes what occurrences would imply. Initial-state rules set Boolean and numerical values at step zero. Goal denials and constraints require the destination. A planning module supplies the generative choice: any instantaneous action or durative-action start may occur at a step. For a fixed maximum step, the paper states a one-to-one correspondence between plans and CASP solutions of the instance encoding plus this module.
A plan is recovered from occurs(a,i) atoms and the numerical assignments to start and end variables. Interfering actions must respect ε-separation: a positive time distance: and this is handled by post-processing following the cited UPMurphi approach. The bounded step count is a logical horizon, while real time within those steps remains determined by constraints.
Modularity is one motivation for using rules. The domain encoding need not be rewritten when the reasoning task changes. Replace the planning module and the same representation could support a hybrid of diagnosis and planning, asking which actions and hidden explanations jointly account for observations. The conclusion also identifies uncertainty about initial situations or action effects as future expansion, not a result already established.
Elaboration tolerance competes with raw performance. The authors say their EZCSP encoding was designed for clarity and elaboration tolerance rather than speed. That design supports changes local to rules, but the experiments also expose missing optimisations such as incremental grounding and multithreading. A modular representation creates opportunities; it does not erase solver architecture.
Worked example 8 · switch from planning to diagnosis
A translated generator model already describes actions, processes, events and observations. A planning module guesses controlled actions leading to a goal. A diagnostic module could instead guess a component fault that explains an unexpected fuel trace. The physical rules stay shared; the query layer changes.
Causal probe 8 · does one-to-one correspondence guarantee practical search?
No. It is a semantic result for a bounded horizon. Grounding size, solver branching, nonlinear feasibility and repeated horizons determine practical cost. Correct representability and efficient discovery are different achievements.
The case study demonstrates viability, not a universal performance victory
The reported evaluation uses generator and car benchmarks, linear and non-linear variants, several EZCSP encodings and three comparison planners. Its strongest lesson is conditional.
The experiments ran on one core of an Intel i7-4790K at 4.00 GHz inside a VMware Workstation 12 virtual machine with Fedora 22. EZCSP 1.7.4 used gringo 3.0.5, clasp 3.1.3, B-Prolog 7.5 for linear constraints and GAMS 24.5.7 for non-linear problems. The comparison systems were dReal 2.15.11, UPMurphi 3.0.2 and the public SMTPlan+ version of 7 July 2016. A dash marks the 600-second timeout; an asterisk marks a free-GAMS size limit.
Fixed-step comparison with dReal and cumulative-horizon comparison with UPMurphi and SMTPlan+ answer different timing questions. In the car linear fixed-step table, EZCSP remains near 0.3 seconds while dReal is around 1.1 seconds. In the non-linear car cases, dReal times out after two instances while EZCSP solves all eight reported cases. Yet on cumulative car results, UPMurphi is faster for the linear cases, and SMTPlan+ is faster throughout.
Generator performance depends on encoding. The simple must-semantics heuristic often improves results substantially; the estimator sometimes helps the harder non-linear cases but times out on later cumulative instances. The paper reports that SMTPlan+ outperforms EZCSP by roughly two orders of magnitude in generator comparisons and solves one additional non-linear instance. All generated benchmark plans passed VAL without invoking expansion.
These outcomes support the claim that a CASP route can handle full-featured PDDL+ examples, including non-linear processes and events, and can outperform some contemporary systems on portions of the selected benchmark. They do not isolate language, encoding, grounding, ASP solving, numerical back end and implementation quality. The authors explicitly leave a thorough comparison with SMTPlan+ for future work and name incremental grounding, multithreading and numerical solver choice as possible factors.
Evidence boundary
Two domains, eight scaled instances per variant, a historical software stack and non-identical comparison protocols do not establish present-day general superiority. “Promising” is the defensible summary. Exact times belong to these encodings, limits and machines.
Worked example 9 · the same table supports opposite local rankings
On cumulative linear car instances, UPMurphi’s roughly 0.4 seconds beats EZCSP’s roughly 0.8–1.0. On the non-linear car series, UPMurphi solves only the first at 184.88 seconds while EZCSP solves all eight in 1.06–2.32. “Planner A is faster” is underspecified without domain and regime.
Causal probe 9 · did validation cause the reported runtimes?
The architecture called VAL, but none of these plans required expansion. The tables therefore do not measure repeated refinement behaviour. They measure the full implementation on candidates that validation accepted.
| Comparison slice | Observed result | Safe interpretation |
|---|---|---|
| Car, fixed step, linear | EZCSP about 0.30–0.32 s; dReal about 1.11–1.19 s | EZCSP faster on these eight fixed-horizon instances. |
| Car, cumulative, linear | UPMurphi about 0.38–0.41 s; EZCSP about 0.83–1.04 s | UPMurphi faster in this easier regime. |
| Car, cumulative, non-linear | EZCSP 1.06–2.32 s; UPMurphi solves one at 184.88 s | EZCSP scales much better on this reported series. |
| Generator, cumulative | SMTPlan+ leads every listed series | CASP viability did not equal best performance. |
Translation makes solver boundaries visible: and therefore improvable
The paper’s enduring contribution is an architecture for mixed reasoning: rules generate and explain a discrete skeleton, constraints fill its continuous geometry, and semantic validation guards the abstraction boundary.
The approach handles numerical constraints, processes, events, durative actions and non-linear terms in the represented benchmark domains. It does not provide a single standard semantics for all CASP languages; instead, the paper gives a simplified definition capturing common traits, then specialises the case study to EZCSP. Porting the encoding requires attention to how another CASP system represents constraint atoms, grounds programmes and communicates with numerical solvers.
Soundness depends on the loop, not just the first encoding. Endpoint invariant checks form an abstraction of continuous behaviour. VAL supplies the semantic oracle for candidate PDDL+ plans. A violation causes focused expansion. If one reports only “ASP plus constraints”, one omits the mechanism that protects against the most instructive continuous-time error.
Efficiency depends on multiple interfaces. Grounding can dominate a rule system; numeric feasibility can dominate a non-linear model; a weak encoding can make must semantics branch unnecessarily; repeated horizons can redo work; and validation can demand refinement. The paper’s discussion of incremental grounding and multithreading recognises that the logical formalism and the implemented architecture should be evaluated separately.
For agency, the model offers a useful conceptual discipline. Some changes are selected, some are enabled and compulsory, some persist continuously, and all must coexist in one trajectory. The plan is an intervention schedule, not a complete narration of the future. A competent agent models what the world will do between its actions and validates that its finite representation has not hidden a forbidden interval.
Worked example 10 · a plan that reaches the goal but is still invalid
A heating plan begins and ends below a safety limit and reaches the desired final temperature after cooling. If temperature overshoots between those points, the goal state does not rescue the plan. Validation rejects a trajectory whose path is unsafe even when its destination is correct.
Causal probe 10 · what is the general lesson beyond PDDL+?
Whenever a finite symbolic model abstracts a richer process, solver success certifies only the encoded obligations. A separate semantic check: and a way to feed counterexamples back: can turn that limitation into an iterative reasoning architecture.
Twelve retrieval hooks
Scholarly and publication gates
Review A · fidelity, teaching and evidential fairness
The companion was checked against all 12 pages of arXiv:1609.00030v1: PDDL+ planning-instance and plan definitions; ASP reduct and answer-set preliminaries; CSP and the paper’s simplified CASP semantics; global time and step boundaries; Boolean and numerical fluent representation; additive contributions; instantaneous and durative action encoding; processes, events and must semantics; inertia and propagation; the planning module and ε-separation; the EZCSP specialisation; validation and expansion; generator and car experiments; solver versions, machine, timeout and GAMS limit; related work; limitations and future directions.
Fidelity review passed. Actions are kept distinct from processes and events. CASP is presented as a pair of linked semantic obligations, not a vague solver blend. Non-linear support is not equated with exact continuous proof by the initial sampling. Soundness is attached to discretise-and-validate. The claim that plans correspond to solutions is scoped to a maximum discrete time step. Benchmark claims distinguish fixed-step from cumulative timings and preserve SMTPlan+’s advantage. The laboratory is explicitly a reconstruction, not EZCSP or VAL.
Teaching review passed. Ten worked examples and ten causal probes cover controlled versus autonomous change, linked logical and numerical feasibility, real time inside discrete indices, construct-specific translation, additive effects, forced triggering, hidden invariant violations, query modularity, conditional benchmark rankings and path safety. Ten diagrams reconstruct different mechanisms. The executable laboratory makes the paper’s key soundness boundary observable.
Review B · language, accessibility, responsive layout and execution
The prose was reviewed for benchmark hype, solver anthropomorphism, unearned causal claims, vague authority, retrospective terminology and repetitive AI-telltale phrasing. British English is consistent. Every SVG has a unique title, description, caption and provenance note; text, geometry and ordering carry meaning independently of colour. Motion stops under reduced-motion preferences. The page supplies a skip link, ordered headings, native labelled controls, a live trajectory region and explicit table headers.
Responsive review covers 1440, 768 and 390 pixels. The hero, exactly five orientation cards, prose columns, ten figures, experiment ledger, three-control laboratory, memory studio and sequence navigation collapse without viewport overflow; the evidence table scrolls independently where needed. Executable review has three exact gates: endpoint sampling must miss but validation must detect the non-linear peak at t=1; refinement must insert that point and make the sampled check reject it; and a threshold event must be scheduled at its first enabling time rather than a delayed alternative.
From reusable bounded search to rules for a continuously changing world
Paper 0105 used tabled logic programming to reuse answers and failed budgets in a discrete state graph. Paper 0106 keeps a finite logical skeleton but stretches every state across real time. The memory of search gives way to a translation boundary: answer sets organise happenings, constraint assignments organise trajectories, and validation checks what the discretisation omitted.
Paper 0107 turns to Borgwardt, Hoffmann, Kovtunova, Krötzsch, Nebel and Steinmetz on the expressivity of planning with Horn description-logic ontologies. The canon will move from numerical hybrid dynamics to semantic background knowledge, asking how ontology-mediated conditions alter what a planning formalism can express.
Sources and audit trail
- Balduccini, M., Magazzeni, D., & Maratea, M. (2016). “PDDL+ Planning via Constraint Answer Set Programming.” arXiv:1609.00030. Primary source.
- Fox, M., & Long, D. (2006). “Modelling Mixed Discrete-Continuous Domains for Planning.” Journal of Artificial Intelligence Research, 27, 235–297. PDDL+ syntax and hybrid-automata semantics.
- Lierler, Y. (2014). “Relating Constraint Answer Set Programming Languages and Algorithms.” Artificial Intelligence, 207, 1–22. CASP language and solver context.
- Cashmore, M., Fox, M., Long, D., & Magazzeni, D. (2016). “A Compilation of the Full PDDL+ Language into SMT.” ICAPS. SMTPlan+ comparison.
- Bryce, D., Gao, S., Musliner, D. J., & Goldman, R. P. (2015). “SMT-Based Nonlinear PDDL+ Planning.” AAAI. dReal comparison and benchmark protocol.
- Della Penna, G., Magazzeni, D., Mercorio, F., & Intrigila, B. (2009). “UPMurphi: A Tool for Universal Planning on PDDL+ Problems.” ICAPS. Model-checking comparison and validation context.
- Shin, J.-A., & Davis, E. (2005). “Processes and Continuous Change in a SAT-Based Planner.” Artificial Intelligence, 166(1–2), 194–253. TM-LPSAT antecedent for linear change.
- Bogomolov, S., Magazzeni, D., Podelski, A., & Wehrle, M. (2014). “Planning as Model Checking in Hybrid Domains.” AAAI. Hybrid model-checking context.
What ships with Paper 0106
Title: When time flows inside a logical state: Balduccini, Magazzeni and Maratea’s PDDL+–CASP translation. Standfirst: A visual and executable reconstruction of PDDL+ hybrid planning, CASP solution pairs, real time within indexed states, durative actions, additive contributions, must-trigger processes and events, and solver-guided invariant refinement. Search terms: PDDL+, constraint answer set programming, CASP, EZCSP, hybrid planning, must semantics, continuous process, discretise and validate, VAL. Demonstration: a trajectory laboratory contrasting sampled feasibility, continuous validation, targeted refinement and compulsory event timing. Accessibility promise: ten titled and described SVG figures, reduced-motion support, labelled native controls, keyboard operation and responsive layouts.