The shop3 Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The shop3 Reference Manual

This is the shop3 Reference Manual, version 3.4.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 17:46:04 2021 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

SHOP3 logo

SHOP3

This repository contains the open source version of the SHOP3 planner.

License

Mozilla Public License

Installation Instructions

Common Lisp

SHOP3 is written in Common Lisp (CL), and requires a CL implementation to run. We recommend one of the following implementations:

We regularly test SHOP3 on all of these lisp implementations, using an exhaustive test suite. There are at least a handful of other CL implementations, both open source and commercial, but we have not tested them with SHOP3. Attempts to run SHOP3 on ECL, ABCL, and clisp have not been successful. Patches to make SHOP3 work with other implementations are welcomed, but we have no plans to add support to any others ourselves.

Note that we have not tested SHOP3 on the free versions of ACL or LispWorks, and we do not expect it to work well on these platforms because of their resource limitations. For hobbyist projects, we suggest SBCL or CCL instead.

Obtaining the code

Clone this repository and then initialize and populate the submodules.

git clone https://github.com/shop-planner/shop3

See the two installation options below to see whether you need to supply the --recurse-submodules option when cloning.

Once you have done that, you can get SHOP3 started either using Quicklisp (probably easiest) or by configuring ASDF (the Common Lisp build manager) yourself. See below.

Option 1: Quicklisp

Probably the easiest way to work with SHOP3 will be to use it in conjunction with Quicklisp. Quicklisp is a package manager for CL libraries, and will be the easiest way to get the libraries that SHOP3 depends on.

If you wish to use Quicklisp, follow the installation instructions for quicklisp at the above site, and then clone the SHOP3 repository into the local-projects subdirectory of your Quicklisp install directory. Once this is done, you should be able to:

  1. Start CL
  2. Inside CL, enable Quicklisp
  3. Enter (ql:quickload "shop3") into the CL REPL.

Quicklisp contains all of the dependencies that SHOP3 requires except the "pddl-utils" system. This system is only used in the tests, or for some optional functionality. If you wish to have this subsystem, you can either;

  1. populate the git submodules -- or just the pddl-tools one -- in the SHOP3 git repository, OR
  2. Clone the pddl-tools repository into local-projects, as well, and do not bother with the git submodules.

Note: At the moment, SHOP3 is not available for installation through Quicklisp, but we have requested that it be added to the distribution, and hope it will be. If it is, we will update the README accordingly, and installation will become much simpler.

Option 2: Without Quicklisp

