Complexity of Classical Planning - Automated Planning - Lecture Slides, Slides of Computer Science

Download Complexity of Classical Planning - Automated Planning - Lecture Slides and more Slides Computer Science in PDF only on Docsity!

Lecture slides for

Automated Planning: Theory and Practice

Chapter 3

Complexity of Classical Planning

Motivation

• Recall that in classical planning, even simple problems can have huge search spaces - Example: - DWR with five locations, three piles, three robots, 100 containers - 10 277 states - About 10 190 times as many states as there are particles in universe
• How difficult is it to solve classical planning problems?
• The answer depends on which representation scheme we use
  • Classical, set-theoretic, state-variable

location 1 location 2

s 0

Complexity Analysis

• Complexity analyses are done on decision problems or language- recognition problems - Problems that have yes-or-no answers
• A language is a set L of strings over some alphabet A
  • Recognition procedure for L
    • A procedure R ( x ) that returns “yes” iff the string x is in L
    • If x is not in L , then R ( x ) may return “no” or may fail to terminate
• Translate classical planning into a language-recognition problem
• Examine the language-recognition problem’s complexity

Planning as a Language-Recognition

Problem

• Consider the following two languages:

PLAN-EXISTENCE = { P : P is the statement of a planning problem that has a solution}

PLAN-LENGTH = {( P,n ) : P is the statement of a planning problem that has a solution of length ≤ n }

• Look at complexity of recognizing PLAN-EXISTENCE and PLAN-LENGTH under different conditions - Classical, set-theoretic, and state-variable representations - Various restrictions and extensions on the kinds of operators we allow

Complexity Classes

• Complexity classes:
  • NLOGSPACE (nondeterministic procedure, logarithmic space) ⊆ P (deterministic procedure, polynomial time) ⊆ NP (nondeterministic procedure, polynomial time) ⊆ PSPACE (deterministic procedure, polynomial space) ⊆ EXPTIME (deterministic procedure, exponential time) ⊆ NEXPTIME (nondeterministic procedure, exponential time) ⊆ EXPSPACE (deterministic procedure, exponential space)
• Let C be a complexity class and L be a language
  • L is C -hard if for every language L' ∈ C , L' can be reduced to L in a polynomial amount of time - NP-hard, PSPACE-hard, etc.
  • L is C -complete if L is C -hard and L ∈ C
    • NP-complete, PSPACE-complete, etc.

Possible Conditions

• Do we give the operators as input to the planning algorithm, or fix them in advance?
• Do we allow infinite initial states?
• Do we allow function symbols?
• Do we allow negative effects?
• Do we allow negative preconditions?
• Do we allow more than one precondition?
• Do we allow operators to have conditional effects?*
  • i.e., effects that only occur when additional preconditions are true

These take us outside classical planning

α (^) no operator has

1 precondition

γ (^) PSPACE-complete or NP-complete for some sets of operators

 In this case, can write domain-specific algorithms  e.g., DWR and Blocks World: PLAN-EXISTENCE is in P and PLAN-LENGTH is NP-complete

• PLAN-LENGTH is never worse than NEXPTIME-complete
  • We can cut off every search path at depth n

Here , PLAN-LENGTH is harder than PLAN-EXISTENCE

State-Variable Representation

• Classical and state-variable representations are equivalent, except that some of the restrictions aren’t possible in state-variable representations - e.g., classical translation of pos(a) ← b - precondition on(a, x ) - two effects, one is negative ¬on(a, x ), on(a,b)

Like classical rep, but fewer lines in the table

Summary

• If classical planning is extended to allow function symbols
  • Then we can encode arbitrary computations as planning problems
    • Plan existence is semidecidable
    • Plan length is decidable
• Ordinary classical planning is quite complex
  • Plan existence is EXPSPACE-complete
  • Plan length is NEXPTIME-complete
  • But those are worst case results
    • If we can write domain-specific algorithms, most well-known planning problems are much easier