The SHOP3 repository has links to all of the libraries it requires in its git submodules. If Quicklisp is not the right approach for you, you must use git commands to populate SHOP3's submodules (if you like, you may clone with the --recurse-submodules option), and then:

  1. Start CL
  2. Load the ASDF CL build system by doing (require :asdf) in the CL REPL.
  3. Tell ASDF where to find SHOP3:
    (asdf:initialize-source-registry
             '(:source-registry (:tree SHOP3-DIRECTORY) :inherit-configuration)
    
    Fill in the name of the directory of your cloned repository for SHOP3-DIRECTORY.
  4. Enter (asdf:load-system "shop3") into the CL REPL.

Once started

We suggest that you interact with SHOP3 through the shop-user package in the REPL.

The best environment for working with CL for any purpose, including SHOP3 planning, is through the Superior Lisp Interaction Mode for Emacs, or SLIME. If you use ACL, Franz have their own Emacs Lisp Interface (ELI) as a possible alternative. Both ACL and CCL have some sort of GUI, as well.

Using SHOP3

See the user manual in the docs directory of the repository. Building the manual requires having texinfo, and SBCL installed, and benefits from having tex/latex installed. To build, change to the docs directory and do make html if you have only makeinfo installed, or just make if you have tex/latex, as well. This will produce the manual in HTML, Emacs info, and PDF formats.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Next: , Previous: , Up: Systems   [Contents][Index]

2.1 shop3

License

Mozilla Public License

Version

3.4.0

Dependencies
Source

shop3.asd (file)

Components

Next: , Previous: , Up: Systems   [Contents][Index]

2.2 shop3/theorem-prover

License

Mozilla Public License

Version

3.4.0

Dependencies
Source

shop3.asd (file)

Components

Next: , Previous: , Up: Systems   [Contents][Index]

2.3 shop3/common

License

Mozilla Public License

Version

3.4.0

Dependencies
Source

shop3.asd (file)

Components

Previous: , Up: Systems   [Contents][Index]

2.4 shop3/unifier

License

Mozilla Public License

Version

3.4.0

Source

shop3.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 shop3/io

Dependency

decls.lisp (file)

Parent

shop3 (system)

Location

io/

Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.2 shop3/pddl

Dependency

io (module)

Parent

shop3 (system)

Location

pddl/

Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.3 shop3/search

Dependency

pddl (module)

Parent

shop3 (system)

Location

planning-engine/

Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.4 shop3/explicit-stack-search

Dependency

search (module)

Parent

shop3 (system)

Location

explicit-stack-search/

Components

Next: , Previous: , Up: Modules   [Contents][Index]

3.5 shop3/looping-tasks

Dependency

explicit-stack-search (module)

Parent

shop3 (system)

Location

looping-tasks/

Component

loop-extensions.lisp (file)


Next: , Previous: , Up: Modules   [Contents][Index]

3.6 shop3/tree

Dependency

looping-tasks (module)

Parent

shop3 (system)

Location

planning-tree/

Components

Previous: , Up: Modules   [Contents][Index]

3.7 shop3/minimal-subtree

Description

When there’s an upset in plan execution, find a minimal affected subtree.

Dependency

tree (module)

Parent

shop3 (system)

Location

minimal-subtree/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 shop3.asd

Location

shop3.asd

Systems
Packages

shop-asd

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 shop3/package.lisp

Parent

shop3 (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 shop3/decls.lisp

Dependency

package.lisp (file)

Parent

shop3 (system)

Location

decls.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 shop3/io/input.lisp

Parent

io (module)

Location

io/input.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 shop3/io/output.lisp

Parent

io (module)

Location

io/output.lisp

Exported Definitions

print-current-state (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 shop3/io/debugging.lisp

Parent

io (module)

Location

io/debugging.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 shop3/io/shop-pprint.lisp

Parent

io (module)

Location

io/shop-pprint.lisp

Packages

shop3-pprint

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 shop3/pddl/decls.lisp

Parent

pddl (module)

Location

pddl/decls.lisp

Internal Definitions

+pddl-requirements-keywords+ (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 shop3/pddl/fluents.lisp

Dependency

decls.lisp (file)

Parent

pddl (module)

Location

pddl/fluents.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 shop3/pddl/pddl.lisp

Dependency

fluents.lisp (file)

Parent

pddl (module)

Location

pddl/pddl.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 shop3/pddl/prover.lisp

Dependency

pddl.lisp (file)

Parent

pddl (module)

Location

pddl/prover.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 shop3/search/protections.lisp

Parent

search (module)

Location

planning-engine/protections.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 shop3/search/task-reductions.lisp

Parent

search (module)

Location

planning-engine/task-reductions.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 shop3/search/search.lisp

Parent

search (module)

Location

planning-engine/search.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 shop3/explicit-stack-search/decls.lisp

Parent

explicit-stack-search (module)

Location

explicit-stack-search/decls.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 shop3/explicit-stack-search/plan-tree.lisp

Dependency

decls.lisp (file)

Parent

explicit-stack-search (module)

Location

explicit-stack-search/plan-tree.lisp

Packages

plan-tree

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.17 shop3/explicit-stack-search/backtrack-stack.lisp

Dependency

plan-tree.lisp (file)

Parent

explicit-stack-search (module)

Location

explicit-stack-search/backtrack-stack.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.18 shop3/explicit-stack-search/explicit-search.lisp

Dependency

backtrack-stack.lisp (file)

Parent

explicit-stack-search (module)

Location

explicit-stack-search/explicit-search.lisp

Exported Definitions

find-plans-stack (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.19 shop3/looping-tasks/loop-extensions.lisp

Parent

looping-tasks (module)

Location

looping-tasks/loop-extensions.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.20 shop3/tree/tree-accessors.lisp

Parent

tree (module)

Location

planning-tree/tree-accessors.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.21 shop3/tree/tree-reductions.lisp

Parent

tree (module)

Location

planning-tree/tree-reductions.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.22 shop3/minimal-subtree/package.lisp

Parent

minimal-subtree (module)

Location

minimal-subtree/package.lisp

Packages

shop3-minimal-subtree


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.23 shop3/minimal-subtree/decls.lisp

Dependency

package.lisp (file)

Parent

minimal-subtree (module)

Location

minimal-subtree/decls.lisp

Exported Definitions

find-failed-task (generic function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.24 shop3/minimal-subtree/minimal-subtree.lisp

Dependency

decls.lisp (file)

Parent

minimal-subtree (module)

Location

minimal-subtree/minimal-subtree.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.25 shop3/plan-repair.lisp

Dependencies
Parent

shop3 (system)

Location

explicit-stack-search/plan-repair.lisp

Exported Definitions

repair-plan (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.26 shop3/shop3.lisp

Dependency

plan-repair.lisp (file)

Parent

shop3 (system)

Location

shop3.lisp

Exported Definitions

find-plans (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.27 shop3/plan-printer.lisp

Dependencies
Parent

shop3 (system)

Location

plan-printer.lisp

Exported Definitions

pprint-plan (function)

Internal Definitions

pprint-step (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.28 shop3/theorem-prover/package-thpr.lisp

Parent

shop3/theorem-prover (system)

Location

theorem-prover/package-thpr.lisp

Packages

shop3.theorem-prover


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.29 shop3/theorem-prover/decls.lisp

Dependency

package-thpr.lisp (file)

Parent

shop3/theorem-prover (system)

Location

theorem-prover/decls.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.30 shop3/theorem-prover/theorem-prover.lisp

Dependency

decls.lisp (file)

Parent

shop3/theorem-prover (system)

Location

theorem-prover/theorem-prover.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.31 shop3/common/package-common.lisp

Parent

shop3/common (system)

Location

common/package-common.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.32 shop3/common/common.lisp

Dependency

package-common.lisp (file)

Parent

shop3/common (system)

Location

common/common.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.33 shop3/common/state-decls.lisp

Dependency

common.lisp (file)

Parent

shop3/common (system)

Location

common/state-decls.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.34 shop3/common/state-utils.lisp

Dependency

state-decls.lisp (file)

Parent

shop3/common (system)

Location

common/state-utils.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.35 shop3/unifier/package-unifier.lisp

Parent

shop3/unifier (system)

Location

unification/package-unifier.lisp

Packages

shop3.unifier


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.36 shop3/unifier/tracer.lisp

Dependency

package-unifier.lisp (file)

Parent

shop3/unifier (system)

Location

unification/tracer.lisp

Exported Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.37 shop3/unifier/unify.lisp

Dependency

tracer.lisp (file)

Parent

shop3/unifier (system)

Location

unification/unify.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 shop3

Source

package.lisp (file)

Nicknames
Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 shop3-user

Source

package.lisp (file)

Nicknames
Use List

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 shop3-pprint

Source

shop-pprint.lisp (file)

Nickname

shop2-pprint

Use List
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 plan-tree

Source

plan-tree.lisp (file)

Use List
Used By List

shop3-minimal-subtree

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 shop3-minimal-subtree

Source

package.lisp (file)

Nicknames
Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.6 shop3.theorem-prover

Source

package-thpr.lisp (file)

Nicknames
Use List
Used By List

shop3

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.7 shop3.common

Source

package-common.lisp (file)

Nicknames
Use List
Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.8 %shop3-common-private%

Source

package-common.lisp (file)


Next: , Previous: , Up: Packages   [Contents][Index]

5.9 shop-asd

Source

shop3.asd

Nicknames
Use List
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.10 shop3.unifier

Source

package-unifier.lisp (file)

Nicknames
Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *attribution-list*
Package

shop3.common

Source

common.lisp (file)

Special Variable: *current-state*
Package

shop3.common

Source

common.lisp (file)

Special Variable: *defdomain-verbose*
Package

shop3

Source

input.lisp (file)

Special Variable: *define-silently*

Set to a non-nil value to suppress output messages printed when SHOP3 model components (domains, etc.) are defined. When this value is NIL, SHOP3 defaults to printing messages when it is asked to define components.

Package

shop3

Source

input.lisp (file)

Special Variable: *domain*

Default domain to use when planning.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *establishers*
Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *external-access*
Package

shop3.common

Source

common.lisp (file)

Special Variable: *inferences*
Package

shop3.common

Source

common.lisp (file)

Special Variable: *literals*
Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *make-problem-silently*

If this variable is bound to t, make-problem will NOT print a message.

Package

shop3

Source

input.lisp (file)

Special Variable: *record-dependencies-p*

Do we record dependencies when we find literals in the theorem prover. If so, see *LITERALS* and *ESTABLISHERS*.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *shop-trace*
Package

shop3.unifier

Source

tracer.lisp (file)

Special Variable: *shop-trace-stream*
Package

shop3.unifier

Source

tracer.lisp (file)

Special Variable: *state*

This special variable should be bound to the current
state inside FIND-SATISFIERS, qv., giving axioms access to the state data structure.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *state-encoding*
Package

shop3.common

Source

common.lisp (file)

Special Variable: *trace-query*
Package

shop3.unifier

Source

tracer.lisp (file)

Special Variable: *which*
Package

shop3

Source

decls.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: apply-substitution TARGET SUBSTITUTION

APPLY-SUBSTITUTION searches through TARGET, replacing each variable symbol with the corresponding value (if any) in SUBSTITUTION

Package

shop3.unifier

Source

unify.lisp (file)

Macro: call FN &rest PARAMS
Package

shop3.common

Source

decls.lisp (file)

Macro: def-logical-keyword (NAME DOMAIN-SPECIALIZER) &body FORMS

(def-logical-keyword name domain-specializer options &body forms) where forms should always include:

(:satisfier-method (goal other-goals state bindings level just1) forms)

The FORMS in the satisfier method will be wrapped in a block named :satisfier-method, in case one wishes to use a non-local exit. (return-from :satisfier-method ...) will work. The method should either fail (return NIL), or it should compute some list of binding lists
from GOAL, combine them with the input BINDINGS, and then recursively call SEEK-SATISFIERS on OTHER-GOALS, incorporating the new bindings.
The satisfier method may reference a formal named DOMAIN.

Defines a logical connective in the SHOP theorem prover.

Defines methods for REAL-SEEK-SATISFIERS-FOR and LOGICAL-KEYWORDP.

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Macro: def-problem-set LIST-NAME PROBLEM-LIST
Package

shop3

Source

input.lisp (file)

Macro: defdomain NAME-AND-OPTIONS ITEMS
Package

shop3

Source

input.lisp (file)

Macro: defproblem PROBLEM-NAME &rest ARGS

(DEFPROBLEM {<name>|<name-and-options>} <state> <tasks>) For backward compatibility, will support also (DEFPROBLEM <name> <domain-name> <state> <tasks>).

Package

shop3

Source

input.lisp (file)

Macro: shop-fail ()
Package

shop3.common

Source

common.lisp (file)

Macro: shop-trace &rest ITEMS

- (SHOP-TRACE) with no arguments will return a list of what’s
currently being traced.

- (SHOP-TRACE ITEM) will turn on tracing for ITEM.

ITEM may be any of the following:

- the name of a method, axiom, operator, task, or predicate;
- one of the keywords :METHODS, :AXIOMS, :OPERATORS, :TASKS,
:GOALS, :EFFECTS, or :PROTECTIONS, in which case SHOP will
trace all items of that type (:GOALS, :EFFECTS, and :PROTECTIONS
refer to three different ways predicates can occur: as goals to
be satisfied, and as effects or protections in operators);
- a pair of the form (:TASK <taskname>), (:METHOD <methodname>). SHOP will break when attempting to expand the task, or apply the method, respectively. - the keyword :STATES, in which case SHOP will include the current
state whenever it prints out a tracing message
- the keyword :ALL in which case SHOP will print out all the tracing information it knows how to.

- (SHOP-TRACE ITEM1 ITEM2 ...) will do the same for a list of items

Package

shop3

Source

debugging.lisp (file)

Macro: shop-untrace &rest ITEMS

(SHOP-UNTRACE ...) is the inverse of (SHOP-TRACE ...)

Package

shop3

Source

debugging.lisp (file)

Macro: trace-print TYPE ITEM STATE &rest FORMATS
Package

shop3.unifier

Source

tracer.lisp (file)

Macro: unify-fail E1 E2

It’s painful (and bug-inducing) to have to remember to compare the result of unify with ’fail.

Package

shop3.unifier

Source

unify.lisp (file)

Macro: unify-fail-p E1 E2

Better-named alias for UNIFY-FAIL.

Package

shop3.unifier

Source

unify.lisp (file)

Macro: unify-p E1 E2

It’s painful (and bug-inducing) to have to remember to compare the result of unify with ’fail. This checks to see whether E1 and E2 unify, and returns T or NIL, accordingly.

Package

shop3.unifier

Source

unify.lisp (file)

Macro: variable-p X

An alias for VARIABLEP, for more consistent naming.

Package

shop3.unifier

Source

unify.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: anonymous-var-p X

Does X name an anonymous variable?

Package

shop3.unifier

Source

unify.lisp (file)

Function: binding-list-value VAR BINDING-LIST &optional IF-NOT-FOUND

Return the value of VAR in BINDING-LISP. When there is no such value, raises an error if IF-NOT-FOUND is :ERROR, else returns the value of IF-NOT-FOUND.

Package

shop3.unifier

Source

unify.lisp (file)

Function: binding-val INSTANCE

Binding structure accessor

Package

shop3.unifier

Source

unify.lisp (file)

Writer

(setf binding-val) (function)

Function: (setf binding-val) VALUE INSTANCE
Package

shop3.unifier

Source

unify.lisp (file)

Reader

binding-val (function)

Function: binding-var INSTANCE

Binding structure accessor

Package

shop3.unifier

Source

unify.lisp (file)

Writer

(setf binding-var) (function)

Function: (setf binding-var) VALUE INSTANCE
Package

shop3.unifier

Source

unify.lisp (file)

Reader

binding-var (function)

Function: complex-node-children TREE-NODE

TREE-NODE must be a COMPLEX-NODE (cf. COMPLEX-NODE-P). Returns its children.

Package

shop3

Source

tree-accessors.lisp (file)

Writer

(setf complex-node-children) (function)

Function: (setf complex-node-children) VALUE TREE-NODE
Package

shop3

Source

tree-accessors.lisp (file)

Reader

complex-node-children (function)

Function: complex-node-p TREE-NODE

Is TREE-NODE a representation of a complex node (i.e., not an operator) in the SHOP2 tree format as described in SHOP2?

Package

shop3

Source

tree-accessors.lisp (file)

Function: complex-node-task TREE-NODE

TREE-NODE must be a COMPLEX-NODE (cf. COMPLEX-NODE-P). Returns the corresponding TASK s-expression.

Package

shop3

Source

tree-accessors.lisp (file)

Function: complex-tree-node-children INSTANCE
Function: (setf complex-tree-node-children) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: compose-substitutions SUB1 SUB2
Package

shop3.unifier

Source

unify.lisp (file)

Function: consumer INSTANCE
Function: (setf consumer) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-plan-tree TREE

Return a functional copy of TREE. By "functional" we mean satisfies the key tree property – the primitive tasks are EQ to the primitive tasks in the plan sequence – but the nodes will not be EQ to the nodes in the original tree (although they will be EQUALP.

Package

shop3

Source

tree-accessors.lisp (file)

Function: decode-tag TAG
Package

shop3.common

Source

state-utils.lisp (file)

Function: delete-domain NAME
Package

shop3

Source

input.lisp (file)

Function: delete-state-tag-decoder ()
Package

shop3.common

Source

state-utils.lisp (file)

Function: delete-tag-map TAG

Erase association of TAG with its operator/action instance.

Package

shop3.common

Source

state-utils.lisp (file)

Function: do-problems PROBLEMS &rest KEYWORDS

DO-PROBLEMS runs FIND-PLANS on each problem in PROBLEMS, which may be either a problem-set name (a symbol) or a list of problems.

Returns nothing of interest: should only be run for what it displays on the console.

Package

shop3

Source

input.lisp (file)

Function: establisher INSTANCE
Function: (setf establisher) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: explain-satisfier UNIFIED-GOAL STATE &key EXTERNAL DOMAIN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: extract-variables EXPR
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: find-all-complex-node-for-task TASK-NAME TREE

Find all complex-nodes in the TREE whose task name is TASK.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-all-complex-node-if FUN TREE

Return a complex node whose TASK (first element) satisfies FUN.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-complex-node-for-task TASK-NAME TREE

Find a complex-node in the TREE whose task name is TASK.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-complex-node-if FUN TREE-LIST &key NODE-FUN

If ‘NODE-FUN‘ is nil return a complex node whose *task* (first element) satisfies ‘FUN‘. If ‘NODE-FUN‘ is non-‘NIL‘, then return a complex node that satisfies ‘FUN‘. Takes a list of trees (list of nodes) as input. Won’t work properly on a true tree.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-domain NAME-OR-OBJ &optional IF-NOT-FOUND

Find and return a domain object with the name NAME. Will return the value in its IF-NOT-FOUND argument if no such domain is loaded. IF-NOT-FOUND defaults to :error, which will raise an error condition.

Package

shop3

Source

input.lisp (file)

Function: find-plan-step TASK PLAN-TREE &optional PLAN-TREE-HASH
Package

plan-tree

Source

plan-tree.lisp (file)

Function: find-plans PROBLEM &key DOMAIN WHICH VERBOSE GC PP PLAN-TREE OPTIMIZE-COST COLLECT-STATE TIME-LIMIT EXPLANATION DEPTH-CUTOFF STATE TASKS STATE-TYPE HAND-STEER LEASHED OUT-STREAM

FIND-PLANS looks for solutions to the planning problem named PROBLEM.
The keyword arguments are as follows:
:WHICH tells what kind of search to do. Its possible values are:
:FIRST - depth-first search, returning the first plan found.
:ALL - depth-first search for *all* plans.
:SHALLOWEST - depth-first search for the shallowest plan in the
search space (this usually is also the shortest plan).
If there’s more than one such plan, return the first. :ALL-SHALLOWEST - depth-first search for all shallowest plans.
:ID-FIRST - iterative deepening search, returning the first plan. :ID-ALL - iterative deepening search for all shallowest plans. :RANDOM - Randomized search. Used by Monroe. Not for normal
SHOP3 domains, since normal SHOP3 domains have order- dependent semantics.
:MCTS - Monte Carlo Tree Search mode (experimental and unstable). :VERBOSE says how much information to print about the plans SHOP3
finds. Its values can be any of the following:
0 or NIL - print nothing
1 or :STATS - print some statistics on SHOP3’s operation
2 or :PLANS - print the stats and print all plans found, but omit operator costs and omit all operators whose names start with "!!"
3 or :LONG-PLANS - print the stats and plans, including all operator costs and all operators (even those whose names start with "!!")
:GC says whether to do a garbage collection before calling SEEK-PLANS :PLAN-TREE indicates whether or not to return plan tree(s).
:COLLECT-STATE indicates whether or not to return final state(s). For backward- compatibility, states are also returned whenever :PLAN-TREE is true. This should probably eventually change.
RETURN VALUES:
PLANS FOUND — a list of plans. Each plan is a list that alternates a between instantiated operators and costs
RUN TIME — floating point value in seconds
/if/ the PLAN-TREE keyword argument is supplied, there will be two additional return values:
PLAN-TREES — a list of plan trees, whose form is specified elsewhere. FINAL-STATES — a list of final state structures, one per plan.

Package

shop3

Source

shop3.lisp (file)

Function: find-plans-stack PROBLEM &key DOMAIN VERBOSE PLAN-TREE GC NO-DEPENDENCIES REPAIRABLE RATIONALE STATE-TYPE OUT-STREAM WHICH

Top level search function for explicit-state search in SHOP3.
Does not support the full range of options supported by SHOP3: only supports finding the first solution to PROBLEM. To comply with SHOP3, though, always returns a list of plans.
If the PLAN-TREE keyword argument is non-NIL, will return an enhanced plan tree, with causal links, unless NO-DEPENDENCIES is non-NIL.

Package

shop3

Source

explicit-search.lisp (file)

Function: find-primitive-node-for-task TASK TREE

Return a primitive node whose task matches TASK. When
the node is found, returns two values: the node itself, and its parent.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-primitive-node-if FUN TREE

Return a primitive node whose TASK satisfies FUN. When
the node is found, returns two values: the node itself, and its parent.

Package

shop3

Source

tree-accessors.lisp (file)

Function: find-problem NAME-OR-PROBLEM &optional ERRORP
Package

shop3

Source

decls.lisp (file)

Function: find-satisfiers GOALS STATE &key JUST-ONE LEVEL DOMAIN

Find and return a list of binding lists that represents the answer to goals (a list representation of a deductive query), where
state provides the database. level is a non-negative integer indicating the current depth of inference, used in debugging prints, and
JUST-ONE is a boolean indicating whether you want just one answer (non-nil) or all answers (nil).

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: find-task-in-tree TASK &optional HASH-TABLE PLAN-TREE

Return the PLAN-TREE:TREE-NODE in TREE corresponding to TASK.

Package

plan-tree

Source

plan-tree.lisp (file)

Function: find-tree-node-if FUNCTION PLAN-TREE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: fix-uninterned-bindings BINDINGS QUERY-VARS
Package

shop3.unifier

Source

unify.lisp (file)

Function: get-alist VARIABLES

Takes a list of variable names as input (VARIABLES), and returns two values: a binding-list mapping the VARIABLES to newly created variables (made using VARIABLE-GENSYM), and a list of the new variables, made with VARIABLE-GENSYM.

Package

shop3.unifier

Source

unify.lisp (file)

Function: get-problems NAME &key PRINT

Get the list of problems for the problem set named NAME

Package

shop3

Source

input.lisp (file)

Function: groundp LITERAL

Is LITERAL a ground literal? Traverse the tree looking for a variable.

Package

shop3.unifier

Source

unify.lisp (file)

Function: internal-operator-p OPERATOR-NAME
Package

shop3

Source

task-reductions.lisp (file)

Function: make-binding VAR VAL
Package

shop3.unifier

Source

unify.lisp (file)

Function: make-binding-list VARIABLES VALUES

Takes a list of VARIABLES and VALUES and returns a BINDING-LIST.

Package

shop3.unifier

Source

unify.lisp (file)

Function: make-complex-node TASK CHILDREN
Package

shop3

Source

tree-accessors.lisp (file)

Function: make-complex-tree-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT) (CHILDREN CHILDREN)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-dependency &key (ESTABLISHER ESTABLISHER) (CONSUMER CONSUMER) (PROP PROP)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-ordered-tree-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT) (CHILDREN CHILDREN)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-primitive-tree-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-problem PROBLEM-NAME-ETC STATE TASKS &rest EXTRAS &aux DOMAIN-NAME

MAKE-PROBLEM creates a planning problem named PROBLEM-NAME
by putting STATE and TASK onto PROBLEM-NAME’s property list under the indicators :STATE and :TASKS. As a side effect, sets the global variable *PROBLEM*.

Package

shop3

Source

input.lisp (file)

Function: make-problem-set LIST-NAME PROBLEM-LIST
Package

shop3

Source

input.lisp (file)

Function: make-state ATOMS &optional STATE-ENCODING
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-tag-map TAG TASK PRIMITIVE

Record association of TAG with operator/action instance OPERATOR.

Package

shop3.common

Source

state-utils.lisp (file)

Function: make-top-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT) (CHILDREN CHILDREN) (LOOKUP-TABLE LOOKUP-TABLE)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-unordered-tree-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT) (CHILDREN CHILDREN)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: node-parent NODE TREE

Find ‘NODE‘’s parent in ‘TREE‘. Returns ‘NIL‘ if nothing found.

Package

shop3

Source

tree-accessors.lisp (file)

Function: pprint-plan PLAN &optional STREAM
Package

shop3

Source

plan-printer.lisp (file)

Function: prepare-state-tag-decoder ()
Package

shop3.common

Source

state-utils.lisp (file)

Function: primitive-node-cost TREE-NODE

TREE-NODE must be a PRIMITIVE-NODE (cf. PRIMITIVE-NODE-P). Returns the corresponding cost (number).

Package

shop3

Source

tree-accessors.lisp (file)

Function: primitive-node-p TREE-NODE

Is TREE-NODE a representation of a primitive node (i.e., an operator) in the SHOP2 tree format as described in SHOP2?

Package

shop3

Source

tree-accessors.lisp (file)

Function: primitive-node-position TREE-NODE

TREE-NODE must be a PRIMITIVE-NODE (cf. PRIMITIVE-NODE-P). Returns the corresponding plan sequence position (integer).

Package

shop3

Source

tree-accessors.lisp (file)

Function: primitive-node-task TREE-NODE

TREE-NODE must be a PRIMITIVE-NODE (cf. PRIMITIVE-NODE-P). Returns the corresponding TASK s-expression.

Package

shop3

Source

tree-accessors.lisp (file)

Function: print-axioms &optional NAME DOMAIN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: print-belief-state-readably BELIEF-STATE &optional STREAM
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: print-current-state &key SORTED STATE
Package

shop3

Source

output.lisp (file)

Function: print-methods &optional NAME DOMAIN
Package

shop3

Source

debugging.lisp (file)

Function: print-operators &optional NAME DOMAIN
Package

shop3

Source

debugging.lisp (file)

Function: process-axiom DOMAIN AXIOM
Package

shop3

Source

input.lisp (file)

Function: prop INSTANCE
Function: (setf prop) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: prop-sorter P1 P2
Package

shop3.common

Source

state-utils.lisp (file)

Function: remove-costs PLAN-AND-COSTS

The SHOP2 plans come with the operators interspersed with their costs. This function just throws away the costs.

Package

shop3

Source

search.lisp (file)

Function: remove-internal-operators COMPLEX-NODE

Returns a new complex-node like the original, but with any children that are internal operators (primitive nodes) removed.

Package

shop3

Source

tree-accessors.lisp (file)

Function: repair-plan DOMAIN PLAN PLAN-TREE EXECUTED DIVERGENCE SEARCH-STATE &key VERBOSE PLAN-TREE-HASH NO-FAILED-TASK

Arguments:
DOMAIN: SHOP2 domain object
PLAN: SHOP2 plan sequence (should work with costs or without, but don’t remove internal operators) PLAN-TREE: *Enhanced* plan tree object (not classic SHOP2 plan tree)
EXECUTED: Prefix of the PLAN
DIVERGENCE: Divergence between the expected state after EXECUTED, specified as (([:ADD|:DELETE] <fact>)+) SEARCH-STATE: Search state object
PLAN-TREE-HASH: Hash table indexing and optimizing access to PLAN-TREE. This is optional – we can manage access anyway, but it will be slower.
Returns: (1) new plan (2) new plan tree (enhanced plan tree, not old-style SHOP plan tree)
(3) plan tree lookup table (4) search-state object.

Package

shop3

Source

plan-repair.lisp (file)

Function: set-domain NAME

NAME argument is a symbol. Will set the global variable *DOMAIN* to the domain with domain-name NAME.

Package

shop3

Source

input.lisp (file)

Function: shop-union S1 S2 &key TEST KEY
Package

shop3.unifier

Source

unify.lisp (file)

Function: shorter-plan PLAN

Removes the internal operators and costs from a plan sequence, and returns the resulting new sequence. Non-destructive.

Package

shop3

Source

search.lisp (file)

Function: standardize EXPR &optional SUBS

Replace all variables in EXPR with newly-generated variables, with new names.

Package

shop3.unifier

Source

unify.lisp (file)

Function: tag-for-action ACTION
Package

shop3.common

Source

state-utils.lisp (file)

Function: task-name TASK
Package

shop3

Source

tree-accessors.lisp (file)

Function: tree-node-dependencies INSTANCE
Function: (setf tree-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: tree-node-expanded-task INSTANCE
Function: (setf tree-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: tree-node-parent INSTANCE
Function: (setf tree-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: tree-node-task TREE-NODE
Package

shop3

Source

tree-accessors.lisp (file)

Function: tree-node-task INSTANCE
Function: (setf tree-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: tree-node-task-name TREE-NODE
Package

shop3

Source

tree-accessors.lisp (file)

Function: unify E1 E2

Checks to see whether or not E1 and E2 unify, returning a substitution (a binding list)
if they do, or FAIL (*NOT* nil) if they don’t.

Package

shop3.unifier

Source

unify.lisp (file)

Function: uniquify-anonymous-variables SEXP

Replace all anonymous variables in SEXP by standardization, so that all anonymous variables are distinct.

Package

shop3.unifier

Source

unify.lisp (file)

Function: validate-plan PLAN DOMAIN-FILE PROBLEM-FILE &key VALIDATOR-PROGNAME SHOP3-DOMAIN VERBOSE

Check the plan for validity. PLAN can be either lisp list
or can be a filename. DOMAIN-FILE and PROBLEM-FILE should be PDDL domain and problem files. VALIDATOR-PROGNAME should be a string that names the
validator in a way that enables it to be found (either an absolute namestring, absolute pathname, or a path-relative namestring).

Package

shop3

Source

pddl.lisp (file)

Function: variable-gensym &optional BASE-NAME

Return a new variable, made from BASE-NAME

Package

shop3.unifier

Source

unify.lisp (file)

Function: variablep X

Is X a symbol representing a logical variable for SHOP’s theorem-prover?

Package

shop3.unifier

Source

unify.lisp (file)

Function: write-pddl-plan SHOP-PLAN &key DOMAIN STREAM FILENAME

Write the plan argument (in a way sensitive to the domain type)
to the FILENAME or STREAM in a format that it can be checked by the validator. This is an easier to use interface to the validator-export function, qv.

Package

shop3

Source

pddl.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: add-atom-to-state ATOM STATE DEPTH OPERATOR

Destructively modifies STATE by adding ATOM
(a positive literal) to the state. DEPTH and OPERATOR are used only for debugging purposes. Will update tag information in state.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: add-atom-to-state ATOM (ST tagged-state) DEPTH OPERATOR
Source

state-utils.lisp (file)

Generic Function: apply-operator DOMAIN STATE TASK-BODY OPERATOR PROTECTIONS DEPTH IN-UNIFIER

If OPERATOR is applicable to TASK in STATE, then APPLY-OPERATOR returns five values:
1. the operator as applied, with all bindings;
2. a state tag, for backtracking purposes;
3. a new set of protections;
4. the cost of the new operator;
5. unifier.
This function also DESTRUCTIVELY MODIFIES its STATE argument. Otherwise it returns FAIL.

Package

shop3

Source

decls.lisp (file)

Methods
Method: apply-operator (DOMAIN domain) STATE TASK-BODY OPERATOR PROTECTIONS DEPTH IN-UNIFIER

If OPERATOR is applicable to TASK in STATE, then APPLY-OPERATOR returns five values:
1. the operator as applied, with all bindings;
2. a state tag, for backtracking purposes;
3. a new set of protections;
4. the cost of the new operator;
5. unifier.
This function also DESTRUCTIVELY MODIFIES its STATE argument. Otherwise it returns FAIL.

Source

task-reductions.lisp (file)

Generic Function: axioms THPR-DOMAIN PREDICATE

Return a list of all the SHOP axioms for PREDICATE in THPR-DOMAIN.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Methods
Method: axioms (DOMAIN has-axioms-mixin) (NAME symbol)

Return a list of axioms for for NAME as defined in DOMAIN.

Method: axioms NO-AXIOMS-DOMAIN PREDICATE
Generic Function: copy-shop-problem NAME PROB &key PROBLEM-CLASS ATOMS TASKS
Package

shop3

Source

decls.lisp (file)

Methods
Method: copy-shop-problem (NAME symbol) (PROB problem) &key PROBLEM-CLASS ATOMS TASKS
Generic Function: copy-state STATE

Return a copy of the state

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: copy-state (ST bit-state)
Source

state-utils.lisp (file)

Method: copy-state (ST doubly-hashed-state)
Source

state-utils.lisp (file)

Method: copy-state (ST mixed-state)
Source

state-utils.lisp (file)

Method: copy-state (ST hash-state)
Source

state-utils.lisp (file)

Method: copy-state (ST list-state)
Source

state-utils.lisp (file)

Generic Function: default-state-type OBJECT
Package

shop3.theorem-prover

Methods
Method: default-state-type (THPR-DOMAIN thpr-domain)

automatically generated reader method

Source

decls.lisp (file)

Generic Function: delete-atom-from-state ATOM STATE DEPTH OPERATOR

Destructively modifies STATE by removing ATOM
(a positive literal) from the state. DEPTH and OPERATOR are used only for debugging purposes. Will update tag information in state.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: delete-atom-from-state ATOM (ST tagged-state) DEPTH OPERATOR
Source

state-utils.lisp (file)

Generic Function: delete-problem PROBLEM
Package

shop3

Source

decls.lisp (file)

Methods
Method: delete-problem (PROBLEM-NAME symbol)
Method: delete-problem (PROBLEM problem)
Generic Function: domain-axioms OBJECT
Package

shop3.theorem-prover

Methods
Method: domain-axioms (HAS-AXIOMS-MIXIN has-axioms-mixin)

automatically generated reader method

Source

decls.lisp (file)

Generic Function: domain-methods DOMAIN

Returns a hash-table mapping complex task names to methods for expanding such tasks.

Package

shop3

Source

decls.lisp (file)

Methods
Method: domain-methods (ACTIONS-DOMAIN-MIXIN actions-domain-mixin)

automatically generated reader method

Generic Function: domain-name OBJECT
Package

shop3.common

Methods
Method: domain-name (PROBSPEC symbol)
Source

decls.lisp (file)

Method: domain-name (PROBLEM problem)

The programmer MAY (but is not obligated to) specify that a problem is intended for use with a particular domain definition.

Source

decls.lisp (file)

Method: domain-name (THPR-DOMAIN thpr-domain)

automatically generated reader method

Source

decls.lisp (file)

Generic Function: domain-operators DOMAIN

Returns a hash-table mapping primitive task names to operator definitions.

Package

shop3

Source

decls.lisp (file)

Methods
Method: domain-operators (ACTIONS-DOMAIN-MIXIN actions-domain-mixin)

automatically generated reader method

Generic Function: find-failed-task DOMAIN PLAN PLAN-TREE EXECUTED DIVERGENCE &key PLAN-TREE-HASH

Return the leftmost failed task in the PLAN that has a failed precondition.
Arguments:
PLAN: Sequence of primitive actions
PLAN-TREE: *Enhanced* SHOP2 plan tree with causal links EXECUTED: Prefix of PLAN that has been executed DIVERGENCE: Divergence between the expected state of the world after EXECUTED and the actual state of the world. Specified as follows (([:ADD|:DELETE] <fact>)+).
That is, any number of lists headed by the :ADD or :DELETE operators, and followed by a list of facts (ground literals). Keyword options:
PLAN-TREE-HASH: if non-NIL should be a hash table (returned by FIND-PLANS-STACK) indexing tasks into the plan-tree. If available, enables quicker lookup.
Returns:
Leftmost, minimal task (plan subtree) that has one or more broken causal links.

Package

shop3-minimal-subtree

Source

decls.lisp (file)

Methods
Method: find-failed-task (DOMAIN domain) PLAN (PLAN-TREE tree-node) EXECUTED DIVERGENCE &key PLAN-TREE-HASH

Default method for FIND-FAILED-TASK.

Source

minimal-subtree.lisp (file)

Method: find-failed-task (DOMAIN symbol) PLAN PLAN-TREE EXECUTED DIVERGENCE &key PLAN-TREE-HASH
Source

minimal-subtree.lisp (file)

Method: find-failed-task (DOMAIN symbol) PLAN PLAN-TREE EXECUTED DIVERGENCE &key PLAN-TREE-HASH around
Source

minimal-subtree.lisp (file)

Generic Function: get-state PROBLEM
Package

shop3

Source

decls.lisp (file)

Methods
Method: get-state (PROBLEM problem)
Method: get-state (PROBLEM-NAME symbol)
Generic Function: get-tasks PROBLEM
Package

shop3

Source

decls.lisp (file)

Methods
Method: get-tasks (NAME symbol)
Method: get-tasks (PROBLEM problem)
Generic Function: handle-domain-options DOMAIN &key TYPE &allow-other-keys

Handle the options in option-list,
as presented to defdomain. These are typically ways of tailoring the domain object, and should be keyword arguments. Returns no value; operates by side effects on DOMAIN.

Package

shop3

Source

decls.lisp (file)

Methods
Method: handle-domain-options (DOMAIN domain) &key TYPE
Source

input.lisp (file)

Generic Function: has-static-preds-p DOMAIN
Package

shop3.theorem-prover

Source

decls.lisp (file)

Methods
Method: has-static-preds-p DOMAIN
Method: has-static-preds-p (DOMAIN static-predicates-mixin)
Generic Function: last-establisher STATE LITERAL

Return the action that last established LITERAL before STATE.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: last-establisher (ST tagged-state) LITERAL
Source

state-utils.lisp (file)

Generic Function: make-initial-state DOMAIN STATE-ENCODING ATOMS &key

Make a state according to a specified domain type and state encoding. Always takes a list of atoms, for special domain types, may take keyword arguments for additional state components.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: make-initial-state (DOMAIN fluents-mixin) STATE-ENCODING ATOMS &key around

Rewrite initial state facts of the form (= <fluent-function> <value>) into new facts of the form (fluent-value fluent-function value).

Source

pddl.lisp (file)

Method: make-initial-state DOMAIN (STATE-ENCODING (eql bit)) ATOMS &key
Source

state-utils.lisp (file)

Method: make-initial-state DOMAIN (STATE-ENCODING (eql doubly-hashed)) ATOMS &key
Source

state-utils.lisp (file)

Method: make-initial-state DOMAIN (STATE-ENCODING (eql mixed)) ATOMS &key
Source

state-utils.lisp (file)

Method: make-initial-state DOMAIN (STATE-ENCODING (eql hash)) ATOMS &key
Source

state-utils.lisp (file)

Method: make-initial-state DOMAIN (STATE-ENCODING (eql list)) ATOMS &key
Source

state-utils.lisp (file)

Generic Function: methods DOMAIN TASK-NAME

Return a list of all the SHOP methods for TASK-NAME in DOMAIN.

Package

shop3

Source

decls.lisp (file)

Methods
Method: methods (DOMAIN domain) (TASK-NAME symbol)
Method: methods DOMAIN TASK-NAME around
Generic Function: name OBJECT
Package

shop3.common

Methods
Method: name (PROBLEM problem)

automatically generated reader method

Source

decls.lisp (file)

Generic Function: parse-domain-items DOMAIN ITEMS

Process all the items in ITEMS. These will be
methods, operators, axioms, and whatever special items domain subclasses may require.
Returns no value; operates by side effects on DOMAIN. For example, in one case we define a method on this for a particular class of domain that adds to the set of items for the domain a list of standard axioms.

Package

shop3

Source

decls.lisp (file)

Methods
Method: parse-domain-items (DOMAIN pddl-typing-mixin) ITEMS around
Source

pddl.lisp (file)

Method: parse-domain-items (DOMAIN equality-mixin) ITEMS around

Add the axiom that treats equality as a built-in predicate. This should later be compiled into find-satisfiers or something.

Source

pddl.lisp (file)

Method: parse-domain-items (DOMAIN fluents-mixin) ITEMS around
Source

pddl.lisp (file)

Method: parse-domain-items (DOMAIN domain) ITEMS
Source

input.lisp (file)

Generic Function: problem-name OBJECT
Package

shop3

Methods
Method: problem-name (PROBLEM problem)

automatically generated reader method

Source

decls.lisp (file)

Generic Function: process-method DOMAIN METHOD-DEF

This generic function allows for
specialization by domain type on how method definitions are parsed. Should return something suitable for installation in the methods table of DOMAIN.

Package

shop3

Source

decls.lisp (file)

Methods
Method: process-method (DOMAIN pure-logic-domain-mixin) METHOD before
Source

input.lisp (file)

Method: process-method (DOMAIN domain) METHOD
Source

input.lisp (file)

Generic Function: process-op DOMAIN OPERATOR-DEF

This generic function allows for specialization
by domain type on how operator definitions are parsed. Should return something suitable for installation in the operators table of DOMAIN.
This generic function supports the new syntax for operators that comes with the :OP keyword instead of :OPERATOR.

Package

shop3

Source

decls.lisp (file)

Methods
Method: process-op (DOMAIN domain) OPERATOR
Source

input.lisp (file)

Generic Function: process-operator DOMAIN OPERATOR-DEF

This generic function allows for specialization
by domain type on how operator definitions are parsed. Should return something suitable for installation in the operators table of DOMAIN.

Package

shop3

Source

decls.lisp (file)

Methods
Method: process-operator (DOMAIN domain) OPERATOR
Source

input.lisp (file)

Generic Function: query GOALS STATE &key JUST-ONE DOMAIN RECORD-DEPENDENCIES

More convenient top-level alternative to FIND-SATISFIERS. Manages optional arguments and ensures that the variable property is properly set in GOALS.

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Methods
Method: query GOALS STATE &key JUST-ONE DOMAIN RECORD-DEPENDENCIES around
Source

input.lisp (file)

Method: query GOALS STATE &key JUST-ONE DOMAIN RECORD-DEPENDENCIES
Generic Function: replay-state-changes STATE UPDATE-LIST &optional STOP-AT
Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: replay-state-changes (ST tagged-state) TAGS-INFO-LIST &optional STOP-AT
Source

state-utils.lisp (file)

Generic Function: retract-state-changes STATE TAG

Restore STATE to its contents *before* the
changes added by TAG. Side-effecting function: will undo individual changes step-by-step. Returns nothing of interest.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: retract-state-changes (ST tagged-state) TAG
Source

state-utils.lisp (file)

Generic Function: seek-plans-null DOMAIN STATE WHICH-PLANS PARTIAL-PLAN PARTIAL-PLAN-COST DEPTH UNIFIER

This SEEK-PLANS-NULL is used with WebServices to strip the add and del lists from the actions in the partial plan before doing the actual SEEK-PLANS-NULL...

Package

shop3

Source

decls.lisp (file)

Methods
Method: seek-plans-null (DOMAIN domain) STATE WHICH-PLANS PARTIAL-PLAN PARTIAL-PLAN-COST DEPTH UNIFIER
Source

search.lisp (file)

Generic Function: seek-plans-primitive DOMAIN TASK1 STATE TASKS TOP-TASKS PARTIAL-PLAN PARTIAL-PLAN-COST DEPTH WHICH-PLANS PROTECTIONS UNIFIER

If there is an OPERATOR that is applicable to the primitive TASK1 in STATE,
then SEEK-PLANS-PRIMITIVE applies that OPERATOR, generates the successor state, updates the current partial plan with the OPERATOR, and continues with planning by recursively calling SEEK-PLANS. Otherwise, it returns FAIL.

Package

shop3

Source

decls.lisp (file)

Methods
Method: seek-plans-primitive (DOMAIN domain) TASK1 STATE TASKS TOP-TASKS PARTIAL-PLAN PARTIAL-PLAN-COST DEPTH WHICH-PLANS PROTECTIONS UNIFIER
Source

search.lisp (file)

Generic Function: set-variable-property DOMAIN X

Record facts about X being a variable, operator, or
other special symbol. Done for side-effects. Returns nothing of interest.

Package

shop3.unifier

Source

unify.lisp (file)

Methods
Method: set-variable-property DOMAIN X
Generic Function: sort-methods DOMAIN METHODS WHICH-PLANS

Sort a list of METHODS in DOMAIN according to WHICH-PLANS.

Package

shop3

Source

decls.lisp (file)

Methods
Method: sort-methods DOMAIN (METHODS list) (WHICH-PLANS symbol)
Method: sort-methods DOMAIN (METHODS list) (WHICH-PLANS (eql random))
Generic Function: sort-results DOMAIN RESULTS UNIFIERS WHICH-PLANS

Sort lists of RESULTS and UNIFIERS in DOMAIN according to WHICH-PLANS and return the new RESULTS and UNIFIERS.

Package

shop3

Source

decls.lisp (file)

Methods
Method: sort-results DOMAIN (RESULTS list) (UNIFIERS list) (WHICH-PLANS symbol)
Method: sort-results DOMAIN (RESULTS list) (UNIFIERS list) (WHICH-PLANS (eql random))
Generic Function: sort-tasks DOMAIN TASKS UNIFIER WHICH-PLANS

Sort the list of pending TASKS in DOMAIN.
This is a replacement for TASK-SORTER that takes an additional WHICH-PLANS argument for EQL-specialization.

Package

shop3

Source

decls.lisp (file)

Methods
Method: sort-tasks DOMAIN TASKS UNIFIER (WHICH-PLANS symbol)

Call TASK-SORTER by default for backward compatibility.

Method: sort-tasks DOMAIN (TASKS list) UNIFIER (WHICH-PLANS (eql random))

Uniformly randomize the list of tasks (originally for Monroe).

Generic Function: source-pddl-domain OBJECT
Package

shop3

Methods
Method: source-pddl-domain (SIMPLE-PDDL-DOMAIN simple-pddl-domain)

automatically generated reader method

Source

pddl.lisp (file)

Generic Function: state OBJECT
Generic Function: (setf state) NEW-VALUE OBJECT
Package

shop3.common

Methods
Method: state (SEARCH-STATE search-state)
Method: (setf state) NEW-VALUE (SEARCH-STATE search-state)

SHOP2 world state object.

Source

decls.lisp (file)

Generic Function: state->state-type STATE

Return the state-type keyword for STATE.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: state->state-type (STATE bit-state)
Source

state-utils.lisp (file)

Method: state->state-type (STATE doubly-hashed-state)
Source

state-utils.lisp (file)

Method: state->state-type (STATE mixed-state)
Source

state-utils.lisp (file)

Method: state->state-type (STATE hash-state)
Source

state-utils.lisp (file)

Method: state->state-type (STATE list-state)
Source

state-utils.lisp (file)

Method: state->state-type STATE
Generic Function: state-all-atoms-for-predicate STATE PRED

Return all atoms in STATE that concern PRED. Used internally
by the theorem-prover. Must be implemented when adding a new state structure type.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: state-all-atoms-for-predicate (ST bit-state) PRED
Source

state-utils.lisp (file)

Method: state-all-atoms-for-predicate (ST doubly-hashed-state) PRED
Source

state-utils.lisp (file)

Method: state-all-atoms-for-predicate (ST mixed-state) PRED
Source

state-utils.lisp (file)

Method: state-all-atoms-for-predicate (ST hash-state) PRED
Source

state-utils.lisp (file)

Method: state-all-atoms-for-predicate (ST list-state) PRED
Source

state-utils.lisp (file)

Generic Function: state-atoms STATE

Return the atoms of the state in a plain list

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: state-atoms (PROBLEM problem)

automatically generated reader method

Source

decls.lisp (file)

Method: state-atoms (ST bit-state)
Source

state-utils.lisp (file)

Method: state-atoms (ST doubly-hashed-state)
Source

state-utils.lisp (file)

Method: state-atoms (ST mixed-state)
Source

state-utils.lisp (file)

Method: state-atoms (ST hash-state)
Source

state-utils.lisp (file)

Method: state-atoms (ST list-state)
Source

state-utils.lisp (file)

Generic Function: state-candidate-atoms-for-goal STATE GOAL

Return all atoms in STATE relevant to GOAL. Used internally
by the theorem-prover. Must be implemented when adding a new state structure type.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: state-candidate-atoms-for-goal (ST bit-state) GOAL
Source

state-utils.lisp (file)

Method: state-candidate-atoms-for-goal (ST doubly-hashed-state) GOAL
Source

state-utils.lisp (file)

Method: state-candidate-atoms-for-goal (ST mixed-state) GOAL
Source

state-utils.lisp (file)

Method: state-candidate-atoms-for-goal (ST hash-state) GOAL
Source

state-utils.lisp (file)

Method: state-candidate-atoms-for-goal (ST list-state) GOAL
Source

state-utils.lisp (file)

Generic Function: state-trajectory STATE &key SORTED

Any state in SHOP implicitly defines a trajectory —
the sequence of states, starting from the initial state, and terminating at this state. This function returns a trajectory leading to STATE.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: state-trajectory (ST tagged-state) &key SORTED
Source

state-utils.lisp (file)

Generic Function: static-preds DOMAIN

Return a list of predicate names for static predicates.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Methods
Method: static-preds (STATIC-PREDICATES-MIXIN static-predicates-mixin)

automatically generated reader method

Generic Function: tag-state STATE &optional INCREMENT

Add a tag to a state; used to make tagged-states, which provide information about how to backtrack over state updates.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: tag-state (ST tagged-state) &optional INCREMENT
Source

state-utils.lisp (file)

Generic Function: task-sorter DOMAIN TASKS UNIFIER

This function allows customization of choice of pending task
to expand. SHOP search behavior can be changed by specializing this generic function (most likely using the domain argument). Returns a sorted list of tasks in the order in which they should be expanded. A failure can be triggered by returning NIL.

Package

shop3

Source

decls.lisp (file)

Methods
Method: task-sorter (DOMAIN domain) TASKS UNIFIER
Generic Function: trigger-trace KEYWORD ITEM-NAME

Allow extensible methods of matching to trigger printing.

Package

shop3.unifier

Source

tracer.lisp (file)

Methods
Method: trigger-trace (KEYWORD (eql tasks)) (ITEM symbol)
Source

debugging.lisp (file)

Method: trigger-trace (KEYWORD (eql goals)) (ITEM symbol)
Source

debugging.lisp (file)

Method: trigger-trace (KEYWORD (eql axioms)) (ITEM symbol)
Source

debugging.lisp (file)

Method: trigger-trace (KEYWORD (eql methods)) (ITEM symbol)
Source

debugging.lisp (file)

Method: trigger-trace KEYWORD ITEM-NAME
Generic Function: validator-export DOMAIN PLAN STREAM

Print a plan in a way that it can be consumed by the VAL validator.

Package

shop3

Source

pddl.lisp (file)

Methods
Method: validator-export (DOMAIN simple-pddl-domain) (PLAN list) STREAM

Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Conditions

Condition: bad-argument ()
Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: predicate
Initargs

:predicate

Readers

predicate (generic function)

Slot: argno
Initargs

:argno

Readers

argno (generic function)

Slot: comment
Initargs

:comment

Readers

comment (generic function)

Condition: incomplete-dependency-error ()
Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: logical-op
Initargs

:logical-op

Readers

logical-op (generic function)

Slot: expression
Initargs

:expression

Readers

expression (generic function)

Condition: instantiation-error ()
Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: predicate
Initargs

:predicate

Readers

predicate (generic function)

Slot: argno
Initargs

:argno

Readers

argno (generic function)

Condition: no-method-for-task ()
Package

shop3

Source

decls.lisp (file)

Direct superclasses

shop-error (condition)

Direct slots
Slot: task-name
Initargs

:task-name

Condition: non-ground-error ()
Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: var
Initargs

:var

Readers

var (generic function)

Slot: expression
Initargs

:expression

Readers

expression (generic function)

Condition: singleton-variable ()
Package

shop3

Source

decls.lisp (file)

Direct superclasses

domain-item-parse-warning (condition)

Direct methods
Direct slots
Slot: variable-names
Initargs

:variable-names

Readers

variable-names (generic function)

Slot: construct-type
Initargs

:construct-type

Readers

construct-type (generic function)

Slot: construct-name
Initargs

:construct-name

Readers

construct-name (generic function)

Slot: construct
Initargs

:construct

Initform

(quote nil)

Readers

construct (generic function)

Slot: branch-number
Initargs

:branch-number

Initform

(quote nil)

Readers

branch-number (generic function)

Condition: task-arity-mismatch ()

An error representing the case where the LIBRARY-ENTRY has a way of performing LIBRARY-TASK whose arity does not match that of TASK, although the
task keyword of TASK and LIBRARY-TASK are the same.

Package

shop3

Source

decls.lisp (file)

Direct superclasses

shop-error (condition)

Direct methods
Direct slots
Slot: task
Initargs

:task

Readers

task-arity-mismatch-task (generic function)

Slot: library-task
Initargs

:library-task

Readers

task-arity-mismatch-library-task (generic function)

Slot: library-entry
Initargs

:library-entry

Readers

task-arity-mismatch-library-entry (generic function)

Condition: theorem-prover-condition ()

This mixin class should be added to any condition raised by
the theorem-prover, in order to allow handlers to distinguish such conditions. It provides no additional behavior or slots, so that it can be mixed into warnings, errors, etc.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Structures

Structure: complex-tree-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

tree-node (structure)

Direct subclasses
Direct methods
Direct slots
Slot: children
Readers

complex-tree-node-children (function)

Writers

(setf complex-tree-node-children) (function)

Structure: dependency ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: establisher
Readers

establisher (function)

Writers

(setf establisher) (function)

Slot: consumer
Readers

consumer (function)

Writers

(setf consumer) (function)

Slot: prop
Readers

prop (function)

Writers

(setf prop) (function)

Structure: ordered-tree-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

pseudo-node (structure)

Direct methods

print-object (method)

Structure: primitive-tree-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

tree-node (structure)

Direct methods

print-object (method)

Structure: pseudo-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

complex-tree-node (structure)

Direct subclasses
Structure: state ()
Package

shop3.common

Source

state-utils.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

tagged-state (structure)

Direct methods

print-object (method)

Direct slots
Slot: body
Readers

state-body (function)

Writers

(setf state-body) (function)

Structure: top-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

complex-tree-node (structure)

Direct methods

print-object (method)

Direct slots
Slot: lookup-table
Readers

top-node-lookup-table (function)

Writers

(setf top-node-lookup-table) (function)

Structure: tree-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods

find-failed-task (method)

Direct slots
Slot: task
Readers

tree-node-task (function)

Writers

(setf tree-node-task) (function)

Slot: expanded-task
Readers

tree-node-expanded-task (function)

Writers

(setf tree-node-expanded-task) (function)

Slot: dependencies
Readers

tree-node-dependencies (function)

Writers

(setf tree-node-dependencies) (function)

Slot: parent
Readers

tree-node-parent (function)

Writers

(setf tree-node-parent) (function)

Structure: unordered-tree-node ()
Package

plan-tree

Source

plan-tree.lisp (file)

Direct superclasses

pseudo-node (structure)

Direct methods

print-object (method)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.7 Classes

Class: adl-domain ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses
Class: adl-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses
Direct subclasses

adl-domain (class)

Class: conditional-effects-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

translate-effect (method)

Class: costs-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Class: disjunctive-preconditions-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

adl-mixin (class)

Direct methods
Class: domain ()

An object representing a SHOP domain.

Package

shop3

Source

decls.lisp (file)

Direct superclasses
Direct subclasses
Direct methods
Class: equality-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

parse-domain-items (method)

Class: existential-preconditions-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

quantified-preconditions-mixin (class)

Direct methods
Class: negative-preconditions-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

adl-mixin (class)

Direct methods
Class: pddl-domain ()

A new class of SHOP3 domain that permits inclusion of
PDDL operator definitions. Right now, this approximates what happens if you have the :adl flag in a PDDL domain file.

Package

shop3

Source

pddl.lisp (file)

Direct superclasses
Class: pddl-typing-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: pddl-types
Initargs

:%pddl-types

Readers

pddl-types (generic function)

Writers

(setf pddl-types) (generic function)

Class: pure-logic-domain-mixin ()

A MIXIN indicating that a domain should not use IF-THEN-ELSE semantics in methods.

Package

shop3

Source

decls.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

process-method (method)

Class: quantified-preconditions-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses
Direct subclasses
Class: simple-pddl-domain ()

A new class of SHOP3 domain that permits inclusion of PDDL operator definitions.

Package

shop3

Source

pddl.lisp (file)

Direct superclasses

domain (class)

Direct subclasses
Direct methods
Direct slots
Slot: source-pddl-domain
Initargs

:source-pddl-domain

Readers

source-pddl-domain (generic function)

Class: static-predicates-mixin ()

Add this to domain classes that should have static predicates defined.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

pddl-domain (class)

Direct methods
Direct slots
Slot: static-preds
Initargs

:static-preds

Readers

static-preds (generic function)

Class: thpr-domain ()

An object representing a SHOP3 theorem prover domain.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Direct superclasses
Direct subclasses

domain (class)

Direct methods
Direct slots
Slot: domain-name
Initargs

:name, :domain-name

Readers

domain-name (generic function)

Slot: default-state-type
Initargs

:default-state-type

Initform

:mixed

Readers

default-state-type (generic function)

Class: universal-preconditions-mixin ()
Package

shop3

Source

pddl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

quantified-preconditions-mixin (class)

Direct methods

Previous: , Up: Exported definitions   [Contents][Index]

6.1.8 Types

Type: shop-variable ()

Type for variables used by the SHOP unifier. A subtype of SYMBOL.

Package

shop3.unifier

Source

unify.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Constants

Constant: +anonymous-property-name+
Package

shop3.unifier

Source

unify.lisp (file)

Constant: +primitive-property-name+
Package

shop3.unifier

Source

unify.lisp (file)

Constant: +shopyright+
Package

shop3

Source

shop3.lisp (file)

Constant: +singleton-term+
Package

shop3.common

Source

state-utils.lisp (file)

Constant: +variable-property-name+
Package

shop3.unifier

Source

unify.lisp (file)

Constant: +variable-term+
Package

shop3.common

Source

state-utils.lisp (file)

Constant: shop-trace-items

Acceptable arguments for SHOP-TRACE (and SHOP-UNTRACE).

Package

shop3

Source

debugging.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Special variables

Special Variable: *action-to-tag-map*

Will be bound to a hash table to look up a numerical tag from an operator/action instance.

Package

shop3.common

Source

state-decls.lisp (file)

Special Variable: *all-problems*
Package

shop3

Source

decls.lisp (file)

Special Variable: *back-quote-name*
Package

shop3

Source

decls.lisp (file)

Special Variable: *break-on-backtrack*

If this variable is bound to T, SHOP will enter a break loop upon backtracking.

Package

shop3

Source

decls.lisp (file)

Special Variable: *collect-state*
Package

shop3

Source

decls.lisp (file)

Special Variable: *current-plan*
Package

shop3

Source

decls.lisp (file)

Special Variable: *current-tasks*
Package

shop3

Source

decls.lisp (file)

Special Variable: *defdomain-pathname*

Dynamic variable used to enable INCLUDE directives to find files relative to the file containing the DEFDOMAIN. Necessary because ASDF breaks usage of *load-truename* by moving the FASLs.

Package

shop3

Source

input.lisp (file)

Special Variable: *depth-cutoff*
Package

shop3

Source

decls.lisp (file)

Special Variable: *enhanced-plan-tree*

Do we build a dependency-enhanced plan tree?

Package

shop3

Source

explicit-search.lisp (file)

Special Variable: *expansions*
Package

shop3

Source

decls.lisp (file)

Special Variable: *explanation*
Package

shop3

Source

decls.lisp (file)

Special Variable: *gc*
Package

shop3

Source

decls.lisp (file)

Special Variable: *hand-steer*

This variable will be DYNAMICALLY bound and used to indicate whether the user wishes to choose tasks for planning by hand.

Package

shop3

Source

decls.lisp (file)

Special Variable: *ignore-singleton-variables*

When T – which should only be for legacy SHOP3 domains – do NOT emit singleton variable warnings.

Package

shop3

Source

input.lisp (file)

Special Variable: *include-rationale*
Package

shop3

Source

explicit-search.lisp (file)

Special Variable: *internal-time-limit*
Package

shop3

Source

decls.lisp (file)

Special Variable: *internal-time-tag*
Package

shop3

Source

decls.lisp (file)

Special Variable: *leashed*

This variable will be DYNAMICALLY bound and it will further constrain the behavior of SHOP when we hand-steer it (see *hand-steer*). If *leashed* is NIL, SHOP will simply proceed when choosing tasks, if there is no choice, i.e., when there’s only one task on the open list, or only one :immediate task. If *leashed* is non-nil, will consult the user even in these cases.

Package

shop3

Source

decls.lisp (file)

Special Variable: *more-tasks-p*

When NIL, it is safe to tail-call any plan-seeking function.

Package

shop3

Source

decls.lisp (file)

Special Variable: *negation-deps-ok*
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Special Variable: *no-dependencies*

When building an ENHANCED-PLAN-TREE, do not record causal links. Defaults to NIL.

Package

shop3

Source

explicit-search.lisp (file)

Special Variable: *operator-tasks*
Package

shop3

Source

decls.lisp (file)

Special Variable: *optimal-cost*
Package

shop3

Source

decls.lisp (file)

Special Variable: *optimal-plan*
Package

shop3

Source

decls.lisp (file)

Special Variable: *optimize-cost*
Package

shop3

Source

decls.lisp (file)

Special Variable: *optimize-first-retrieval*

In some cases we can optimize solutions to :FIRST to find only the first match.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Special Variable: *plan-tree*
Package

shop3

Source

decls.lisp (file)

Special Variable: *plans-found*
Package

shop3

Source

decls.lisp (file)

Special Variable: *pp*
Package

shop3

Source

decls.lisp (file)

Special Variable: *print-plans*
Package

shop3

Source

decls.lisp (file)

Special Variable: *print-stats*
Package

shop3

Source

decls.lisp (file)

Special Variable: *problem*
Package

shop3

Source

decls.lisp (file)

Special Variable: *protections*
Package

shop3

Source

decls.lisp (file)

Special Variable: *pshort*
Package

shop3

Source

decls.lisp (file)

Special Variable: *shop-pprint-table*
Package

shop3

Source

decls.lisp (file)

Special Variable: *shop-version*
Package

shop3

Source

decls.lisp (file)

Special Variable: *start-real-time*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *start-run-time*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *state-tag-map*

Will be bound to a hash table to look up an operator/action instance from a tag.

Package

shop3.common

Source

state-decls.lisp (file)

Special Variable: *states-found*
Package

shop3

Source

decls.lisp (file)

Special Variable: *subtask-parents*
Package

shop3

Source

decls.lisp (file)

Special Variable: *tasklist*
Package

shop3

Source

decls.lisp (file)

Special Variable: *time-limit*
Package

shop3

Source

decls.lisp (file)

Special Variable: *traced-axioms*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *traced-goals*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *traced-methods*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *traced-tasks*
Package

shop3

Source

debugging.lisp (file)

Special Variable: *unifiers-found*
Package

shop3

Source

decls.lisp (file)

Special Variable: *validator-progname*
Package

shop3

Source

pddl.lisp (file)

Special Variable: *verbose*
Package

shop3

Source

decls.lisp (file)

Special Variable: +binary-numerical-operators+

Binary numerical operations permitted by the :fluents requirement.

Package

shop3.theorem-prover

Source

fluents.lisp (file)

Special Variable: +fluent-updates+
Package

shop3

Source

pddl.lisp (file)

Special Variable: +numerical-comparisons+

Numerical comparisons permitted by the :fluents requirement.

Package

shop3.theorem-prover

Source

fluents.lisp (file)

Special Variable: +pddl-requirements-keywords+
Package

shop3

Source

decls.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Macros

Macro: appendf PLACE VALUE
Package

shop3

Source

decls.lisp (file)

Macro: catch-internal-time &rest BODY
Package

shop3

Source

decls.lisp (file)

Macro: defconstant NAME VALUE &optional DOC
Package

shop3

Source

decls.lisp (file)

Macro: print-unreadably (&rest ARGS) &body BODY

This macro is for defining a method for printing un-readably, and deferring to the built-in method when trying to print readably. Particularly useful for structures, but could be generally applicable.

Package

plan-tree

Source

plan-tree.lisp (file)

Macro: push-last ITEM LIST
Package

shop3

Source

decls.lisp (file)

Macro: seek-satisfiers GOALS STATE VAR-VAL-LIST LEVEL JUST1 &key DOMAIN DEPENDENCIES

Find satisfying assignments to variables in GOALS, using STATE and VAR-VAL-LIST. Find just one assignment if JUST1 is non-NIL.
VAR-VAL-LIST is a list made up of either variables or the values assigned to those variables. This list will be harvested into a list of binding lists to be returned by FIND-SATISFIERS.
Semantically, returns *multiple answers*.
In terms of the program, returns two values:
1. a list of values for the variables (or the variables themselves, if unbound). 2. a list of dependencies, which will be computed if *RECORD-DEPENDENCIES-P* is non-NIL.

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Macro: simple-backquote X
Package

shop3

Source

decls.lisp (file)

Macro: verbose-format &rest ARGS
Package

shop3

Source

decls.lisp (file)

Macro: when-done &body BODY
Package

shop3

Source

search.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Functions

Function: %make-bit-state &key (BODY BODY) (TAGS-INFO TAGS-INFO) (BLOCK-AT BLOCK-AT)
Package

shop3.common

Source

state-utils.lisp (file)

Function: %new-method-id METHOD-TASK-NAME

Return a new name for a method expression (top level method form, as distinguished from a precondition/tasknet pair, which may be nested in a single ‘:method‘ expression with others).
This returns a symbol that is *not* interned.

Package

shop3

Source

input.lisp (file)

Function: acceptable-cost-p COST
Package

shop3

Source

search.lisp (file)

Function: add-protection PROTECTIONS PROTECT DEPTH OPERATOR STATE
Package

shop3

Source

protections.lisp (file)

Function: add-source UNIFIED-GOAL EXTERNAL EXPLANATION
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: all-raw-depends-lists-p LIST
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: all-raw-depends-p LIST
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: already-immediate-p REDUCTION
Package

shop3

Source

task-reductions.lisp (file)

Function: anonymous-var-symbol-p X
Package

shop3.unifier

Source

unify.lisp (file)

Function: answer-set-union ANSWER-LIST NEW-ANSWER-LIST DEPENDENCY-LIST NEW-DEPENDENCY-LIST

Remove redundant answers from ANSWER-LIST. If we remove an entry from ANSWER-LIST, also remove the corresponding entry from DEPENDENCY-LIST.
ANSWER-LIST is a list of lists of (variable | value).
Returns two values: the filtered answer-list and the filtered dependency-list.

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: apply-action DOMAIN STATE TASK-BODY ACTION PROTECTIONS DEPTH IN-UNIFIER

If ACTION, a PDDL ACTION, is applicable to TASK in STATE, then APPLY-ACTION returns six values:
1. the operator as applied, with all bindings;
2. a state tag, for backtracking purposes;
3. a new set of protections;
4. the cost of the new operator;
5. unifier;
6. dependencies for primary and secondary effects, if *record-dependencies-p* is true.
This function also DESTRUCTIVELY MODIFIES its STATE argument.
Otherwise it returns FAIL.

Package

shop3

Source

pddl.lisp (file)

Function: apply-method-bindings TASK TOP-TASKS TASKS REDUCTION UNIFIER
Package

shop3

Source

search.lisp (file)

Function: apply-substitution-to-tree BINDINGS PLAN-TREE
Package

shop3

Source

explicit-search.lisp (file)

Function: axiom-sexp-p LST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: backtrack FORMAT-STRING &rest ARGS
Package

shop3

Source

output.lisp (file)

Function: binding-p OBJECT
Package

shop3.unifier

Source

unify.lisp (file)

Function: bit-state-block-at INSTANCE
Function: (setf bit-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: bit-state-body INSTANCE
Function: (setf bit-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: bit-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: bit-state-tags-info INSTANCE
Function: (setf bit-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: bit-statebody-increment-position POSITION PRED-TYPE-COUNTS
Package

shop3.common

Source

state-utils.lisp (file)

Function: bit-statebody-search-array PRED-ARRAY PRED-TYPE-COUNTS ENTITY-NUMBER-TABLES COMPLEX-POSITION
Package

shop3.common

Source

state-utils.lisp (file)

Function: check-constraints BINDING

Check to make sure that all the constraints on the binding-val are satisfied.
Returns a boolean, and a second value (for debugging) listing a failed constraint.

Package

shop3.unifier

Source

unify.lisp (file)

Function: check-for-singletons VAR-TABLE &key CONTEXT-TABLES CONTEXT-TABLE CONSTRUCT-TYPE CONSTRUCT-NAME CONSTRUCT BRANCH-NUMBER
Package

shop3

Source

input.lisp (file)

Function: choose-immediate-task IMMEDIATE-TASKS UNIFIER

Which of the set of IMMEDIATE-TASKS should SHOP2 work on first? Defaults to the first element, unless the user intervenes.

Package

shop3

Source

search.lisp (file)

Function: choose-immediate-task-state STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: choose-method-bindings-state STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: choose-method-state STATE DOMAIN
Package

shop3

Source

explicit-search.lisp (file)

Function: choose-toplevel-task STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: clobbered-p TREE-NODE DIVERGENCE
Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: complex-tree-node-dependencies INSTANCE
Function: (setf complex-tree-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: complex-tree-node-expanded-task INSTANCE
Function: (setf complex-tree-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: complex-tree-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: complex-tree-node-parent INSTANCE
Function: (setf complex-tree-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: complex-tree-node-task INSTANCE
Function: (setf complex-tree-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: compute-fluent-updates EFFECT-EXPR STATE DOMAIN DEPTH

Translate a FLUENT-UPDATE EFFECT-EXPR into a set of ADD and DELETES (these will have as predicate FLUENT-VALUE), and optionally return a set of dependencies.

Package

shop3

Source

pddl.lisp (file)

Function: copy-binding INSTANCE
Package

shop3.unifier

Source

unify.lisp (file)

Function: copy-complex-tree-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-dependency INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-hash-table H1 &optional COPY-FN
Package

shop3.common

Source

state-utils.lisp (file)

Function: copy-operator SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package

shop3

Source

SYS:SRC;CODE;SEQ.LISP (not found)

Function: copy-operator-node SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package

shop3

Source

SYS:SRC;CODE;SEQ.LISP (not found)

Function: copy-ordered-tree-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-pddl-action SEQUENCE

Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.

Package

shop3

Source

SYS:SRC;CODE;SEQ.LISP (not found)

Function: copy-primitive-tree-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-pseudo-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-raw-depend INSTANCE
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: copy-state-update INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: copy-task-tree TT
Package

shop3

Source

task-reductions.lisp (file)

Function: copy-top-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-tree-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: copy-unordered-tree-node INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: count-method-branches METHOD-BODY
Package

shop3

Source

input.lisp (file)

Function: delete-protection PROTECTIONS PROTECT DEPTH OPERATOR STATE
Package

shop3

Source

protections.lisp (file)

Function: delete-task-main-list L TASK DELETED
Package

shop3

Source

task-reductions.lisp (file)

Function: delete-task-top-list L ML TASK
Package

shop3

Source

task-reductions.lisp (file)

Function: dependency-for-negation POSITIVE-LITERAL STATE
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: dependency-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: determine-verbosity VERBOSE
Package

shop3

Source

output.lisp (file)

Function: divergence-list-p LIST
Package

shop3

Source

plan-repair.lisp (file)

Function: divergence-op-p OP
Package

shop3

Source

plan-repair.lisp (file)

Function: do-conjunct DOMAIN GOAL1 REMAINING STATE BINDINGS LEVEL JUST1 DEPENDENCIES-IN

Where goal1 is an atomic predicate (not an atom per se, but a clause not headed by an operator or other symbol), try to find a binding that satisfies goal1 along with all of the other formulas in remaining.

Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: do-conjunct-from-atoms DOMAIN GOAL1 REMAINING STATE BINDINGS LEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: do-conjunct-from-axiom AXIOM DOMAIN GOAL1 REMAINING STATE BINDINGS LEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: do-conjunct-from-axioms DOMAIN GOAL1 REMAINING STATE BINDINGS LEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: domain-include-search PATH

Search for PATH relative to *COMPILE-FILE-TRUENAME*, *LOAD-TRUENAME*, the cached location of the domain definition file, and *DEFAULT-PATHNAME-DEFAULTS*.

Package

shop3

Source

input.lisp (file)

Function: doubly-hashed-state-block-at INSTANCE
Function: (setf doubly-hashed-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: doubly-hashed-state-body INSTANCE
Function: (setf doubly-hashed-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: doubly-hashed-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: doubly-hashed-state-tags-info INSTANCE
Function: (setf doubly-hashed-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: dummy-external-access-hook GOAL
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: dump-higher-cost-plans! ()
Package

shop3

Source

search.lisp (file)

Function: dump-previous-plans! ()

Clear out the data structures (special variables) we use to return plans.

Package

shop3

Source

search.lisp (file)

Function: empty-p STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: expand-include DOMAIN ITEMS
Package

shop3

Source

input.lisp (file)

Function: expand-includes DOMAIN ITEMS

Handle :INCLUDE directives, return a new items list if any are found, otherwise the original list.

Package

shop3

Source

input.lisp (file)

Function: extend-plan-tree-nodes BASE-NODES
Package

shop3

Source

tree-reductions.lisp (file)

Function: external-find-satisfiers DOMAIN GOAL STATE
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: external-query DOMAIN QUERY STATE
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: extract-adds-and-deletes DOMAIN EFFECT-EXPR STATE DEPTH

This function is intended for use on a PDDL :effect expression. It partitions the effects into adds and deletes and returns these two values, together with a set of dependencies as a third value, if dependency tracking is turned on.

Package

shop3

Source

pddl.lisp (file)

Function: extract-method-id DOMAIN METHOD-EXPR TASK-NAME
Package

shop3

Source

input.lisp (file)

Function: extract-subtasks REDUCTION
Package

shop3

Source

tree-reductions.lisp (file)

Function: extract-subtree ROOT-NODE NODES
Package

shop3

Source

tree-reductions.lisp (file)

Function: extract-suffix PLAN PREFIX
Package

shop3

Source

plan-repair.lisp (file)

Function: extract-tree PLAN
Package

shop3

Source

tree-reductions.lisp (file)

Function: extract-trees PLANS-FOUND UNIFIERS-FOUND
Package

shop3

Source

shop3.lisp (file)

Function: filter-singletons SINGLETONS CONTEXT-TABLES
Package

shop3

Source

input.lisp (file)

Function: find-adder PROP DIVERGENCE-LIST
Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: find-binding TARGET BINDING-LIST

Find and return the value of TARGET that’s recorded in BINDING-LIST.

Package

shop3.unifier

Source

unify.lisp (file)

Function: find-checking-path TREE-NODE

Find and return the series of tree nodes that should be checked above TREE-NODE. Returns a list in order of checking (i.e., top-down).

Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: find-deleter PROP DIVERGENCE-LIST
Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: find-next-main-list TASK L
Package

shop3

Source

task-reductions.lisp (file)

Function: find-plan-suffix ORIG-PLAN EXECUTED-PREFIX
Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: find-plans-1 DOMAIN STATE TASKS WHICH PROBLEM &optional OUT-STREAM
Package

shop3

Source

shop3.lisp (file)

Function: find-variable TREE
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: first-word-equal STRING1 STRING2
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: force-immediate REDUCTIONS
Package

shop3

Source

task-reductions.lisp (file)

Function: force-immediate-reduction REDUCTION
Package

shop3

Source

task-reductions.lisp (file)

Function: force-immediate-unordered UNORDERED-LIST &optional PREVIOUS
Package

shop3

Source

task-reductions.lisp (file)

Function: freeze-state EXECUTED FAILED-ACTION DIVERGENCE SEARCH-STATE

Arguments:
PLAN: sequence of primitive actions.
EXECUTED: Prefix of the plan that has been executed. FAILED-ACTION: First action whose preconditions are clobbered, or the leftmost leaf child of the first non-primitive task whose preconditions are broken.
DIVERGENCE: Divergence between the expected state after EXECUTED, specified as (([:ADD|:DELETE] <fact>)+) SEARCH-STATE: Search state object.

Returns:
Modified search state object.

Package

shop3

Source

plan-repair.lisp (file)

Function: fully-instantiated-goal GOAL
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: generate-reductions DOMAIN REDUCTIONS SUBTASKS
Package

shop3

Source

loop-extensions.lisp (file)

Function: get-attribution UNIFIED-QUERY
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: get-immediate-list TL
Package

shop3

Source

search.lisp (file)

Function: get-task-body TASK1
Package

shop3

Source

task-reductions.lisp (file)

Function: get-task-name TASK1
Package

shop3

Source

task-reductions.lisp (file)

Function: get-top-tasks L
Package

shop3

Source

task-reductions.lisp (file)

Function: goal-equalp G1 G2
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: harvest-variables SEXP &optional ALL-VARS

Tree-walk the SEXP, harvesting all variables into a hash-table. The hash-table will have as keys variable names, and values will be counts of number of appearances. Defaults to *not* counting variables with the "ignore prefix" of underscore, unless ALL-VARS is non-NIL.
PRECONDITION: PROCESS-VARIABLE-PROPERTY must have been called on the surrounding context, becasue this relies on VARIABLEP working.

Package

shop3

Source

input.lisp (file)

Function: hash-state-block-at INSTANCE
Function: (setf hash-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: hash-state-body INSTANCE
Function: (setf hash-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: hash-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: hash-state-tags-info INSTANCE
Function: (setf hash-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: immediate-tasks STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: incorporate-unifiers UNIFIERS REMAINING JUST-ONE STATE BINDINGS DEPENDENCIES-IN ADDED-DEPENDENCIES DOMAIN NEWLEVEL
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: indented-format INDENTATION &rest BODY
Package

shop3

Source

output.lisp (file)

Function: invoke-external-query QUERY STATE
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: leftmost-p TREE-NODE
Package

shop3-minimal-subtree

Source

minimal-subtree.lisp (file)

Function: list-insert-atom-into-statebody ATOM STATEBODY
Package

shop3.common

Source

state-utils.lisp (file)

Function: list-remove-atom-from-statebody ATOM STATEBODY
Package

shop3.common

Source

state-utils.lisp (file)

Function: list-state-block-at INSTANCE
Function: (setf list-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: list-state-body INSTANCE
Function: (setf list-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: list-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: list-state-tags-info INSTANCE
Function: (setf list-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: loop-body-item KEY TASK-BODY
Package

shop3

Source

loop-extensions.lisp (file)

Function: loop-body-item-inner KEY TASK-BODY
Package

shop3

Source

loop-extensions.lisp (file)

Function: loop-item KEY TASK-BODY
Package

shop3

Source

loop-extensions.lisp (file)

Function: looping-p TASK-NAME
Package

shop3

Source

loop-extensions.lisp (file)

Function: make-add-child-to-tree &key PARENT CHILD
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-add-dependencies DEPENDENCIES
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-bit-state ATOMS
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-cs-state &rest ARGLIST &key MODE ALTERNATIVES CURRENT-TASK
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-dependencies TREE-NODE DEPEND-LISTS HASH-TABLE
Package

shop3

Source

explicit-search.lisp (file)

Function: make-domain NAME-AND-OPTIONS &rest ITEMS
Package

shop3

Source

input.lisp (file)

Function: make-doubly-hashed-state ATOMS
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-hash-state ATOMS
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-list-state ATOMS
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-loop-state-expand &rest ARGLIST &key TOP-TASKS TASKS UNIFIER
Package

shop3

Source

loop-extensions.lisp (file)

Function: make-method-instantiation &rest ARGLIST &key UNIFIER TOP-TASKS TASKS
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-mixed-state ATOMS
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-operator &key (HEAD HEAD) (PRECONDITIONS PRECONDITIONS) (DELETIONS DELETIONS) (ADDITIONS ADDITIONS) (COST-FUN COST-FUN)
Package

shop3

Source

decls.lisp (file)

Function: make-operator-node &key (COST COST) (OPERATOR OPERATOR) (POSITION POSITION)
Package

shop3

Source

tree-reductions.lisp (file)

Function: make-pddl-action &key (HEAD HEAD) (PRECONDITION PRECONDITION) (EFFECT EFFECT) (COST-FUN COST-FUN)
Package

shop3

Source

pddl.lisp (file)

Function: make-plan-tree-for-task-net TASK-NET PARENT HASH-TABLE
Package

shop3

Source

explicit-search.lisp (file)

Function: make-prim-state-expand &rest ARGLIST &key TOP-TASKS TASKS PROTECTIONS PARTIAL-PLAN UNIFIER PARTIAL-PLAN-COST PARENT CHILD
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-primitive-node TASK COST POSITION
Package

shop3

Source

tree-accessors.lisp (file)

Function: make-pseudo-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT) (CHILDREN CHILDREN)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-raw-depend &key (PROP PROP) (EST EST)
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: make-record-expansion TASK-NODE
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-state-update &key (ACTION ACTION) (LITERAL LITERAL)
Package

shop3.common

Source

state-utils.lisp (file)

Function: make-tree-node &key (TASK TASK) (EXPANDED-TASK EXPANDED-TASK) (DEPENDENCIES DEPENDENCIES) (PARENT PARENT)
Package

plan-tree

Source

plan-tree.lisp (file)

Function: make-update-parent &key OLD-PARENT
Package

shop3

Source

backtrack-stack.lisp (file)

Function: make-world-state-tag &rest ARGLIST &key TAG
Package

shop3

Source

backtrack-stack.lisp (file)

Function: makedoubly-hashedstate &key (BODY BODY) (TAGS-INFO TAGS-INFO) (BLOCK-AT BLOCK-AT)
Package

shop3.common

Source

state-utils.lisp (file)

Function: makehashstate &key (BODY BODY) (TAGS-INFO TAGS-INFO) (BLOCK-AT BLOCK-AT)
Package

shop3.common

Source

state-utils.lisp (file)

Function: makeliststate &key (BODY BODY) (TAGS-INFO TAGS-INFO) (BLOCK-AT BLOCK-AT)
Package

shop3.common

Source

state-utils.lisp (file)

Function: makemixedstate &key (BODY BODY) (TAGS-INFO TAGS-INFO) (BLOCK-AT BLOCK-AT)
Package

shop3.common

Source

state-utils.lisp (file)

Function: merge-binding-set-lists BINDING-SETS1 BINDING-SETS2 &optional ORIGINAL-BINDING-SETS2
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: merge-binding-sets BINDING-SET1 BINDING-SET2
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: method-printer STR METHOD
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: method-sexp-p LST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: mixed-state-block-at INSTANCE
Function: (setf mixed-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: mixed-state-body INSTANCE
Function: (setf mixed-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: mixed-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: mixed-state-tags-info INSTANCE
Function: (setf mixed-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: new-symbol SYM
Package

shop3

Source

loop-extensions.lisp (file)

Function: node-children NODE NODES
Package

shop3

Source

tree-reductions.lisp (file)

Function: nshuffle-array ARRAY
Package

shop3

Source

decls.lisp (file)

Function: nshuffle-list LIST

Shuffle the list using an intermediate vector.

Package

shop3

Source

decls.lisp (file)

Function: occurs VARIABLE-NAME EXPR
Package

shop3.unifier

Source

unify.lisp (file)

Function: of-type-exprs VARS TYPES

Because SHOP3 doesn’t have the same typing, we take variables and their types and generate a list of distinguished propositions we can use in preconditions.

Package

shop3

Source

pddl.lisp (file)

Function: op-sexp-p LST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: operator-additions STRUCTURE
Function: (setf operator-additions) VALUE STRUCTURE
Package

shop3

Source

decls.lisp (file)

Function: operator-cost-fun STRUCTURE
Function: (setf operator-cost-fun) VALUE STRUCTURE
Package

shop3

Source

decls.lisp (file)

Function: operator-deletions STRUCTURE
Function: (setf operator-deletions) VALUE STRUCTURE
Package

shop3

Source

decls.lisp (file)

Function: operator-head STRUCTURE
Function: (setf operator-head) VALUE STRUCTURE
Package

shop3

Source

decls.lisp (file)

Function: operator-node-cost STRUCTURE
Function: (setf operator-node-cost) VALUE STRUCTURE
Package

shop3

Source

tree-reductions.lisp (file)

Function: operator-node-operator STRUCTURE
Function: (setf operator-node-operator) VALUE STRUCTURE
Package

shop3

Source

tree-reductions.lisp (file)

Function: operator-node-position STRUCTURE
Function: (setf operator-node-position) VALUE STRUCTURE
Package

shop3

Source

tree-reductions.lisp (file)

Function: operator-p X
Package

shop3

Source

decls.lisp (file)

Function: operator-preconditions STRUCTURE
Function: (setf operator-preconditions) VALUE STRUCTURE
Package

shop3

Source

decls.lisp (file)

Function: operator-printer STR OPERATOR
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: operator-sexp-p LST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: operator-task OPERATOR-NODE
Package

shop3

Source

tree-reductions.lisp (file)

Function: optimize-continue-p WHICH
Package

shop3

Source

search.lisp (file)

Function: ordered-tree-node-children INSTANCE
Function: (setf ordered-tree-node-children) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: ordered-tree-node-dependencies INSTANCE
Function: (setf ordered-tree-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: ordered-tree-node-expanded-task INSTANCE
Function: (setf ordered-tree-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: ordered-tree-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: ordered-tree-node-parent INSTANCE
Function: (setf ordered-tree-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: ordered-tree-node-task INSTANCE
Function: (setf ordered-tree-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: parse-pddl-method DOMAIN METHOD
Package

shop3

Source

pddl.lisp (file)

Function: parse-typed-list TYPED-LIST

Takes a typed-list (this is a PDDL construct) as argument and pulls out the declared items and types and returns two parallel lists of declared names and type names.

Package

shop3

Source

pddl.lisp (file)

Function: pddl-action-cost-fun STRUCTURE
Function: (setf pddl-action-cost-fun) VALUE STRUCTURE
Package

shop3

Source

pddl.lisp (file)

Function: pddl-action-effect STRUCTURE
Function: (setf pddl-action-effect) VALUE STRUCTURE
Package

shop3

Source

pddl.lisp (file)

Function: pddl-action-head STRUCTURE
Function: (setf pddl-action-head) VALUE STRUCTURE
Package

shop3

Source

pddl.lisp (file)

Function: pddl-action-p X
Package

shop3

Source

pddl.lisp (file)

Function: pddl-action-precondition STRUCTURE
Function: (setf pddl-action-precondition) VALUE STRUCTURE
Package

shop3

Source

pddl.lisp (file)

Function: pddl-satisfiers-for-exists DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: pddl-satisfiers-for-f-exp DOMAIN ARGUMENTS OTHER-GOALS STATE VAR-VAL-LIST LEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: pddl-satisfiers-for-forall DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: pddl-satisfiers-for-imply DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: pddl-satisfiers-for-not DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: plan-cost PLAN
Package

shop3

Source

output.lisp (file)

Function: plan-operator-nodes PLAN &optional N

This function translates operator expressions into operator nodes, assembling together the operator, its the position in the plan and cost.

Package

shop3

Source

tree-reductions.lisp (file)

Function: plan-tree-nodes BASE-NODES
Package

shop3

Source

tree-reductions.lisp (file)

Function: pprint-preconds STR PRECONDS
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: pprint-step STREAM STEP
Package

shop3

Source

plan-printer.lisp (file)

Function: pprint-task-net STR TASK-NET
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: prepare-choose-immediate-task-state STATE
Package

shop3

Source

explicit-search.lisp (file)

Function: primitive-symbol-p X
Package

shop3.unifier

Source

unify.lisp (file)

Function: primitive-tree-node-dependencies INSTANCE
Function: (setf primitive-tree-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: primitive-tree-node-expanded-task INSTANCE
Function: (setf primitive-tree-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: primitive-tree-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: primitive-tree-node-parent INSTANCE
Function: (setf primitive-tree-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: primitive-tree-node-task INSTANCE
Function: (setf primitive-tree-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: primitivep X

PRIMITIVEP returns T if X is a symbol whose name begins with #!

Package

shop3

Source

decls.lisp (file)

Function: print-current-plan ()
Package

shop3

Source

output.lisp (file)

Function: print-current-tasks ()
Package

shop3

Source

output.lisp (file)

Function: print-list-on-lines STR LIST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: print-list-suffix-lines STR LIST
Package

shop3-pprint

Source

shop-pprint.lisp (file)

Function: print-operator OPERATOR &optional STREAM
Package

shop3

Source

debugging.lisp (file)

Function: print-output-file PLAN
Package

shop3

Source

output.lisp (file)

Function: print-stats DEPTH PLANS TASKS INFERENCES RUNTIME REALTIME &optional STREAM
Package

shop3

Source

output.lisp (file)

Function: print-stats-header LABEL &optional STREAM
Package

shop3

Source

output.lisp (file)

Function: print1 OBJ
Package

shop3

Source

output.lisp (file)

Function: process-pddl-method-pre DOMAIN PRE

This is the main function that does the pre-processing, it looks through the preconditions finding the forall conditions and replacing the variables in that condition.

Package

shop3

Source

pddl.lisp (file)

Function: process-task-list TASKS
Package

shop3

Source

input.lisp (file)

Function: protection-ok STATE PROTECTIONS HEAD
Package

shop3

Source

protections.lisp (file)

Function: pseudo-node-children INSTANCE
Function: (setf pseudo-node-children) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pseudo-node-dependencies INSTANCE
Function: (setf pseudo-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pseudo-node-expanded-task INSTANCE
Function: (setf pseudo-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pseudo-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pseudo-node-parent INSTANCE
Function: (setf pseudo-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pseudo-node-task INSTANCE
Function: (setf pseudo-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: pull-tag-info TAGS-INFO TAG &optional STOP-AT
Package

shop3.common

Source

state-utils.lisp (file)

Function: query-current-state FIRST-SYMBOL
Package

shop3

Source

output.lisp (file)

Function: quotify X
Package

shop3

Source

decls.lisp (file)

Function: randomize-list LIST

Return a copy of LIST with all its members in a random order.

Package

shop3

Source

decls.lisp (file)

Function: raw-depend-p OBJECT
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: rd-est INSTANCE
Function: (setf rd-est) VALUE INSTANCE
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: rd-prop INSTANCE
Function: (setf rd-prop) VALUE INSTANCE
Package

shop3.theorem-prover

Source

decls.lisp (file)

Function: rd-union NEW-DEPENDS DEPENDENCIES
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: real-apply-substitution TARGET BINDING-LIST
Package

shop3.unifier

Source

unify.lisp (file)

Function: real-seek-satisfiers DOMAIN GOALS STATE VAR-VAL-LIST LEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: record-node-expansion TREE-NODE EXPANDED-TASK HASH-TABLE
Package

shop3

Source

explicit-search.lisp (file)

Function: record-operator TASK1 OPERATOR UNIFIER
Package

shop3

Source

tree-reductions.lisp (file)

Function: record-reduction TASK1 REDUCTION UNIFIER
Package

shop3

Source

tree-reductions.lisp (file)

Function: remove-subtree-from-table HASH-TABLE SUBTREE
Package

shop3

Source

explicit-search.lisp (file)

Function: rename-sym SYM RENAMING-TABLE
Package

shop3

Source

loop-extensions.lisp (file)

Function: replace-task-main-list ML T1 T2
Package

shop3

Source

task-reductions.lisp (file)

Function: replace-task-top-list L T1 T2
Package

shop3

Source

task-reductions.lisp (file)

Function: replan-from-failure DOMAIN FAILED-TREE-NODE SEARCH-STATE &key VERBOSE
Package

shop3

Source

plan-repair.lisp (file)

Function: report-no-method X STR
Package

shop3

Source

decls.lisp (file)

Function: report-task-arity-mismatch CONDITION STREAM
Package

shop3

Source

decls.lisp (file)

Function: rest-shop2-axiom-p AX
Package

shop3

Source

input.lisp (file)

Function: resymbol-task TSK RENAMING-TABLE
Package

shop3

Source

loop-extensions.lisp (file)

Function: search-tree ITEM TREE
Package

shop3

Source

input.lisp (file)

Function: seek-plans-primitive-1 DOMAIN TASK1 STATE TASKS TOP-TASKS DEPTH PROTECTIONS UNIFIER
Package

shop3

Source

search.lisp (file)

Function: seek-plans-stack STATE DOMAIN &key WHICH REPAIRABLE

Workhorse function for FIND-PLANS-STACK. Executes the SHOP3 search virtual machine, cycling through different virtual instructions depending on the value of the MODE slot of STATE.
Returns three values:
List of PLANS – currently there is always only one, but this complies with the return from conventional SHOP3.
List of PLAN-TREES – optional
List of indices into PLAN-TREES – optional, will be supplied if PLAN-TREES supplied.

Package

shop3

Source

explicit-search.lisp (file)

Function: setof-bagof-helper MODE DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: shop-trace-1 ITEMS
Package

shop3

Source

debugging.lisp (file)

Function: shop-trace-info ()

Information about the traced aspects of shop2.

Package

shop3

Source

debugging.lisp (file)

Function: shop-untrace-1 ITEMS
Package

shop3

Source

debugging.lisp (file)

Function: shop-untrace-all ()
Package

shop3

Source

debugging.lisp (file)

Function: shop2-axiom-p AX
Package

shop3

Source

input.lisp (file)

Function: stack-backjump STATE TARGET
Package

shop3

Source

explicit-search.lisp (file)

Function: stack-backtrack STATE

Chronological backtracking only, for now. Return the CHOICE-ENTRY where you stopped.

Package

shop3

Source

explicit-search.lisp (file)

Function: standard-satisfiers-for-and DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-assign DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-assign* DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-bagof DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-call DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-enforce DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-eval DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-exists DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-external DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-forall DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN &aux NEW-DEPENDENCIES
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-imply DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-not DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-or DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: standard-satisfiers-for-setof DOMAIN ARGUMENTS OTHER-GOALS STATE BINDINGS NEWLEVEL JUST1 DEPENDENCIES-IN
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: state-body INSTANCE
Function: (setf state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: state-update-action INSTANCE
Function: (setf state-update-action) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: state-update-literal INSTANCE
Function: (setf state-update-literal) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: state-update-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: static-bounds-p DOMAIN LOGICAL-EXPR
Package

shop3.theorem-prover

Source

theorem-prover.lisp (file)

Function: store-plan! PLAN STATE UNIFIER
Package

shop3

Source

search.lisp (file)

Function: strip-nops PLAN
Package

shop3

Source

task-reductions.lisp (file)

Function: strip-task-sexp TASK

Remove qualifiers like :TASK and :IMMEDIATE from TASK and return it.

Package

shop3

Source

explicit-search.lisp (file)

Function: strip-tree-tags TREE
Package

shop3

Source

tree-reductions.lisp (file)

Function: tagged-state-block-at INSTANCE
Function: (setf tagged-state-block-at) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: tagged-state-body INSTANCE
Function: (setf tagged-state-body) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: tagged-state-p OBJECT
Package

shop3.common

Source

state-utils.lisp (file)

Function: tagged-state-tags-info INSTANCE
Function: (setf tagged-state-tags-info) VALUE INSTANCE
Package

shop3.common

Source

state-utils.lisp (file)

Function: tagged-state-tags-info-tag TAGGED-STATE
Package

shop3.common

Source

state-utils.lisp (file)

Function: task-args TASK
Package

shop3

Source

tree-accessors.lisp (file)

Function: task-sexp-task-name TASK
Package

shop3

Source

explicit-search.lisp (file)

Function: test-plans-found STATE &key REPAIRABLE
Package

shop3

Source

explicit-search.lisp (file)

Function: time-expired-p ()
Package

shop3

Source

search.lisp (file)

Function: to-string NUM &optional MAX-DECIMAL
Package

shop3

Source

output.lisp (file)

Function: top-node-children INSTANCE
Function: (setf top-node-children) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-dependencies INSTANCE
Function: (setf top-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-expanded-task INSTANCE
Function: (setf top-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-lookup-table INSTANCE
Function: (setf top-node-lookup-table) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-parent INSTANCE
Function: (setf top-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: top-node-task INSTANCE
Function: (setf top-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: translate-fluent-precond DOMAIN EXPRESSION

Find the fluent comparison expressions in EXPRESSION and rewrite them into expressions of the form (FLUENT-CHECK <COMP-OP> <F-EXP> <F-EXP>) for the theorem-prover.

Package

shop3

Source

pddl.lisp (file)

Function: translate-include DOMAIN INCLUDE-ITEM
Package

shop3

Source

input.lisp (file)

Function: translate-metric-updates DOMAIN EXPRESSION
Package

shop3

Source

pddl.lisp (file)

Function: translate-pddl-quantifier EXPRESSION QUANTIFIER &optional DOMAIN

Translate EXPRESSION from PDDL quantifier (forall and exists) notation into SHOP3 quantifier notation (and adds some
(<type> <var>) conditions).

Package

shop3

Source

pddl.lisp (file)

Function: tree-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: typed-list-vars TYPED-LIST &optional DOMAIN

Takes a typed-list (this is a PDDL construct) as argument and pulls out the variables and types and returns two parallel lists of variable names and type names.

Package

shop3

Source

pddl.lisp (file)

Function: unify1 E1 E2
Package

shop3.unifier

Source

unify.lisp (file)

Function: unordered-tree-node-children INSTANCE
Function: (setf unordered-tree-node-children) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: unordered-tree-node-dependencies INSTANCE
Function: (setf unordered-tree-node-dependencies) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: unordered-tree-node-expanded-task INSTANCE
Function: (setf unordered-tree-node-expanded-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: unordered-tree-node-p OBJECT
Package

plan-tree

Source

plan-tree.lisp (file)

Function: unordered-tree-node-parent INSTANCE
Function: (setf unordered-tree-node-parent) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: unordered-tree-node-task INSTANCE
Function: (setf unordered-tree-node-task) VALUE INSTANCE
Package

plan-tree

Source

plan-tree.lisp (file)

Function: user-choose-task TASK-LIST UNIFIER &optional IMMEDIATE

Function called to allow a user to choose the next task for expansion, instead of SHOP2.

Package

shop3

Source

search.lisp (file)

Function: variable-name X
Package

shop3.unifier

Source

unify.lisp (file)

Function: variable-symbol-p X
Package

shop3.unifier

Source

unify.lisp (file)

Function: vars-boundp TREE &optional ACC
Package

shop3.theorem-prover

Source

prover.lisp (file)

Function: well-formed-listp L
Package

shop3

Source

task-reductions.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Generic functions

Generic Function: alternatives OBJECT
Generic Function: (setf alternatives) NEW-VALUE OBJECT
Package

shop3

Methods
Method: alternatives (CHOICE-ENTRY choice-entry)

automatically generated reader method

Source

backtrack-stack.lisp (file)

Method: alternatives (SEARCH-STATE search-state)

automatically generated reader method

Source

decls.lisp (file)

Method: (setf alternatives) NEW-VALUE (SEARCH-STATE search-state)

automatically generated writer method

Source

decls.lisp (file)

Generic Function: apply-method DOMAIN STATE TASK METHOD PROTECTIONS DEPTH IN-UNIFIER

If METHOD is applicable to TASK in STATE, then APPLY-METHOD returns the
resulting list of reductions. Otherwise it returns NIL.
PROTECTIONS are to be passed down the stack and checked whenever we apply an operator in the context of applying the METHOD.
DEPTH is used for tracing.
IN-UNIFIER will be applied to the TASK when applying the method.

Package

shop3

Source

decls.lisp (file)

Methods
Method: apply-method (DOMAIN domain) STATE TASK-BODY METHOD PROTECTIONS DEPTH IN-UNIFIER
Source

task-reductions.lisp (file)

Generic Function: argno CONDITION
Package

shop3.theorem-prover

Methods
Method: argno (CONDITION bad-argument)
Source

decls.lisp (file)

Method: argno (CONDITION instantiation-error)
Source

decls.lisp (file)

Generic Function: assign-domain-method-id DOMAIN METHOD METHOD-ID
Package

shop3

Source

decls.lisp (file)

Methods
Method: assign-domain-method-id (DOMAIN actions-domain-mixin) METHOD (METHOD-ID symbol)
Generic Function: atom-in-state-p ATOM STATE

Is the atom in the state?

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: atom-in-state-p ATOM (ST bit-state)
Source

state-utils.lisp (file)

Method: atom-in-state-p ATOM (ST doubly-hashed-state)
Source

state-utils.lisp (file)

Method: atom-in-state-p ATOM (ST mixed-state)
Source

state-utils.lisp (file)

Method: atom-in-state-p ATOM (ST hash-state)
Source

state-utils.lisp (file)

Method: atom-in-state-p ATOM (ST list-state)
Source

state-utils.lisp (file)

Generic Function: backtrack-stack OBJECT
Generic Function: (setf backtrack-stack) NEW-VALUE OBJECT
Package

shop3

Methods
Method: backtrack-stack (SEARCH-STATE search-state)

automatically generated reader method

Source

decls.lisp (file)

Method: (setf backtrack-stack) NEW-VALUE (SEARCH-STATE search-state)

automatically generated writer method

Source

decls.lisp (file)

Generic Function: branch-number CONDITION
Package

shop3

Methods
Method: branch-number (CONDITION singleton-variable)
Source

decls.lisp (file)

Generic Function: child OBJECT
Package

shop3

Methods
Method: child (ADD-CHILD-TO-TREE add-child-to-tree)

automatically generated reader method

Source

backtrack-stack.lisp (file)

Generic Function: comment CONDITION
Package

shop3.theorem-prover

Methods
Method: comment (CONDITION bad-argument)
Source

decls.lisp (file)

Generic Function: construct CONDITION
Package

shop3

Methods
Method: construct (CONDITION singleton-variable)
Source

decls.lisp (file)

Generic Function: construct-name CONDITION
Package

shop3

Methods
Method: construct-name (CONDITION singleton-variable)
Source

decls.lisp (file)

Generic Function: construct-type CONDITION
Package

shop3

Methods
Method: construct-type (CONDITION singleton-variable)
Source

decls.lisp (file)

Generic Function: correct-arity CONDITION
Package

shop3.theorem-prover

Methods
Method: correct-arity (CONDITION incorrect-arity-error)
Source

decls.lisp (file)

Generic Function: cost OBJECT
Generic Function: (setf cost) NEW-VALUE OBJECT
Package

shop3

Methods
Method: cost (SEARCH-STATE search-state)
Method: (setf cost) NEW-VALUE (SEARCH-STATE search-state)

Cost of partial-plan.

Source

decls.lisp (file)

Generic Function: current-task OBJECT
Generic Function: (setf current-task) NEW-VALUE OBJECT
Package

shop3

Methods
Method: current-task (CHOICE-ENTRY choice-entry)

automatically generated reader method

Source

backtrack-stack.lisp (file)

Method: current-task (SEARCH-STATE search-state)
Method: (setf current-task) NEW-VALUE (SEARCH-STATE search-state)

The currently active task, if that’s meaningful in this search MODE.

Source

decls.lisp (file)

Generic Function: dependencies OBJECT
Package

shop3

Methods
Method: dependencies (ADD-DEPENDENCIES add-dependencies)

automatically generated reader method

Source

backtrack-stack.lisp (file)

Generic Function: depth OBJECT
Generic Function: (setf depth) NEW-VALUE OBJECT
Package

shop3

Methods
Method: depth (SEARCH-STATE search-state)
Method: (setf depth) NEW-VALUE (SEARCH-STATE search-state)

Depth in search. Used by the tracing functions.

Source

decls.lisp (file)

Generic Function: do-backtrack STACK-ENTRY STATE

Update the STATE to restore the items recorded in STACK-ENTRY.

Package

shop3

Source

backtrack-stack.lisp (file)

Methods
Method: do-backtrack (ENTRY loop-state-expand) (STATE search-state)
Source

loop-extensions.lisp (file)

Method: do-backtrack (ENTRY record-expansion) (STATE search-state)
Method: do-backtrack (ENTRY choice-entry) (STATE search-state)
Method: do-backtrack (ENTRY prim-state-expand) (STATE search-state)
Method: do-backtrack (ENTRY add-child-to-tree) (STATE search-state)
Method: do-backtrack (ENTRY add-dependencies) (STATE search-state)
Method: do-backtrack (ENTRY method-instantiation) (STATE search-state)
Method: do-backtrack (ENTRY state-tag) (STATE search-state)
Generic Function: domain-include-parse PARENT-DOMAIN DOMAIN-NAME PATH

Return domain items from including DOMAIN-NAME found in PATH.

Package

shop3

Source

input.lisp (file)

Methods
Method: domain-include-parse (PARENT-DOMAIN simple-pddl-domain) DOMAIN-NAME PATH
Source

pddl.lisp (file)

Method: domain-include-parse (PARENT-DOMAIN domain) DOMAIN-NAME PATH
Generic Function: domain-method-id-lookup DOMAIN METHOD-ID
Package

shop3

Source

decls.lisp (file)

Methods
Method: domain-method-id-lookup (DOMAIN actions-domain-mixin) (METHOD-ID symbol)
Generic Function: domain-method-to-name-table OBJECT
Package

shop3

Methods
Method: domain-method-to-name-table (ACTIONS-DOMAIN-MIXIN actions-domain-mixin)

Map from methods (by object identity) to method IDs (symbols).

Source

decls.lisp (file)

Generic Function: domain-name-to-method-table OBJECT
Package

shop3

Methods
Method: domain-name-to-method-table (ACTIONS-DOMAIN-MIXIN actions-domain-mixin)

Map from method IDs (symbols) to methods.

Source

decls.lisp (file)

Generic Function: expand-loop ENGINE DOMAIN TASK1 STATE TASKS TOP-TASKS IN-UNIFIER &optional ESS-SEARCH-STATE
Package

shop3

Methods
Method: expand-loop (ENGINE (eql shop2)) DOMAIN TASK1 STATE TASKS TOP-TASKS IN-UNIFIER &optional ESS-SEARCH-STATE
Source

loop-extensions.lisp (file)

Method: expand-loop (ENGINE (eql ess)) DOMAIN TASK1 STATE TASKS TOP-TASKS IN-UNIFIER &optional ESS-SEARCH-STATE
Source

loop-extensions.lisp (file)

Generic Function: expand-loop-body BODY-KEY TASK-BODY DOMAIN STATE IN-UNIFIER SEARCH-STATE
Package

shop3

Methods
Method: expand-loop-body (BODY-KEY (eql cond2)) TASK-BODY DOMAIN STATE IN-UNIFIER SEARCH-STATE
Source

loop-extensions.lisp (file)

Method: expand-loop-body (BODY-KEY (eql for)) TASK-BODY DOMAIN STATE IN-UNIFIER SEARCH-STATE
Source

loop-extensions.lisp (file)

Method: expand-loop-body (BODY-KEY (eql cond)) TASK-BODY DOMAIN STATE IN-UNIFIER SEARCH-STATE
Source

loop-extensions.lisp (file)

Generic Function: expand-primitive-state STATE DOMAIN
Package

shop3

Source

explicit-search.lisp (file)

Methods
Method: expand-primitive-state STATE (DOMAIN domain)
Generic Function: expression CONDITION
Package

shop3.theorem-prover

Methods
Method: expression (CONDITION incomplete-dependency-error)
Source

decls.lisp (file)

Method: expression (CONDITION incorrect-arity-error)
Source

decls.lisp (file)

Method: expression (CONDITION non-ground-error)
Source

decls.lisp (file)

Generic Function: find-failed-choice-entry FAILED OBJ

Find and return the stack entry for the choice BEFORE the insertion of FAILED into the plan tree.

Package

shop3

Source

plan-repair.lisp (file)

Methods
Method: find-failed-choice-entry (FAILED complex-tree-node) (OBJ search-state)
Method: find-failed-choice-entry (FAILED complex-tree-node) (STACK list)
Generic Function: find-failed-stack-entry FAILED OBJ

Find and return the stack entry that corresponds to adding FAILED to the plan tree.

Package

shop3

Source

plan-repair.lisp (file)

Methods
Method: find-failed-stack-entry (FAILED complex-tree-node) (OBJ search-state)
Method: find-failed-stack-entry (FAILED complex-tree-node) (STACK list)
Generic Function: fluent-comparison-p DOMAIN OP
Package

shop3.theorem-prover

Source

fluents.lisp (file)

Methods
Method: fluent-comparison-p (DOMAIN fluents-mixin) (OP symbol)
Method: fluent-comparison-p (DOMAIN fluents-mixin) OP
Generic Function: fluent-expr-p DOMAIN EXPR
Package

shop3.theorem-prover

Source

fluents.lisp (file)

Methods
Method: fluent-expr-p (DOMAIN fluents-mixin) (VALUE number)
Method: fluent-expr-p (DOMAIN fluents-mixin) (EXPR list)
Method: fluent-expr-p (DOMAIN fluents-mixin) EXPR
Generic Function: fluent-function-p DOMAIN NAME
Package

shop3.theorem-prover

Source

fluents.lisp (file)

Methods
Method: fluent-function-p (DOMAIN fluents-mixin) (NAME symbol)
Method: fluent-function-p (DOMAIN fluents-mixin) NAME
Generic Function: fluent-functions OBJECT
Package

shop3.theorem-prover

Methods
Method: fluent-functions (FLUENTS-MIXIN fluents-mixin)

List of symbols naming metric fluent functions.

Source

fluents.lisp (file)

Generic Function: include-in-tag ACTION ATOM STATE

Add to the current tag a state update (characterized by ACTION) performed with ATOM (a literal) as operand.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: include-in-tag ACTION ATOM (ST tagged-state)
Source

state-utils.lisp (file)

Generic Function: initialize-problem PROBLEM &key STATE TASKS

Function that does the work of populating a problem. Allows the programmer of SHOP extensions to extend or override the normal problem-building.

Package

shop3

Source

decls.lisp (file)

Methods
Method: initialize-problem (PROBLEM problem) &key STATE TASKS
Source

input.lisp (file)

Generic Function: insert-atom ATOM STATE

Insert the atom into the state. The return value is
undefined. This function destructively modifies its state argument.
Note that an atom is NOT a lisp atom — it is actually a list of pred . args representing a first order logic positive literal.

Package

shop3.common

Source

state-decls.lisp (file)

Methods
Method: insert-atom ATOM (ST bit-state)
Source

state-utils.lisp (file)

Method: insert-atom ATOM (ST doubly-hashed-state)
Source

state-utils.lisp (file)

Method: insert-atom ATOM (ST mixed-state)
Source

state-utils.lisp (file)

Method: insert-atom ATOM (ST hash-state)
Source

state-utils.lisp (file)

Method: insert-atom ATOM (ST list-state)
Source

state-utils.lisp (file)

Generic Function: install-domain DOMAIN &optional REDEFINE-OK

Record DOMAIN for later retrieval.
Currently records the domain on the prop-list of the domain’s name. By default will warn if you redefine a domain. If REDEFINE-OK is non-nil, redefinition warnings will be quashed (handy for test suites).

Package

shop3

Source

decls.lisp (file)

Methods
Method: install-domain (DOMAIN domain) &optional REDEFINE-OK
Source

input.lisp (file)

Generic Function: logical-keywordp SYMBOL DOMAIN

Return true if the planning domain should interpret
symbol as a semantically meaningful logical connective, as opposed to an atomic predicate name.

IT IS STRONGLY RECOMMENDED that defmethod should NOT be used with this function! Instead, please use the def-logical-keyword macro.

Package

shop3.theorem-prover

Source

decls.lisp (file)

Methods
Method: logical-keywordp (G0 (eql f-exp-value)) (DOMAIN fluents-mixin)
Source

prover.lisp (file)

Method: logical-keywordp (G0 (eql imply)) (DOMAIN disjunctive-preconditions-mixin)