The shop3 Reference Manual

This is the shop3 Reference Manual, version 3.10.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Sep 15 06:41:44 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

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


2.1 shop3

License

Mozilla Public License

Version

3.10.0

Dependencies
  • shop3/common (system)., at least version (:read-file-form "shop-version.lisp-expr")
  • shop3/theorem-prover (system)., at least version (:read-file-form "shop-version.lisp-expr")
  • trivial-garbage (system).
  • alexandria (system).
  • iterate (system).
Source

shop3.asd.

Child Components

2.2 shop3/common

License

Mozilla Public License

Version

3.10.0

Dependencies
Source

shop3.asd.

Child Components

2.3 shop3/unifier

License

Mozilla Public License

Version

3.10.0

Dependency

alexandria (system).

Source

shop3.asd.

Child Components

2.4 shop3/theorem-prover

License

Mozilla Public License

Version

3.10.0

Dependencies
Source

shop3.asd.

Child Components

3 Modules

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


3.1 shop3/io

Dependency

decls.lisp (file).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

3.2 shop3/pddl

Dependency

io (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

3.3 shop3/search

Dependency

pddl (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

3.4 shop3/explicit-stack-search

Dependency

search (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

3.5 shop3/looping-tasks

Dependency

explicit-stack-search (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Component

loop-extensions.lisp (file).


3.6 shop3/tree

Dependency

looping-tasks (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

3.7 shop3/minimal-subtree

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

Dependency

tree (module).

Source

shop3.asd.

Parent Component

shop3 (system).

Child Components

4 Files

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


4.1 Lisp


4.1.1 shop3/shop3.asd

Source

shop3.asd.

Parent Component

shop3 (system).

ASDF Systems
Packages

shop-asd.

Public Interface

operation-done-p (method).

Internals

4.1.2 shop3/package.lisp

Source

shop3.asd.

Parent Component

shop3 (system).

Packages

4.1.3 shop3/decls.lisp

Dependency

package.lisp (file).

Source

shop3.asd.

Parent Component

shop3 (system).

Public Interface
Internals

4.1.4 shop3/io/input.lisp

Source

shop3.asd.

Parent Component

io (module).

Public Interface
Internals

4.1.5 shop3/io/output.lisp

Source

shop3.asd.

Parent Component

io (module).

Public Interface

print-current-state (function).

Internals

4.1.6 shop3/io/debugging.lisp

Source

shop3.asd.

Parent Component

io (module).

Public Interface
Internals

4.1.7 shop3/io/shop-pprint.lisp

Source

shop3.asd.

Parent Component

io (module).

Packages

shop3-pprint.

Internals

4.1.8 shop3/pddl/decls.lisp

Source

shop3.asd.

Parent Component

pddl (module).

Internals

+pddl-requirements-keywords+ (special variable).


4.1.9 shop3/pddl/fluents.lisp

Dependency

decls.lisp (file).

Source

shop3.asd.

Parent Component

pddl (module).

Internals

4.1.10 shop3/pddl/pddl.lisp

Dependency

fluents.lisp (file).

Source

shop3.asd.

Parent Component

pddl (module).

Public Interface
Internals

4.1.11 shop3/pddl/prover.lisp

Dependency

pddl.lisp (file).

Source

shop3.asd.

Parent Component

pddl (module).

Internals

4.1.12 shop3/search/protections.lisp

Source

shop3.asd.

Parent Component

search (module).

Internals

4.1.13 shop3/search/task-reductions.lisp

Source

shop3.asd.

Parent Component

search (module).

Public Interface
Internals

4.1.14 shop3/search/search.lisp

Source

shop3.asd.

Parent Component

search (module).

Public Interface
Internals

4.1.15 shop3/search/plan-trajectory.lisp

Source

shop3.asd.

Parent Component

search (module).

Public Interface

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

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Public Interface
Internals

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

Dependency

plan-tree.lisp (file).

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Public Interface
Internals

4.1.18 shop3/explicit-stack-search/prepare-return-values.lisp

Dependency

decls.lisp (file).

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Public Interface

prepare-return-values (function).

Internals

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

Dependency

prepare-return-values.lisp (file).

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Public Interface

print-object (method).

Internals

4.1.20 shop3/explicit-stack-search/analogical-replay.lisp

Dependency

backtrack-stack.lisp (file).

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Internals

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

Dependency

analogical-replay.lisp (file).

Source

shop3.asd.

Parent Component

explicit-stack-search (module).

Public Interface
Internals

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

Source

shop3.asd.

Parent Component

looping-tasks (module).

Internals

4.1.23 shop3/tree/tree-accessors.lisp

Source

shop3.asd.

Parent Component

tree (module).

Public Interface
Internals

4.1.24 shop3/tree/tree-reductions.lisp

Dependency

tree-accessors.lisp (file).

Source

shop3.asd.

Parent Component

tree (module).

Internals

4.1.25 shop3/minimal-subtree/package.lisp

Source

shop3.asd.

Parent Component

minimal-subtree (module).

Packages

shop3-minimal-subtree.


4.1.26 shop3/minimal-subtree/decls.lisp

Dependency

package.lisp (file).

Source

shop3.asd.

Parent Component

minimal-subtree (module).

Public Interface

find-failed-task (generic function).


4.1.27 shop3/minimal-subtree/minimal-subtree.lisp

Dependency

decls.lisp (file).

Source

shop3.asd.

Parent Component

minimal-subtree (module).

Public Interface
Internals

4.1.28 shop3/plan-repair.lisp

Dependencies
Source

shop3.asd.

Parent Component

shop3 (system).

Public Interface

repair-plan (function).

Internals

4.1.29 shop3/shop3.lisp

Dependency

plan-repair.lisp (file).

Source

shop3.asd.

Parent Component

shop3 (system).

Public Interface

find-plans (function).

Internals

4.1.30 shop3/plan-printer.lisp

Dependencies
Source

shop3.asd.

Parent Component

shop3 (system).

Public Interface

pprint-plan (function).

Internals

pprint-step (function).


4.1.31 shop3/common/package-common.lisp

Source

shop3.asd.

Parent Component

shop3/common (system).

Packages

4.1.32 shop3/common/common.lisp

Dependency

package-common.lisp (file).

Source

shop3.asd.

Parent Component

shop3/common (system).

Public Interface

4.1.33 shop3/common/state-decls.lisp

Dependency

common.lisp (file).

Source

shop3.asd.

Parent Component

shop3/common (system).

Public Interface
Internals

4.1.34 shop3/common/state-utils.lisp

Dependency

state-decls.lisp (file).

Source

shop3.asd.

Parent Component

shop3/common (system).

Public Interface
Internals

4.1.35 shop3/common/tagged-state.lisp

Dependency

state-utils.lisp (file).

Source

shop3.asd.

Parent Component

shop3/common (system).

Public Interface
Internals

4.1.36 shop3/unifier/package-unifier.lisp

Source

shop3.asd.

Parent Component

shop3/unifier (system).

Packages

shop3.unifier.


4.1.37 shop3/unifier/tracer.lisp

Dependency

package-unifier.lisp (file).

Source

shop3.asd.

Parent Component

shop3/unifier (system).

Public Interface

4.1.38 shop3/unifier/unify.lisp

Dependency

tracer.lisp (file).

Source

shop3.asd.

Parent Component

shop3/unifier (system).

Public Interface
Internals

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

Source

shop3.asd.

Parent Component

shop3/theorem-prover (system).

Packages

shop3.theorem-prover.


4.1.40 shop3/theorem-prover/decls.lisp

Dependency

package-thpr.lisp (file).

Source

shop3.asd.

Parent Component

shop3/theorem-prover (system).

Public Interface
Internals

4.1.41 shop3/theorem-prover/theorem-prover.lisp

Dependency

decls.lisp (file).

Source

shop3.asd.

Parent Component

shop3/theorem-prover (system).

Public Interface
Internals

5 Packages

Packages are listed by definition order.


5.1 shop-asd

Source

shop3.asd.

Nicknames
  • shop2-asd
  • shop3-asd
Use List
  • asdf/interface.
  • common-lisp.
Internals

5.2 shop3.theorem-prover

Source

package-thpr.lisp.

Nicknames
  • shopthpr
  • shop.theorem-prover
Use List
Used By List

shop3.

Public Interface
Internals

5.3 plan-tree

Source

package.lisp.

Nickname

shop-extended-plan-tree

Use List
  • common-lisp.
  • iterate.
Used By List

shop3-minimal-subtree.

Public Interface
Internals

5.4 shop3.common

Source

package-common.lisp.

Nicknames
  • shop3cmn
  • shop.common
  • shop2.common
Use List
Used By List
Public Interface
Internals

5.5 shop3-pprint

Source

shop-pprint.lisp.

Nickname

shop2-pprint

Use List
  • common-lisp.
  • iterate.
  • shop3.
Internals

5.6 shop3-minimal-subtree

Source

package.lisp.

Nicknames
  • shop-minimal-subtree
  • subtree
  • shop2-minimal-subtree
Use List
Public Interface

find-failed-task (generic function).

Internals

5.7 %shop3-common-private%

Source

package-common.lisp.


5.8 shop3-user

SHOP3-USER is a "scratch" package for
experimenting with the SHOP3 API. Typically any real work should be moved to a dedicated package you create for yourself.

Source

package.lisp.

Nicknames
  • shop-user
  • shop2-user
Use List

5.9 shop3.unifier

Source

package-unifier.lisp.

Nicknames
  • shopunif
  • shop2.unifier
  • shop.unifier
Use List

common-lisp.

Used By List
Public Interface
Internals

5.10 prepare-return-values

Source

package.lisp.

Nickname

prv

Use List
  • common-lisp.
  • iterate.
Public Interface

prepare-return-values (function).

Internals

5.11 shop3

The SHOP3 package is the package that exposes SHOP3’s API.

Source

package.lisp.

Nicknames
  • shop
  • shop2
Use List
Used By List
Public Interface
Internals

6 Definitions

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


6.1 Public Interface


6.1.1 Special variables

Special Variable: *attribution-list*
Package

shop3.common.

Source

common.lisp.

Special Variable: *current-state*
Package

shop3.common.

Source

common.lisp.

Special Variable: *defdomain-verbose*
Package

shop3.

Source

input.lisp.

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.

Special Variable: *domain*

Default domain to use when planning.

Package

shop3.theorem-prover.

Source

decls.lisp.

Special Variable: *establishers*
Package

shop3.theorem-prover.

Source

decls.lisp.

Special Variable: *external-access*
Package

shop3.common.

Source

common.lisp.

Special Variable: *inferences*
Package

shop3.common.

Source

common.lisp.

Special Variable: *literals*
Package

shop3.theorem-prover.

Source

decls.lisp.

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.

Special Variable: *shop-trace*
Package

shop3.unifier.

Source

tracer.lisp.

Special Variable: *shop-trace-stream*
Package

shop3.unifier.

Source

tracer.lisp.

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.

Special Variable: *state-encoding*
Package

shop3.common.

Source

common.lisp.

Special Variable: *trace-query*
Package

shop3.unifier.

Source

tracer.lisp.

Special Variable: *which*
Package

shop3.

Source

decls.lisp.


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.

Macro: call (fn &rest params)
Package

shop3.common.

Source

decls.lisp.

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.

Macro: def-problem-set (list-name problem-list)
Package

shop3.

Source

input.lisp.

Macro: defdomain (name-and-options items)
Package

shop3.

Source

input.lisp.

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.

Macro: shop-fail ()
Package

shop3.common.

Source

common.lisp.

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.

Macro: shop-untrace (&rest items)

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

Package

shop3.

Source

debugging.lisp.

Macro: trace-print (type item state &rest formats)
Package

shop3.unifier.

Source

tracer.lisp.

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.

Macro: unify-fail-p (e1 e2)

Better-named alias for UNIFY-FAIL.

Package

shop3.unifier.

Source

unify.lisp.

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.

Macro: variable-p (x)

An alias for VARIABLEP, for more consistent naming.

Package

shop3.unifier.

Source

unify.lisp.


6.1.3 Ordinary functions

Function: all-primitive-nodes (tree)
Package

shop3.

Source

tree-accessors.lisp.

Function: anonymous-var-p (x)

Does X name an anonymous variable?

Package

shop3.unifier.

Source

unify.lisp.

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.

Reader: binding-val (instance)

Binding structure accessor

Package

shop3.unifier.

Source

unify.lisp.

Target Slot

val.

Writer: (setf binding-val) (instance)
Package

shop3.unifier.

Source

unify.lisp.

Target Slot

val.

Reader: binding-var (instance)

Binding structure accessor

Package

shop3.unifier.

Source

unify.lisp.

Target Slot

var.

Writer: (setf binding-var) (instance)
Package

shop3.unifier.

Source

unify.lisp.

Target Slot

var.

Function: complex-node-children (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: (setf complex-node-children) (structure)
Package

shop3.

Source

tree-accessors.lisp.

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.

Function: complex-node-task (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: (setf complex-node-task) (structure)
Package

shop3.

Source

tree-accessors.lisp.

Reader: complex-tree-node-children (instance)
Writer: (setf complex-tree-node-children) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

children.

Reader: complex-tree-node-method-name (instance)
Writer: (setf complex-tree-node-method-name) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

method-name.

Function: compose-substitutions (sub1 sub2)
Package

shop3.unifier.

Source

unify.lisp.

Reader: consumer (instance)
Writer: (setf consumer) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

consumer.

Function: copy-plan-tree (plan-tree lookup-table translation-table)

Make a new copy of PLAN-TREE (indexed by LOOKUP-TABLE), and using the input TRANSLATION-TABLE, which translates old primitive tasks to new primitive tasks.

Package

plan-tree.

Source

plan-tree.lisp.

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.

Function: decode-tag (tag)
Package

shop3.common.

Source

tagged-state.lisp.

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

shop3.common.

Source

tagged-state.lisp.

Function: delete-tag-map (tag)

Erase association of TAG with its operator/action instance.

Package

shop3.common.

Source

tagged-state.lisp.

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.

Reader: establisher (instance)
Writer: (setf establisher) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

establisher.

Function: explain-satisfier (unified-goal state &key external domain)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: extract-variables (expr)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

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.

Function: find-all-complex-node-if (fun tree)

Return a complex node whose TASK satisfies FUN.

Package

shop3.

Source

tree-accessors.lisp.

Function: find-all-primitive-nodes-if (fun tree)

Return a list of all primitive nodes whose TASK satisfies FUN.

Package

shop3.

Source

tree-accessors.lisp.

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.

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.

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.

Function: find-plan-step (task plan-tree &optional plan-tree-hash)
Package

plan-tree.

Source

plan-tree.lisp.

Function: find-plans (problem &rest options &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 plan-num-limit &allow-other-keys)

FIND-PLANS looks for solutions to the planning PROBLEM.
PROBLEM should be a problem-designator (a PROBLEM or a symbol naming one).
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(s) found
(up to *plan-num-limit*).
: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. Returns plan(s) found by random selection (subject to *plan-num-limit*).
Used by Monroe. Not for normal SHOP3 domains, since
normal SHOP3 domains have order-dependent semantics.

: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.
:PLAN-NUM-LIMIT is an int greater than or equal to 1 (its default value) specifying a limit on the number of plans to generate.
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.

Function: find-plans-stack (problem &key domain verbose plan-tree gc no-dependencies repairable rationale state-type out-stream which plan-num-limit analogical-replay unpack-returns make-analogy-table)

Top level search function for explicit-state search in SHOP3.
Does not support the full range of options supported by SHOP3’s ‘find-plans-stack‘.

Keyword arguments:
* domain : either a domain name (symbol) or a ‘shop:domain‘ object.
* verbose : 0, 1, 2, 3; default 0
* plan-tree : build and return a plan tree? (‘plan-tree:top-node‘),
defaults to ‘nil‘.
* gc : If possible, perform a full GC before starting to plan. Default: current value of ‘shop:*gc*‘.
* no-dependencies : if building a plan tree, build it *without* causal dependencies. Default: ‘nil‘.
* repairable : return plans that can be repaired. Default: ‘nil‘.
* rationale : build a plan tree with rationale information. Default: ‘nil‘. * state-type : what state type should be used for representing world states? (Note: world-state/SHOP state, *not* search-state). Default: ‘:mixed‘. * out-stream : where should output be printed. Default: ‘t‘ (standard output). * which : What/how many plans should be returned? Supports only ‘:first‘ (the default) and ‘:all‘.
* plan-num-limit: an int greater than or equal to 1 (its default value) specifying a limit on the number of plans to generate.
* analogical-replay : Do search informed by the contents of the ‘*analogical-replay-table*‘. Default: ‘nil‘.
* make-analogy-table : Populate ‘*analogical-replay-table*‘ while planning. Only works with ‘:which‘ = ‘:first‘. Default: ‘nil‘.
* unpack-returns : If true, return values in a way compatible with ‘find-plans‘. If false, return a list of ‘plan-return‘ objects instead. See discussion of return values, below. Default: ‘t‘.

Return values:
There are two possible return types, selected by the keyword argument ‘unpack-returns‘:

1. Default/compatible with ‘find-plans‘:
* List of plans
* List of plan trees (if computed)
* List of plan tree lookup tables
* List of final world states
* List of analogical replay tables (if computed)
To comply with SHOP3, 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 true.
Returns the values returned by SEEK-PLANS-STACK, qv.

2. If UNPACK-RETURNS is NIL, then return one or more appropriate PLAN-RETURN objects.

Package

shop3.

Source

explicit-search.lisp.

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.

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.

Function: find-problem (name-or-problem &optional errorp)
Package

shop3.

Source

decls.lisp.

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.

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.

Function: find-tree-node-if (function plan-tree)
Package

plan-tree.

Source

plan-tree.lisp.

Function: fix-uninterned-bindings (bindings query-vars)
Package

shop3.unifier.

Source

unify.lisp.

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.

Function: get-problems (name &key print)

Get the list of problems for the problem set named NAME

Package

shop3.

Source

input.lisp.

Function: groundp (literal)

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

Package

shop3.unifier.

Source

unify.lisp.

Function: internal-operator-p (operator-name)
Package

shop3.

Source

task-reductions.lisp.

Function: make-binding (var val)
Package

shop3.unifier.

Source

unify.lisp.

Function: make-binding-list (variables values)

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

Package

shop3.unifier.

Source

unify.lisp.

Function: make-complex-node (task children)
Package

shop3.

Source

tree-accessors.lisp.

Function: make-complex-tree-node (&key task expanded-task dependencies parent children method-name)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-dependency (&key establisher consumer prop)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-ordered-tree-node (&key task expanded-task dependencies parent children method-name)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-primitive-tree-node (&key task expanded-task dependencies parent)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-problem (problem-name-etc state tasks &rest extras)

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.

Function: make-problem-set (list-name problem-list)
Package

shop3.

Source

input.lisp.

Function: make-tag-map (tag task primitive)

Record association of TAG with operator/action instance OPERATOR.

Package

shop3.common.

Source

tagged-state.lisp.

Function: make-top-node (&key task expanded-task dependencies parent children method-name lookup-table)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-unordered-tree-node (&key task expanded-task dependencies parent children method-name)
Package

plan-tree.

Source

plan-tree.lisp.

Function: node-parent (node tree)

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

Package

shop3.

Source

tree-accessors.lisp.

Function: plan-final-state (plan &key domain problem initial-state)
Package

shop3.

Source

plan-trajectory.lisp.

Function: plan-states (plan &key domain problem)

Return a trajectory of states corresponding to the plan-sequence. The trajectory will be a list of states in which each state will be a list of atoms.

DOMAIN is a domain designator. PROBLEM is a SHOP problem designator. The PROBLEM keyword argument is *mandatory*. It must also be possible to find a domain, but this can be done either by supplying it directly, or taking it from the problem.

Package

shop3.

Source

plan-trajectory.lisp.

Function: pprint-plan (plan &optional stream)
Package

shop3.

Source

plan-printer.lisp.

Function: prepare-return-values (plan &key plan-tree bindings)

Take the PLAN and PLAN-TREE and create new PLAN and PLAN-TREE objects, copies of the originals, with the BINDINGS applied.

Package

prepare-return-values.

Source

prepare-return-values.lisp.

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

shop3.common.

Source

tagged-state.lisp.

Function: primitive-node-cost (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: (setf primitive-node-cost) (structure)
Package

shop3.

Source

tree-accessors.lisp.

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.

Function: primitive-node-position (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: (setf primitive-node-position) (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: primitive-node-task (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: (setf primitive-node-task) (structure)
Package

shop3.

Source

tree-accessors.lisp.

Function: print-axioms (&optional name domain)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: print-belief-state-readably (belief-state &optional stream)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: print-current-state (&key sorted state)
Package

shop3.

Source

output.lisp.

Function: print-methods (&optional name domain)
Package

shop3.

Source

debugging.lisp.

Function: print-operators (&optional name domain)
Package

shop3.

Source

debugging.lisp.

Function: process-axiom (domain axiom)
Package

shop3.

Source

input.lisp.

Reader: prop (instance)
Writer: (setf prop) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

prop.

Function: prop-sorter (p1 p2)

Function that can be used inside CL:SORT to sort SHOP literals alphabetically for easier human inspection.

Package

shop3.common.

Source

state-utils.lisp.

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.

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.

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.

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.

Function: shop-trace-info ()

Information about the traced aspects of shop3.

Package

shop3.

Source

debugging.lisp.

Function: shop-union (s1 s2 &key test key)
Package

shop3.unifier.

Source

unify.lisp.

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.

Function: standardize (expr &optional subs)

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

Package

shop3.unifier.

Source

unify.lisp.

Function: tag-for-action (action)
Package

shop3.common.

Source

tagged-state.lisp.

Function: task-name (task)
Package

shop3.

Source

tree-accessors.lisp.

Reader: tree-node-dependencies (instance)
Writer: (setf tree-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

dependencies.

Reader: tree-node-expanded-task (instance)
Writer: (setf tree-node-expanded-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

expanded-task.

Reader: tree-node-parent (instance)
Writer: (setf tree-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

parent.

Reader: tree-node-task (instance)
Writer: (setf tree-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

task.

Function: tree-node-task (tree-node)
Setf Expander: (setf tree-node-task) (tree-node)
Package

shop3.

Source

tree-accessors.lisp.

Function: tree-node-task-name (tree-node)
Package

shop3.

Source

tree-accessors.lisp.

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.

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.

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 file designators. 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.

Function: variable-gensym (&optional base-name)

Return a new variable, made from BASE-NAME

Package

shop3.unifier.

Source

unify.lisp.

Function: variablep (x)

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

Package

shop3.unifier.

Source

unify.lisp.

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.


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.

Methods
Method: add-atom-to-state (atom (st tagged-state) depth operator)
Source

tagged-state.lisp.

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.

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.

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.

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.

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.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

Generic Reader: default-state-type (object)
Package

shop3.theorem-prover.

Methods
Reader Method: default-state-type ((thpr-domain thpr-domain))

automatically generated reader method

Source

decls.lisp.

Target Slot

default-state-type.

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.

Methods
Method: delete-atom-from-state (atom (st tagged-state) depth operator)
Source

tagged-state.lisp.

Generic Function: delete-domain (domain-desig)
Package

shop3.

Source

input.lisp.

Methods
Method: delete-domain ((domain domain))
Method: delete-domain ((domain-name symbol))
Generic Function: delete-problem (problem)
Package

shop3.

Source

decls.lisp.

Methods
Method: delete-problem ((problem-name symbol))
Method: delete-problem ((problem problem))
Generic Reader: domain-axioms (object)
Package

shop3.theorem-prover.

Methods
Reader Method: domain-axioms ((has-axioms-mixin has-axioms-mixin))

automatically generated reader method

Source

decls.lisp.

Target Slot

axioms.

Generic Function: domain-methods (domain)

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

Package

shop3.

Source

decls.lisp.

Methods
Reader Method: domain-methods ((actions-domain-mixin actions-domain-mixin))

automatically generated reader method

Target Slot

methods.

Method: domain-methods ((domain-name symbol))
Generic Function: domain-name (object)
Package

shop3.common.

Methods
Method: domain-name ((probspec symbol))
Source

decls.lisp.

Reader 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.

Target Slot

domain-name.

Reader Method: domain-name ((thpr-domain thpr-domain))

automatically generated reader method

Source

decls.lisp.

Target Slot

domain-name.

Generic Function: domain-operators (domain)

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

Package

shop3.

Source

decls.lisp.

Methods
Reader Method: domain-operators ((actions-domain-mixin actions-domain-mixin))

automatically generated reader method

Target Slot

operators.

Method: domain-operators ((domain-name symbol))
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.

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.

Method: find-failed-task ((domain symbol) plan plan-tree executed divergence &key plan-tree-hash)
Source

minimal-subtree.lisp.

Method: find-failed-task :around ((domain symbol) plan plan-tree executed divergence &key plan-tree-hash)
Source

minimal-subtree.lisp.

Generic Function: get-state (problem)
Package

shop3.

Source

decls.lisp.

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

shop3.

Source

decls.lisp.

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.

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

input.lisp.

Generic Function: has-static-preds-p (domain)
Package

shop3.theorem-prover.

Source

decls.lisp.

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.

Methods
Method: last-establisher ((st tagged-state) literal)
Source

tagged-state.lisp.

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.

Methods
Method: make-initial-state :around ((domain fluents-mixin) state-encoding atoms &key)

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

Source

pddl.lisp.

Method: make-initial-state (domain (state-encoding (eql :bit)) atoms &key)
Source

state-utils.lisp.

Method: make-initial-state (domain (state-encoding (eql :doubly-hashed)) atoms &key)
Source

state-utils.lisp.

Method: make-initial-state (domain (state-encoding (eql :mixed)) atoms &key)
Source

state-utils.lisp.

Method: make-initial-state (domain (state-encoding (eql :hash)) atoms &key)
Source

state-utils.lisp.

Method: make-initial-state (domain (state-encoding (eql :list)) atoms &key)
Source

state-utils.lisp.

Generic Function: methods (domain task-name)

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

Package

shop3.

Source

decls.lisp.

Methods
Method: methods ((domain domain) (task-name symbol))
Method: methods ((domain symbol) task-name)
Method: methods :around (domain task-name)
Generic Reader: name (object)
Package

shop3.common.

Methods
Reader Method: name ((problem problem))

automatically generated reader method

Source

decls.lisp.

Target Slot

name.

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.

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

pddl.lisp.

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

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

Source

pddl.lisp.

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

pddl.lisp.

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

input.lisp.

Generic Function: plan-tree->sexp (plan-tree)

Translate PLAN-TREE into an s-expression for export to other systems.

Package

plan-tree.

Source

plan-tree.lisp.

Methods
Method: plan-tree->sexp ((top top-node))
Method: plan-tree->sexp ((cn complex-tree-node))
Method: plan-tree->sexp ((on ordered-tree-node))
Method: plan-tree->sexp ((un unordered-tree-node))
Method: plan-tree->sexp ((pn primitive-tree-node))
Generic Reader: problem-name (object)
Package

shop3.

Methods
Reader Method: problem-name ((problem problem))

automatically generated reader method

Source

decls.lisp.

Target Slot

name.

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.

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

input.lisp.

Method: process-method ((domain domain) method)
Source

input.lisp.

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.

Methods
Method: process-op ((domain domain) operator)
Source

input.lisp.

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.

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

input.lisp.

Generic Function: query (goals state &key just-one domain return-dependencies record-dependencies state-type)

Find and return a list of binding lists that represents the answer to goals. QUERY is a more convenient top-level alternative to FIND-SATISFIERS, the function used internally by SHOP3.

Parameters:

GOALS
A list of goals; implicitly a conjunction (this may change).
STATE
A SHOP3 state object with the currently-true facts or a list of positive literals to be assembled into a state.
JUST-ONE
Boolean: If true, return only one solution instead of all solutions.
DOMAIN
A SHOP3 Theorem-prover domain designator.
RETURN-DEPENDENCIES
Boolean: If true, return dependencies (establishing actions)
for the answer(s).
RECORD-DEPENDENCIES
Deprecated synonym for RETURN-DEPENDENCIES.
STATE-TYPE
If supplied, and the state is a list of facts, what sort of state should query create from the facts?
Returns:

ANSWERS
List of answers for the query. Each answer is a list of variable bindings for the variables in the query (GOALS).
DEPENDENCIES
Optional. List of dependencies, one for each of the answers in the query.

Note: Manages optional arguments and ensures that the variable property
is properly set in GOALS.

Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Methods
Method: query :around (goals state &key just-one domain return-dependencies record-dependencies state-type)
Source

input.lisp.

Method: query (goals state &key just-one domain return-dependencies record-dependencies)
Generic Function: replay-state-changes (state update-list &optional stop-at)
Package

shop3.common.

Source

state-decls.lisp.

Methods
Method: replay-state-changes ((st tagged-state) tags-info-list &optional stop-at)
Source

tagged-state.lisp.

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.

Methods
Method: retract-state-changes ((st tagged-state) tag)
Source

tagged-state.lisp.

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.

Methods
Method: seek-plans-null ((domain domain) state which-plans partial-plan partial-plan-cost depth unifier)
Source

search.lisp.

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.

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.

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.

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.

Methods
Method: sort-methods :around ((domain domain) (methods list) (which-plans symbol))
Source

explicit-search.lisp.

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.

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.

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 Reader: source-pddl-domain (object)
Package

shop3.

Methods
Reader Method: source-pddl-domain ((simple-pddl-domain simple-pddl-domain))

automatically generated reader method

Source

pddl.lisp.

Target Slot

source-pddl-domain.

Generic Reader: state (object)
Generic Writer: (setf state) (object)
Package

shop3.common.

Methods
Reader Method: state ((search-state search-state))
Writer Method: (setf state) ((search-state search-state))

SHOP2 world state object.

Source

decls.lisp.

Target Slot

world-state.

Generic Function: state->state-type (state)

Return the state-type keyword for STATE.

Package

shop3.common.

Source

state-decls.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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.

Methods
Method: state-all-atoms-for-predicate ((st bit-state) pred)
Source

state-utils.lisp.

Method: state-all-atoms-for-predicate ((st doubly-hashed-state) pred)
Source

state-utils.lisp.

Method: state-all-atoms-for-predicate ((st mixed-state) pred)
Source

state-utils.lisp.

Method: state-all-atoms-for-predicate ((st hash-state) pred)
Source

state-utils.lisp.

Method: state-all-atoms-for-predicate ((st list-state) pred)
Source

state-utils.lisp.

Generic Function: state-atoms (state)

Return the atoms of the state in a plain list

Package

shop3.common.

Source

state-decls.lisp.

Methods
Reader Method: state-atoms ((problem problem))

automatically generated reader method

Source

decls.lisp.

Target Slot

state-atoms.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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

state-utils.lisp.

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.

Methods
Method: state-trajectory ((st tagged-state) &key sorted)
Source

state-utils.lisp.

Generic Reader: static-preds (domain)

Return a list of predicate names for static predicates.

Package

shop3.theorem-prover.

Source

decls.lisp.

Methods
Reader Method: static-preds ((static-predicates-mixin static-predicates-mixin))

automatically generated reader method

Target Slot

static-preds.

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.

Methods
Method: tag-state ((st tagged-state) &optional increment)
Source

tagged-state.lisp.

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.

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.

Methods
Method: trigger-trace ((keyword (eql :tasks)) (item symbol))
Source

debugging.lisp.

Method: trigger-trace ((keyword (eql :goals)) (item symbol))
Source

debugging.lisp.

Method: trigger-trace ((keyword (eql :axioms)) (item symbol))
Source

debugging.lisp.

Method: trigger-trace ((keyword (eql :methods)) (item symbol))
Source

debugging.lisp.

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.

Methods
Method: validator-export ((domain domain) (plan list) stream)

6.1.5 Standalone methods

Method: make-load-form ((obj top-node) &optional environment)
Source

plan-tree.lisp.

Method: make-load-form ((obj binding) &optional env)
Source

unify.lisp.

Method: make-load-form ((problem problem) &optional environment)
Source

decls.lisp.

Method: operation-done-p ((o compile-op) (c tester-cl-source-file))

We are crushing the normal operation-done-p for compile-op, so that the tester files get recompiled, to take into account any changes to shop3.

Package

asdf/action.

Source

shop3.asd.

Method: print-object ((d dependency) str)
Source

plan-tree.lisp.

Method: print-object ((d top-node) str)
Source

plan-tree.lisp.

Method: print-object ((d unordered-tree-node) str)
Source

plan-tree.lisp.

Method: print-object ((d ordered-tree-node) str)
Source

plan-tree.lisp.

Method: print-object ((d primitive-tree-node) str)
Source

plan-tree.lisp.

Method: print-object ((d complex-tree-node) str)
Source

plan-tree.lisp.

Method: print-object ((s state) str)
Source

state-utils.lisp.

Method: print-object ((obj domain) str)
Source

decls.lisp.

Method: print-object ((x problem) stream)
Source

decls.lisp.

Method: print-object ((obj choice-entry) str)
Source

backtrack-stack.lisp.


6.1.6 Conditions

Condition: bad-argument
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: predicate
Initargs

:predicate

Readers

predicate.

Writers

This slot is read-only.

Slot: argno
Initargs

:argno

Readers

argno.

Writers

This slot is read-only.

Slot: comment
Initargs

:comment

Readers

comment.

Writers

This slot is read-only.

Condition: incomplete-dependency-error
Package

shop3.theorem-prover.

Source

decls.lisp.

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

:logical-op

Readers

logical-op.

Writers

This slot is read-only.

Slot: expression
Initargs

:expression

Readers

expression.

Writers

This slot is read-only.

Condition: instantiation-error
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: predicate
Initargs

:predicate

Readers

predicate.

Writers

This slot is read-only.

Slot: argno
Initargs

:argno

Readers

argno.

Writers

This slot is read-only.

Condition: no-method-for-task
Package

shop3.

Source

decls.lisp.

Direct superclasses

shop-error.

Direct slots
Slot: task-name
Initargs

:task-name

Condition: non-ground-error
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: var
Initargs

:var

Readers

var.

Writers

This slot is read-only.

Slot: expression
Initargs

:expression

Readers

expression.

Writers

This slot is read-only.

Condition: singleton-variable
Package

shop3.

Source

decls.lisp.

Direct superclasses

domain-item-parse-warning.

Direct methods
Direct slots
Slot: variable-names
Initargs

:variable-names

Readers

variable-names.

Writers

This slot is read-only.

Slot: construct-type
Initargs

:construct-type

Readers

construct-type.

Writers

This slot is read-only.

Slot: construct-name
Initargs

:construct-name

Readers

construct-name.

Writers

This slot is read-only.

Slot: construct
Initform

(quote nil)

Initargs

:construct

Readers

construct.

Writers

This slot is read-only.

Slot: branch-number
Initform

(quote nil)

Initargs

:branch-number

Readers

branch-number.

Writers

This slot is read-only.

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.

Direct superclasses

shop-error.

Direct methods
Direct slots
Slot: task
Initargs

:task

Readers

task-arity-mismatch-task.

Writers

This slot is read-only.

Slot: library-task
Initargs

:library-task

Readers

task-arity-mismatch-library-task.

Writers

This slot is read-only.

Slot: library-entry
Initargs

:library-entry

Readers

task-arity-mismatch-library-entry.

Writers

This slot is read-only.

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.

Direct superclasses

condition.

Direct subclasses

6.1.7 Structures

Structure: complex-tree-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

tree-node.

Direct subclasses
Direct methods
Direct slots
Slot: children
Readers

complex-tree-node-children.

Writers

(setf complex-tree-node-children).

Slot: method-name
Type

(or null symbol)

Readers

complex-tree-node-method-name.

Writers

(setf complex-tree-node-method-name).

Structure: dependency
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

structure-object.

Direct methods
Direct slots
Slot: establisher
Readers

establisher.

Writers

(setf establisher).

Slot: consumer
Readers

consumer.

Writers

(setf consumer).

Slot: prop
Readers

prop.

Writers

(setf prop).

Structure: ordered-tree-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

pseudo-node.

Direct methods
Structure: primitive-tree-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

tree-node.

Direct methods
Structure: pseudo-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

complex-tree-node.

Direct subclasses
Structure: state
Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

structure-object.

Direct subclasses

tagged-state.

Direct methods

print-object.

Direct slots
Slot: body
Readers

state-body.

Writers

(setf state-body).

Structure: tagged-state

The ‘tagged-state‘ type encapsulates the behaviors needed to support backtracking and backjumping.

Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

state.

Direct subclasses
Direct methods
Direct slots
Slot: tags-info
Initform

(list (list 0))

Readers

tagged-state-tags-info.

Writers

(setf tagged-state-tags-info).

Slot: block-at
Type

fixnum

Initform

0

Readers

tagged-state-block-at.

Writers

(setf tagged-state-block-at).

Structure: top-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

complex-tree-node.

Direct methods
Direct slots
Slot: lookup-table
Type

(or hash-table null)

Readers

top-node-lookup-table.

Writers

(setf top-node-lookup-table).

Structure: tree-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

structure-object.

Direct subclasses
Direct methods
Direct slots
Slot: task
Readers

tree-node-task.

Writers

(setf tree-node-task).

Slot: expanded-task
Readers

tree-node-expanded-task.

Writers

(setf tree-node-expanded-task).

Slot: dependencies
Readers

tree-node-dependencies.

Writers

(setf tree-node-dependencies).

Slot: parent
Readers

tree-node-parent.

Writers

(setf tree-node-parent).

Structure: unordered-tree-node
Package

plan-tree.

Source

plan-tree.lisp.

Direct superclasses

pseudo-node.

Direct methods

6.1.8 Classes

Class: adl-domain
Package

shop3.

Source

pddl.lisp.

Direct superclasses
Class: adl-mixin
Package

shop3.

Source

pddl.lisp.

Direct superclasses
Direct subclasses

adl-domain.

Class: conditional-effects-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses
Direct methods

translate-effect.

Class: costs-mixin
Package

shop3.

Source

pddl.lisp.

Class: disjunctive-preconditions-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses

adl-mixin.

Direct methods
Class: domain

An object representing a SHOP domain.

Package

shop3.

Source

decls.lisp.

Direct superclasses
Direct subclasses
Direct methods
Direct slots
Slot: items

Cached copy of the ITEMS source.

Readers

domain-items.

Writers

This slot is read-only.

Class: equality-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses
Direct methods

parse-domain-items.

Class: existential-preconditions-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses

quantified-preconditions-mixin.

Direct methods
Class: negative-preconditions-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses

adl-mixin.

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.

Direct superclasses
Class: pddl-typing-mixin
Package

shop3.

Source

pddl.lisp.

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

:%pddl-types

Readers

pddl-types.

Writers

(setf pddl-types).

Class: problem

An object representing a SHOP problem.

Package

shop3.

Source

decls.lisp.

Direct methods
Direct slots
Slot: state-atoms
Package

shop3.common.

Initargs

:state-atoms

Readers

state-atoms.

Writers

This slot is read-only.

Slot: tasks
Initargs

:tasks

Readers

tasks.

Writers

This slot is read-only.

Slot: name
Package

shop3.common.

Initargs

:name

Readers
Writers

This slot is read-only.

Slot: domain-name

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

Package

shop3.common.

Initargs

:domain-name

Readers

domain-name.

Writers

This slot is read-only.

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.

Direct methods

process-method.

Class: quantified-preconditions-mixin
Package

shop3.

Source

pddl.lisp.

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.

Direct superclasses

domain.

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

:source-pddl-domain

Readers

source-pddl-domain.

Writers

This slot is read-only.

Class: static-predicates-mixin

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

Package

shop3.theorem-prover.

Source

decls.lisp.

Direct subclasses

pddl-domain.

Direct methods
Direct slots
Slot: static-preds
Initargs

:static-preds

Readers

static-preds.

Writers

This slot is read-only.

Class: thpr-domain

An object representing a SHOP3 theorem prover domain.

Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses
Direct subclasses

domain.

Direct methods
Direct slots
Slot: domain-name
Package

shop3.common.

Initargs

:name, :domain-name

Readers

domain-name.

Writers

This slot is read-only.

Slot: default-state-type
Initform

:mixed

Initargs

:default-state-type

Readers

default-state-type.

Writers

This slot is read-only.

Class: universal-preconditions-mixin
Package

shop3.

Source

pddl.lisp.

Direct subclasses

quantified-preconditions-mixin.

Direct methods

6.1.9 Types

Type: binding-list ()
Package

shop3.unifier.

Source

unify.lisp.

Type: shop-variable ()

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

Package

shop3.unifier.

Source

unify.lisp.


6.2 Internals


6.2.1 Constants

Constant: +anonymous-property-name+
Package

shop3.unifier.

Source

unify.lisp.

Constant: +primitive-property-name+
Package

shop3.unifier.

Source

unify.lisp.

Constant: +shop-trace-items+

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

Package

shop3.

Source

debugging.lisp.

Constant: +shopyright+
Package

shop3.

Source

shop3.lisp.

Constant: +singleton-term+
Package

shop3.common.

Source

state-utils.lisp.

Constant: +variable-property-name+
Package

shop3.unifier.

Source

unify.lisp.

Constant: +variable-term+
Package

shop3.common.

Source

state-utils.lisp.


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.

Special Variable: *all-method-names*

Will hold a hash table used to insure that all methods have unique names.

Package

shop3.

Source

input.lisp.

Special Variable: *all-problems*
Package

shop3.

Source

decls.lisp.

Special Variable: *analogical-replay*

If this variable is bound to T, SHOP will use analogical replay to provide guidance in heuristic search while planning.
Currently supported only in FIND-PLANS-STACK.

Package

shop3.

Source

decls.lisp.

Special Variable: *analogical-replay-table*

Hash table from task names to method choices.

Package

shop3.

Source

analogical-replay.lisp.

Special Variable: *back-quote-name*
Package

shop3.

Source

decls.lisp.

Special Variable: *before-extract-trees-hook*

This function exists solely for instrumenting for testing purposes. If this is bound to a function, that function will be called at the top of EXTRACT-PLAN-TREES. Generally should be NIL.

Package

shop3.

Source

decls.lisp.

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.

Special Variable: *collect-state*
Package

shop3.

Source

decls.lisp.

Special Variable: *current-plan*
Package

shop3.

Source

decls.lisp.

Special Variable: *current-tasks*
Package

shop3.

Source

decls.lisp.

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.

Special Variable: *depth-cutoff*
Package

shop3.

Source

decls.lisp.

Special Variable: *enhanced-plan-tree*

Do we build a dependency-enhanced plan tree?

Package

shop3.

Source

explicit-search.lisp.

Special Variable: *expansions*
Package

shop3.

Source

decls.lisp.

Special Variable: *explanation*
Package

shop3.

Source

decls.lisp.

Special Variable: *gc*
Package

shop3.

Source

decls.lisp.

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.

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.

Special Variable: *include-rationale*
Package

shop3.

Source

explicit-search.lisp.

Special Variable: *internal-time-limit*
Package

shop3.

Source

decls.lisp.

Special Variable: *internal-time-tag*
Package

shop3.

Source

decls.lisp.

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.

Special Variable: *make-analogy-table*

If this variable is bound to T, SHOP will build a table for analogical replay (*analogical-replay-table*) while planning.
Currently supported only in FIND-PLANS-STACK.

Package

shop3.

Source

decls.lisp.

Special Variable: *more-tasks-p*

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

Package

shop3.

Source

decls.lisp.

Special Variable: *negation-deps-ok*
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Special Variable: *no-dependencies*

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

Package

shop3.

Source

explicit-search.lisp.

Special Variable: *node-children-table*
Package

shop3.

Source

tree-reductions.lisp.

Special Variable: *node-list*
Package

plan-tree.

Source

plan-tree.lisp.

Special Variable: *old-depth*

For iterative-deepening search, what was the maximum depth of the last iteration, so we can avoid duplicate plans.

Package

shop3.

Source

decls.lisp.

Special Variable: *operator-tasks*
Package

shop3.

Source

decls.lisp.

Special Variable: *optimal-cost*
Package

shop3.

Source

decls.lisp.

Special Variable: *optimal-plan*
Package

shop3.

Source

decls.lisp.

Special Variable: *optimize-cost*
Package

shop3.

Source

decls.lisp.

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.

Special Variable: *plan-num-limit*
Package

shop3.

Source

decls.lisp.

Special Variable: *plan-tree*
Package

shop3.

Source

decls.lisp.

Special Variable: *plans-found*
Package

shop3.

Source

decls.lisp.

Special Variable: *pp*
Package

shop3.

Source

decls.lisp.

Special Variable: *print-plans*
Package

shop3.

Source

decls.lisp.

Special Variable: *print-stats*
Package

shop3.

Source

decls.lisp.

Special Variable: *problem*
Package

shop3.

Source

decls.lisp.

Special Variable: *protections*
Package

shop3.

Source

decls.lisp.

Special Variable: *pshort*
Package

shop3.

Source

decls.lisp.

Special Variable: *shop-pprint-table*
Package

shop3.

Source

decls.lisp.

Special Variable: *shop-version*
Package

shop3.

Source

decls.lisp.

Special Variable: *start-real-time*
Package

shop3.

Source

debugging.lisp.

Special Variable: *start-run-time*
Package

shop3.

Source

debugging.lisp.

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.

Special Variable: *states-found*
Package

shop3.

Source

decls.lisp.

Special Variable: *subtask-parents*
Package

shop3.

Source

decls.lisp.

Special Variable: *table-for-load-form*
Package

plan-tree.

Source

plan-tree.lisp.

Special Variable: *task-operator*
Package

shop3.

Source

decls.lisp.

Special Variable: *tasklist*
Package

shop3.

Source

decls.lisp.

Special Variable: *time-limit*
Package

shop3.

Source

decls.lisp.

Special Variable: *traced-axioms*
Package

shop3.

Source

debugging.lisp.

Special Variable: *traced-goals*
Package

shop3.

Source

debugging.lisp.

Special Variable: *traced-methods*
Package

shop3.

Source

debugging.lisp.

Special Variable: *traced-tasks*
Package

shop3.

Source

debugging.lisp.

Special Variable: *unifiers-found*
Package

shop3.

Source

decls.lisp.

Special Variable: *unique-method-names*

This variable will be dynamically bound by code for parsing domains
(and should *not* be set by users). If T, the system will raise an error
if methods do not have unique names. If :WARN, the system will issue a warning. If NIL, the system will accept non-unique names quietly.

Package

shop3.

Source

decls.lisp.

Special Variable: *validator-progname*
Package

shop3.

Source

pddl.lisp.

Special Variable: *verbose*
Package

shop3.

Source

decls.lisp.

Special Variable: +binary-numerical-operators+

Binary numerical operations permitted by the :fluents requirement.

Package

shop3.theorem-prover.

Source

fluents.lisp.

Special Variable: +fluent-updates+
Package

shop3.

Source

pddl.lisp.

Special Variable: +method-definition-keywords+

This constant holds a list of method definition keywords that are valid for default SHOP domains.

Package

shop3.

Source

decls.lisp.

Special Variable: +numerical-comparisons+

Numerical comparisons permitted by the :fluents requirement.

Package

shop3.theorem-prover.

Source

fluents.lisp.

Special Variable: +pddl-requirements-keywords+
Package

shop3.

Source

decls.lisp.


6.2.3 Macros

Macro: appendf (place value)
Package

shop3.

Source

decls.lisp.

Macro: catch-internal-time (&rest body)
Package

shop3.

Source

decls.lisp.

Macro: defconstant (name value &optional doc)
Package

shop3.

Source

decls.lisp.

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.

Macro: push-last (item list)
Package

shop3.

Source

decls.lisp.

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.

Macro: simple-backquote (x)
Package

shop3.

Source

decls.lisp.

Macro: stack-constructor (name-arg &rest arglist)
Package

shop3.

Source

backtrack-stack.lisp.

Macro: verbose-format (&rest args)
Package

shop3.

Source

decls.lisp.

Macro: when-done (&body body)
Package

shop3.

Source

search.lisp.

Macro: with-method-name-table (&rest body)
Package

shop3.

Source

input.lisp.


6.2.4 Ordinary functions

Function: %make-bit-state (&key body tags-info block-at)
Package

shop3.common.

Source

state-decls.lisp.

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.

Function: acceptable-cost-p (cost)
Package

shop3.

Source

search.lisp.

Function: add-protection (protections protect depth operator state)
Package

shop3.

Source

protections.lisp.

Function: add-source (unified-goal external explanation)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: all-elements-bindings (lst)
Package

shop3.unifier.

Source

unify.lisp.

Function: all-raw-depends-lists-p (list)
Package

shop3.theorem-prover.

Source

decls.lisp.

Function: all-raw-depends-p (list)
Package

shop3.theorem-prover.

Source

decls.lisp.

Function: all-roots (all-nodes subtask-parents-table)

Return the list of nodes in ALL-NODES that don’t have parents.
Parents are determined by the contents of the SUBTASK-PARENTS-TABLE.
As in many other places, the elements of ALL-NODES are either PRIMITIVE-NODEs or tasks (s-expressions).

Package

shop3.

Source

tree-reductions.lisp.

Function: already-immediate-p (reduction)
Package

shop3.

Source

task-reductions.lisp.

Function: anonymous-var-symbol-p (x)
Package

shop3.unifier.

Source

unify.lisp.

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.

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.

Function: apply-method-bindings (task top-tasks tasks reduction unifier)
Package

shop3.

Source

search.lisp.

Function: apply-substitution-to-tree (bindings plan-tree)
Package

shop3.

Source

explicit-search.lisp.

Function: axiom-sexp-p (lst)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: backtrack (format-string &rest args)
Package

shop3.

Source

output.lisp.

Function: binding-p (object)
Package

shop3.unifier.

Source

unify.lisp.

Function: bit-state-block-at (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf bit-state-block-at) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: bit-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf bit-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: bit-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: bit-state-tags-info (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf bit-state-tags-info) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: bit-statebody-increment-position (position pred-type-counts)
Package

shop3.common.

Source

state-utils.lisp.

Function: bit-statebody-search-array (pred-array pred-type-counts entity-number-tables complex-position)
Package

shop3.common.

Source

state-utils.lisp.

Function: canonically-order (tree &optional keep-empty)
Package

shop3.

Source

tree-accessors.lisp.

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.

Function: check-for-singletons (var-table &key context-tables context-table construct-type construct-name construct branch-number)
Package

shop3.

Source

input.lisp.

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.

Function: choose-immediate-task-state (state)
Package

shop3.

Source

explicit-search.lisp.

Function: choose-method-bindings-state (state)
Package

shop3.

Source

explicit-search.lisp.

Function: choose-method-state (state domain)

Try to apply the first of the methods in the current set of alternatives to the search-state STATE, using DOMAIN. Return is boolean, true if the expansion is successful, otherwise NIL to trigger backtracking.

Package

shop3.

Source

explicit-search.lisp.

Function: choose-toplevel-task (state)
Package

shop3.

Source

explicit-search.lisp.

Function: clobbered-p (tree-node divergence)
Package

shop3-minimal-subtree.

Source

minimal-subtree.lisp.

Function: complex-tree-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf complex-tree-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: complex-tree-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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

plan-tree.

Source

plan-tree.lisp.

Function: complex-tree-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: complex-tree-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf complex-tree-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: complex-tree-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf complex-tree-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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.

Function: copy-binding (instance)
Package

shop3.unifier.

Source

unify.lisp.

Function: copy-complex-node (sequence)

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

Package

shop3.

Alias for

copy-seq.

Function: copy-complex-tree-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-dependency (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-hash-table (h1 &optional copy-fn)
Package

shop3.common.

Source

state-utils.lisp.

Function: copy-operator (sequence)

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

Package

shop3.

Alias for

copy-seq.

Function: copy-ordered-tree-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-pddl-action (sequence)

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

Package

shop3.

Alias for

copy-seq.

Function: copy-primitive-node (sequence)

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

Package

shop3.

Alias for

copy-seq.

Function: copy-primitive-tree-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-pseudo-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-raw-depend (instance)
Package

shop3.theorem-prover.

Source

decls.lisp.

Function: copy-replay-table-entry (instance)
Package

shop3.

Source

analogical-replay.lisp.

Function: copy-state-update (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: copy-task-tree (tt)
Package

shop3.

Source

task-reductions.lisp.

Function: copy-top-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-tree-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: copy-unordered-tree-node (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: count-method-branches (method-body)
Package

shop3.

Source

input.lisp.

Function: create-node-children-table (subtask-parents-table all-nodes all-primitive-nodes)

Build and return a hash-table of nodes’ children using the SUBTASK-PARENTS-TABLE and the lists of ALL-NODES and ALL-PRIMITIVE-NODES. Elements of ALL-NODES are *either* PRIMITIVE-NODEs or TASKS (lists) for complex tasks.

Package

shop3.

Source

tree-reductions.lisp.

Function: decode-task (task all-primitive-nodes)

Take a TASK s-expression and return either: (a) NIL if it corresponds to a no-op (’SHOP::!!INOP), (b) the corresponding primitive-node, if the task is a primitive one, (c) the symbol :FAIL if the primitive task was not successfully expanded – if it is part of a failed search branch then or (c) TASK itself.

Package

shop3.

Source

tree-reductions.lisp.

Function: delete-protection (protections protect depth operator state)
Package

shop3.

Source

protections.lisp.

Function: delete-protections (dels protections state depth operator)
Package

shop3.

Source

task-reductions.lisp.

Function: delete-task-main-list (l task deleted)
Package

shop3.

Source

task-reductions.lisp.

Function: delete-task-top-list (l ml task)
Package

shop3.

Source

task-reductions.lisp.

Function: dependency-for-negation (positive-literal state)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: dependency-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: determine-verbosity (verbose)
Package

shop3.

Source

output.lisp.

Function: divergence-list-p (list)
Package

shop3.

Source

plan-repair.lisp.

Function: divergence-op-p (op)
Package

shop3.

Source

plan-repair.lisp.

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.

Function: do-conjunct-from-atoms (domain goal1 remaining state bindings level just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: do-conjunct-from-axiom (axiom domain goal1 remaining state bindings level just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: do-conjunct-from-axioms (domain goal1 remaining state bindings level just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

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.

Function: doubly-hashed-state-block-at (instance)
Package

shop3.common.

Source

state-decls.lisp.

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

shop3.common.

Source

state-decls.lisp.

Function: doubly-hashed-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf doubly-hashed-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: doubly-hashed-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: doubly-hashed-state-tags-info (instance)
Package

shop3.common.

Source

state-decls.lisp.

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

shop3.common.

Source

state-decls.lisp.

Function: dummy-external-access-hook (goal)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

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

shop3.

Source

search.lisp.

Function: dump-previous-plans! ()

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

Package

shop3.

Source

search.lisp.

Function: empty-p (state)
Package

shop3.

Source

explicit-search.lisp.

Function: expand-include (domain items)
Package

shop3.

Source

input.lisp.

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.

Function: extend-plan-tree-nodes (base-nodes &optional acc)
Package

shop3.

Source

tree-reductions.lisp.

Function: external-find-satisfiers (domain goal state)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: external-query (domain query state)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

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.

Function: extract-method-id (domain method-expr task-name)
Package

shop3.

Source

input.lisp.

Function: extract-subtasks (reduction)
Package

shop3.

Source

tree-reductions.lisp.

Function: extract-subtree (root-node nodes)

Recursively build the subtree below ROOT-NODE from the set of possible nodes in NODES. At the top level, it returns a COMPLEX-NODE if ROOT-NODE is a complex task or ROOT-NODE if ROOT-NODE is a PRIMITIVE-NODE.

Package

shop3.

Source

tree-reductions.lisp.

Function: extract-suffix (plan prefix)
Package

shop3.

Source

plan-repair.lisp.

Function: extract-tree (plan)
Package

shop3.

Source

tree-reductions.lisp.

Function: extract-trees (plans-found unifiers-found)
Package

shop3.

Source

shop3.lisp.

Function: filter-singletons (singletons context-tables)
Package

shop3.

Source

input.lisp.

Function: find-adder (prop divergence-list)
Package

shop3-minimal-subtree.

Source

minimal-subtree.lisp.

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.

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.

Function: find-deleter (prop divergence-list)
Package

shop3-minimal-subtree.

Source

minimal-subtree.lisp.

Function: find-next-main-list (task l)
Package

shop3.

Source

task-reductions.lisp.

Function: find-plan-suffix (orig-plan executed-prefix)
Package

shop3-minimal-subtree.

Source

minimal-subtree.lisp.

Function: find-plans-1 (domain state tasks which problem &key out-stream &allow-other-keys)
Package

shop3.

Source

shop3.lisp.

Function: find-variable (tree)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: first-word-equal (string1 string2)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: force-immediate (reductions)
Package

shop3.

Source

task-reductions.lisp.

Function: force-immediate-reduction (reduction)
Package

shop3.

Source

task-reductions.lisp.

Function: force-immediate-unordered (unordered-list &optional previous)
Package

shop3.

Source

task-reductions.lisp.

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.

Function: fully-instantiated-goal (goal)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: generate-reductions (domain reductions subtasks)
Package

shop3.

Source

loop-extensions.lisp.

Function: get-attribution (unified-query)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: get-immediate-list (tl)
Package

shop3.

Source

search.lisp.

Function: get-method-name (lst method-id branch-counter singleton method-head)
Package

shop3.

Source

input.lisp.

Function: get-task-body (task1)
Package

shop3.

Source

task-reductions.lisp.

Function: get-task-name (task1)

Return the name of the TASK in a task expression.
This is more than just taking the first element because that could be :TASK, could be modified by :IMMEDIATE, etc.

Package

shop3.

Source

task-reductions.lisp.

Function: get-top-tasks (l)
Package

shop3.

Source

task-reductions.lisp.

Function: goal-equalp (g1 g2)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

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.

Function: hash-state-block-at (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf hash-state-block-at) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: hash-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf hash-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: hash-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: hash-state-tags-info (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf hash-state-tags-info) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: id-search (domain state tasks top-tasks which out-stream &key depth-increment)
Package

shop3.

Source

shop3.lisp.

Function: immediate-tasks (state)
Package

shop3.

Source

explicit-search.lisp.

Function: incorporate-unifiers (unifiers remaining just-one state bindings dependencies-in added-dependencies domain newlevel)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: indented-format (indentation &rest body)
Package

shop3.

Source

output.lisp.

Function: index-method-on-domain (domain method-id method-obj)

Record the METHOD-ID/METHOD-OBJ association in DOMAIN.

Package

shop3.

Source

input.lisp.

Function: insert-if-necessary (obj &optional table)

Make an entry in TABLE for OBJ if it’s not already there.

Package

plan-tree.

Source

plan-tree.lisp.

Function: invoke-external-query (query state)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: leftmost-p (tree-node)
Package

shop3-minimal-subtree.

Source

minimal-subtree.lisp.

Function: list-insert-atom-into-statebody (atom statebody)
Package

shop3.common.

Source

state-utils.lisp.

Function: list-remove-atom-from-statebody (atom statebody)
Package

shop3.common.

Source

state-utils.lisp.

Function: list-state-block-at (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf list-state-block-at) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: list-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf list-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: list-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: list-state-tags-info (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf list-state-tags-info) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: loop-body-item (key task-body)
Package

shop3.

Source

loop-extensions.lisp.

Function: loop-body-item-inner (key task-body)
Package

shop3.

Source

loop-extensions.lisp.

Function: loop-item (key task-body)
Package

shop3.

Source

loop-extensions.lisp.

Function: looping-p (task-name)
Package

shop3.

Source

loop-extensions.lisp.

Function: make-add-child-to-tree (&key parent child)

Constructor for ADD-CHILD-TO-TREE objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-add-dependencies (&key dependencies)

Constructor for ADD-DEPENDENCIES objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-bit-state (atoms)
Package

shop3.common.

Source

state-utils.lisp.

Package

plan-tree.

Source

plan-tree.lisp.

Function: make-cs-state (&key mode alternatives current-task)

Constructor for CHOICE-ENTRY objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-dependencies (tree-node depend-lists hash-table)
Package

shop3.

Source

explicit-search.lisp.

Function: make-domain (name-and-options &rest items)
Package

shop3.

Source

input.lisp.

Function: make-doubly-hashed-state (atoms)
Package

shop3.common.

Source

state-utils.lisp.

Function: make-hash-state (atoms)
Package

shop3.common.

Source

state-utils.lisp.

Function: make-list-state (atoms)
Package

shop3.common.

Source

state-utils.lisp.

Function: make-loop-state-expand (&rest arglist &key top-tasks tasks unifier)
Package

shop3.

Source

loop-extensions.lisp.

Function: make-method-instantiation (&key unifier top-tasks tasks)

Constructor for METHOD-INSTANTIATION objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-mixed-state (atoms)
Package

shop3.common.

Source

state-utils.lisp.

Function: make-operator (&key head preconditions deletions additions cost-fun)
Package

shop3.

Source

decls.lisp.

Function: make-operator-task-table ()
Package

shop3.

Source

tree-reductions.lisp.

Function: make-pddl-action (&key head precondition effect cost-fun)
Package

shop3.

Source

pddl.lisp.

Function: make-plan-copy (plan)

Copy the argument PLAN, and return the copy and a hash-table that maps the tasks in the original PLAN into the copy.
The hash table is essential because the plan tree is indexed by object equality, so when the plan is rewritten, any plan tree must be rewritten, as well.

Package

shop3.

Source

explicit-search.lisp.

Function: make-plan-tree-for-task-net (task-net parent hash-table)
Package

shop3.

Source

explicit-search.lisp.

Function: make-prim-state-expand (&key top-tasks tasks protections partial-plan unifier partial-plan-cost)

Constructor for PRIM-STATE-EXPAND objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-primitive-node (cost task position)
Package

shop3.

Source

tree-accessors.lisp.

Function: make-pseudo-node (&key task expanded-task dependencies parent children method-name)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-raw-depend (&key prop est)
Package

shop3.theorem-prover.

Source

decls.lisp.

Function: make-record-expansion (&key tree-node)

Constructor for RECORD-EXPANSION objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-record-expansion-for-replay (&key task method-id)

Constructor for RECORD-EXPANSION-FOR-REPLAY objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: make-replay-table-entry (&key singleton alist)
Package

shop3.

Source

analogical-replay.lisp.

Function: make-state-update (&key action literal)
Package

shop3.common.

Source

state-decls.lisp.

Function: make-subtask-parents-table ()
Package

shop3.

Source

tree-reductions.lisp.

Function: make-tree-node (&key task expanded-task dependencies parent)
Package

plan-tree.

Source

plan-tree.lisp.

Function: make-world-state-tag (&key tag)

Constructor for STATE-TAG objects.

Package

shop3.

Source

backtrack-stack.lisp.

Function: makedoubly-hashedstate (&key body tags-info block-at)
Package

shop3.common.

Source

state-decls.lisp.

Function: makehashstate (&key body tags-info block-at)
Package

shop3.common.

Source

state-decls.lisp.

Function: makeliststate (&key body tags-info block-at)
Package

shop3.common.

Source

state-decls.lisp.

Function: makemixedstate (&key body tags-info block-at)
Package

shop3.common.

Source

state-decls.lisp.

Function: merge-binding-set-lists (binding-sets1 binding-sets2 &optional original-binding-sets2)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: merge-binding-sets (binding-set1 binding-set2)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: method-printer (str method)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: method-sexp-p (lst)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: min-start (node)
Package

shop3.

Source

tree-accessors.lisp.

Function: mixed-state-block-at (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf mixed-state-block-at) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: mixed-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf mixed-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: mixed-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: mixed-state-tags-info (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf mixed-state-tags-info) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: new-symbol (sym)
Package

shop3.

Source

loop-extensions.lisp.

Function: node-children (node &optional children-table)

Find all the nodes in NODES whose parent is NODE.

Package

shop3.

Source

tree-reductions.lisp.

Function: nshuffle-array (array)
Package

shop3.

Source

decls.lisp.

Function: nshuffle-list (list)

Shuffle the list using an intermediate vector.

Package

shop3.

Source

decls.lisp.

Function: obj-bindings (hash-table)

Return an ordered list of variable-name instantiator pairs for use in a LET form.

Package

plan-tree.

Source

plan-tree.lisp.

Function: occurs (variable-name expr)
Package

shop3.unifier.

Source

unify.lisp.

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.

Function: op-sexp-p (lst)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: operator-additions (structure)
Package

shop3.

Source

decls.lisp.

Function: (setf operator-additions) (structure)
Package

shop3.

Source

decls.lisp.

Function: operator-cost-fun (structure)
Package

shop3.

Source

decls.lisp.

Function: (setf operator-cost-fun) (structure)
Package

shop3.

Source

decls.lisp.

Function: operator-deletions (structure)
Package

shop3.

Source

decls.lisp.

Function: (setf operator-deletions) (structure)
Package

shop3.

Source

decls.lisp.

Function: operator-head (structure)
Package

shop3.

Source

decls.lisp.

Function: (setf operator-head) (structure)
Package

shop3.

Source

decls.lisp.

Function: operator-name (operator)
Package

shop3.

Source

decls.lisp.

Function: operator-p (x)
Package

shop3.

Source

decls.lisp.

Function: operator-preconditions (structure)
Package

shop3.

Source

decls.lisp.

Function: (setf operator-preconditions) (structure)
Package

shop3.

Source

decls.lisp.

Function: operator-printer (str operator)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: operator-sexp-p (lst)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: operator-task (operator-node)
Package

shop3.

Source

tree-reductions.lisp.

Function: optimize-continue-p (which)
Package

shop3.

Source

search.lisp.

Function: ordered-tree-node-children (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf ordered-tree-node-children) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf ordered-tree-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-method-name (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf ordered-tree-node-method-name) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf ordered-tree-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: ordered-tree-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf ordered-tree-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: parse-pddl-method (domain method)
Package

shop3.

Source

pddl.lisp.

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.

Function: pddl-action-cost-fun (structure)
Package

shop3.

Source

pddl.lisp.

Function: (setf pddl-action-cost-fun) (structure)
Package

shop3.

Source

pddl.lisp.

Function: pddl-action-effect (structure)
Package

shop3.

Source

pddl.lisp.

Function: (setf pddl-action-effect) (structure)
Package

shop3.

Source

pddl.lisp.

Function: pddl-action-head (structure)
Package

shop3.

Source

pddl.lisp.

Function: (setf pddl-action-head) (structure)
Package

shop3.

Source

pddl.lisp.

Function: pddl-action-name (pddl-action)
Package

shop3.

Source

pddl.lisp.

Function: pddl-action-p (x)
Package

shop3.

Source

pddl.lisp.

Function: pddl-action-precondition (structure)
Package

shop3.

Source

pddl.lisp.

Function: (setf pddl-action-precondition) (structure)
Package

shop3.

Source

pddl.lisp.

Function: pddl-satisfiers-for-exists (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

prover.lisp.

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.

Function: pddl-satisfiers-for-forall (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

prover.lisp.

Function: pddl-satisfiers-for-imply (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

prover.lisp.

Function: pddl-satisfiers-for-not (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

prover.lisp.

Function: phase-one (plan-tree translation-table bindings)
Package

prepare-return-values.

Source

prepare-return-values.lisp.

Function: plan-operator-nodes (plan &optional origin)

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.

Function: plan-returns (pr-list &optional unpack-returns)

Unpack the return values from PR-LIST, which should be a list of PLAN-RETURN objects.

Package

shop3.

Source

explicit-search.lisp.

Function: plan-tree-nodes (base-nodes)
Package

shop3.

Source

tree-reductions.lisp.

Function: populate-plan-return (&rest args)
Package

shop3.

Source

explicit-search.lisp.

Function: pprint-preconds (str preconds)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: pprint-step (stream step)
Package

shop3.

Source

plan-printer.lisp.

Function: pprint-task-net (str task-net)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: prepare-choose-immediate-task-state (state)
Package

shop3.

Source

explicit-search.lisp.

Function: primitive-symbol-p (x)
Package

shop3.unifier.

Source

unify.lisp.

Function: primitive-tree-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf primitive-tree-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: primitive-tree-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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

plan-tree.

Source

plan-tree.lisp.

Function: primitive-tree-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: primitive-tree-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf primitive-tree-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: primitive-tree-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf primitive-tree-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: primitivep (x)

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

Package

shop3.

Source

decls.lisp.

Function: print-current-plan ()
Package

shop3.

Source

output.lisp.

Function: print-current-tasks ()
Package

shop3.

Source

output.lisp.

Function: print-list-on-lines (str list)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: print-list-suffix-lines (str list)
Package

shop3-pprint.

Source

shop-pprint.lisp.

Function: print-operator (operator &optional stream)
Package

shop3.

Source

debugging.lisp.

Function: print-output-file (plan)
Package

shop3.

Source

output.lisp.

Function: print-stats (depth plans tasks inferences runtime realtime &optional stream)
Package

shop3.

Source

output.lisp.

Function: print-stats-header (label &optional stream)
Package

shop3.

Source

output.lisp.

Function: print1 (obj)
Package

shop3.

Source

output.lisp.

Function: process-add-list (domain adds state)
Package

shop3.

Source

task-reductions.lisp.

Function: process-delete-list (domain dels state)
Package

shop3.

Source

task-reductions.lisp.

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.

Function: process-task-list (tasks)
Package

shop3.

Source

input.lisp.

Function: protection-ok (domain state protections head)
Package

shop3.

Source

protections.lisp.

Function: pseudo-node-children (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-children) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-expanded-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-method-name (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-method-name) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pseudo-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf pseudo-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: pull-tag-info (tags-info tag &optional stop-at)
Package

shop3.common.

Source

tagged-state.lisp.

Function: query-current-state (first-symbol)
Package

shop3.

Source

output.lisp.

Function: quotify (x)
Package

shop3.

Source

decls.lisp.

Function: randomize-list (list)

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

Package

shop3.

Source

decls.lisp.

Function: raw-depend-p (object)
Package

shop3.theorem-prover.

Source

decls.lisp.

Reader: rd-est (instance)
Writer: (setf rd-est) (instance)
Package

shop3.theorem-prover.

Source

decls.lisp.

Target Slot

est.

Reader: rd-prop (instance)
Writer: (setf rd-prop) (instance)
Package

shop3.theorem-prover.

Source

decls.lisp.

Target Slot

prop.

Function: rd-union (new-depends dependencies)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: real-apply-substitution (target binding-list)
Package

shop3.unifier.

Source

unify.lisp.

Function: real-seek-satisfiers (domain goals state var-val-list level just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: record-node-expansion (tree-node expanded-task hash-table &key chosen-method)
Package

shop3.

Source

explicit-search.lisp.

Function: record-operator (task1 operator)
Package

shop3.

Source

tree-reductions.lisp.

Function: record-reduction (task1 reduction unifier)
Package

shop3.

Source

tree-reductions.lisp.

Function: remove-subtree-from-table (hash-table subtree)
Package

shop3.

Source

explicit-search.lisp.

Function: rename-sym (sym renaming-table)
Package

shop3.

Source

loop-extensions.lisp.

Function: replace-task-main-list (ml t1 t2)
Package

shop3.

Source

task-reductions.lisp.

Function: replace-task-top-list (l t1 t2)
Package

shop3.

Source

task-reductions.lisp.

Function: replan-from-failure (domain failed-tree-node search-state &key verbose plan-num-limit)
Package

shop3.

Source

plan-repair.lisp.

Reader: replay-table-entry-alist (instance)
Writer: (setf replay-table-entry-alist) (instance)
Package

shop3.

Source

analogical-replay.lisp.

Target Slot

alist.

Function: replay-table-entry-p (object)
Package

shop3.

Source

analogical-replay.lisp.

Reader: replay-table-entry-singleton (instance)
Writer: (setf replay-table-entry-singleton) (instance)
Package

shop3.

Source

analogical-replay.lisp.

Target Slot

singleton.

Function: report-no-method (x str)
Package

shop3.

Source

decls.lisp.

Function: report-task-arity-mismatch (condition stream)
Package

shop3.

Source

decls.lisp.

Function: rest-shop2-axiom-p (ax)
Package

shop3.

Source

input.lisp.

Function: resymbol-task (tsk renaming-table)
Package

shop3.

Source

loop-extensions.lisp.

Function: search-tree (item tree)
Package

shop3.

Source

input.lisp.

Function: seek-plans-primitive-1 (domain task1 state tasks top-tasks depth protections unifier)
Package

shop3.

Source

search.lisp.

Function: seek-plans-stack (state domain &key which repairable unpack-returns plan-num-limit)

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.
If UNPACK-RETURNS is non-NIL (the default):
Returns five 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.
List of world states (SHOP states) – optional
List of analogical-replay tables – optional
If UNPACK-RETURNS is NIL, returns a list of PLAN-RETURN objects.

Package

shop3.

Source

explicit-search.lisp.

Function: setof-bagof-helper (mode domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: shop-trace-1 (items)
Package

shop3.

Source

debugging.lisp.

Function: shop-untrace-1 (items)
Package

shop3.

Source

debugging.lisp.

Function: shop-untrace-all ()
Package

shop3.

Source

debugging.lisp.

Function: shop2-axiom-p (ax)
Package

shop3.

Source

input.lisp.

Function: slot-value-translator (val &optional table)
Package

plan-tree.

Source

plan-tree.lisp.

Function: stack-backjump (state target)
Package

shop3.

Source

explicit-search.lisp.

Function: stack-backtrack (state)

Do a one-step, chronological backtrack, undoing all changes until we reach the next CHOICE-ENTRY.

Return the CHOICE-ENTRY where backtracking stopped.

Note: Requires the dynamic variable *DOMAIN* to be properly bound around calls.

Package

shop3.

Source

explicit-search.lisp.

Function: standard-satisfiers-for-and (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-assign (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-assign* (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-bagof (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-call (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-enforce (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-eval (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-exists (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-external (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-forall (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-imply (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-not (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-or (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: standard-satisfiers-for-setof (domain arguments other-goals state bindings newlevel just1 dependencies-in)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Reader: state-body (instance)
Writer: (setf state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Target Slot

body.

Function: state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Reader: state-update-action (instance)
Writer: (setf state-update-action) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Target Slot

action.

Reader: state-update-literal (instance)
Writer: (setf state-update-literal) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Target Slot

literal.

Function: state-update-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Function: static-bounds-p (domain logical-expr)
Package

shop3.theorem-prover.

Source

theorem-prover.lisp.

Function: strip-nops (plan)
Package

shop3.

Source

task-reductions.lisp.

Function: strip-task-sexp (task)

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

Package

shop3.

Source

explicit-search.lisp.

Function: strip-tree-tags (tree)

Return TREE – which should be composed of TREE-NODEs
with all the task keywords (:TASK and :IMMEDIATE) stripped out. Note that because SHOP plan "trees" are sometimes forests, we check for that case at the top.

Package

shop3.

Source

tree-reductions.lisp.

Reader: tagged-state-block-at (instance)
Writer: (setf tagged-state-block-at) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Target Slot

block-at.

Function: tagged-state-body (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: (setf tagged-state-body) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Function: tagged-state-p (object)
Package

shop3.common.

Source

state-decls.lisp.

Reader: tagged-state-tags-info (instance)
Writer: (setf tagged-state-tags-info) (instance)
Package

shop3.common.

Source

state-decls.lisp.

Target Slot

tags-info.

Function: tagged-state-tags-info-tag (tagged-state)
Package

shop3.common.

Source

tagged-state.lisp.

Function: task-args (task)
Package

shop3.

Source

tree-accessors.lisp.

Function: test-plan-found (state &key repairable)

If there is a plan in STATE (a SEARCH-STATE), then return T and the plan, otherwise return NIL.

Package

shop3.

Source

explicit-search.lisp.

Function: time-expired-p ()
Package

shop3.

Source

search.lisp.

Function: to-string (num &optional max-decimal)
Package

shop3.

Source

output.lisp.

Function: top-node-children (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-children) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: top-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: top-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-expanded-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Reader: top-node-lookup-table (instance)
Writer: (setf top-node-lookup-table) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Target Slot

lookup-table.

Function: top-node-method-name (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-method-name) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: top-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: top-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: top-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf top-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Package

prepare-return-values.

Source

prepare-return-values.lisp.

Package

prepare-return-values.

Source

prepare-return-values.lisp.

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.

Function: translate-include (domain include-item)
Package

shop3.

Source

input.lisp.

Function: translate-lookup-table (new-root plan-translation-table tree-plan-translation-table)

Update the tree node lookup table in NEW-ROOT using the two translation hash tables. Done for side-effects: returns nothing.

Package

prepare-return-values.

Source

prepare-return-values.lisp.

Function: translate-metric-updates (domain expression)
Package

shop3.

Source

pddl.lisp.

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.

Function: tree-compare (tree1 tree2)

Strictly for debugging use – this very inefficient function pinpoints differences between trees.

Package

shop3.

Source

tree-accessors.lisp.

Function: tree-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

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.

Function: unify1 (e1 e2)
Package

shop3.unifier.

Source

unify.lisp.

Function: unordered-tree-node-children (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf unordered-tree-node-children) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-dependencies (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf unordered-tree-node-dependencies) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-expanded-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-method-name (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf unordered-tree-node-method-name) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-p (object)
Package

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-parent (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf unordered-tree-node-parent) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: unordered-tree-node-task (instance)
Package

plan-tree.

Source

plan-tree.lisp.

Function: (setf unordered-tree-node-task) (instance)
Package

plan-tree.

Source

plan-tree.lisp.

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.

Function: variable-name (x)
Package

shop3.unifier.

Source

unify.lisp.

Function: variable-symbol-p (x)
Package

shop3.unifier.

Source

unify.lisp.

Function: vars-boundp (tree &optional acc)
Package

shop3.theorem-prover.

Source

prover.lisp.

Function: well-formed-listp (l)
Package

shop3.

Source

task-reductions.lisp.


6.2.5 Generic functions

Generic Function: %delete-a-decomposition (domain task method-id)
Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: %delete-a-decomposition ((domain domain) (task list) (method-id symbol))
Generic Function: %record-a-decomposition (domain task method-id)
Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: %record-a-decomposition ((domain domain) (task list) (method-id symbol))
Generic Function: %update-singleton (replay-table-entry)
Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: %update-singleton ((replay-table-entry replay-table-entry))
Generic Reader: alternatives (object)
Package

shop3.

Methods
Reader Method: alternatives ((choice-entry choice-entry))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

alternatives.

Reader Method: alternatives ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

alternatives.

Generic Writer: (setf alternatives) (object)
Package

shop3.

Methods
Writer Method: (setf alternatives) ((search-state search-state))

automatically generated writer method

Source

decls.lisp.

Target Slot

alternatives.

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.

Methods
Method: apply-method ((domain domain) state task-body method protections depth in-unifier)
Source

task-reductions.lisp.

Generic Reader: argno (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: argno ((condition bad-argument))
Source

decls.lisp.

Target Slot

argno.

Reader Method: argno ((condition instantiation-error))
Source

decls.lisp.

Target Slot

argno.

Generic Function: assign-domain-method-id (domain method method-id)
Package

shop3.

Source

decls.lisp.

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.

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

state-utils.lisp.

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

state-utils.lisp.

Method: atom-in-state-p (atom (st mixed-state))
Source

state-utils.lisp.

Method: atom-in-state-p (atom (st hash-state))
Source

state-utils.lisp.

Method: atom-in-state-p (atom (st list-state))
Source

state-utils.lisp.

Generic Reader: backtrack-stack (object)
Package

shop3.

Methods
Reader Method: backtrack-stack ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

backtrack-stack.

Generic Writer: (setf backtrack-stack) (object)
Package

shop3.

Methods
Writer Method: (setf backtrack-stack) ((search-state search-state))

automatically generated writer method

Source

decls.lisp.

Target Slot

backtrack-stack.

Generic Reader: branch-number (condition)
Package

shop3.

Methods
Reader Method: branch-number ((condition singleton-variable))
Source

decls.lisp.

Target Slot

branch-number.

Generic Reader: child (object)
Package

shop3.

Methods
Reader Method: child ((add-child-to-tree add-child-to-tree))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

child.

Generic Function: clear-replay-table (domain table)
Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: clear-replay-table :around ((domain domain) (table hash-table))
Method: clear-replay-table ((domain domain) (table hash-table))
Generic Reader: comment (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: comment ((condition bad-argument))
Source

decls.lisp.

Target Slot

comment.

Generic Reader: construct (condition)
Package

shop3.

Methods
Reader Method: construct ((condition singleton-variable))
Source

decls.lisp.

Target Slot

construct.

Generic Reader: construct-name (condition)
Package

shop3.

Methods
Reader Method: construct-name ((condition singleton-variable))
Source

decls.lisp.

Target Slot

construct-name.

Generic Reader: construct-type (condition)
Package

shop3.

Methods
Reader Method: construct-type ((condition singleton-variable))
Source

decls.lisp.

Target Slot

construct-type.

Generic Function: copy-plan-tree-node (node)
Package

plan-tree.

Source

plan-tree.lisp.

Methods
Method: copy-plan-tree-node ((node primitive-tree-node))
Method: copy-plan-tree-node ((node top-node))
Method: copy-plan-tree-node ((node ordered-tree-node))
Method: copy-plan-tree-node ((node unordered-tree-node))
Method: copy-plan-tree-node ((node complex-tree-node))
Generic Reader: correct-arity (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: correct-arity ((condition incorrect-arity-error))
Source

decls.lisp.

Target Slot

correct-arity.

Generic Reader: cost (object)
Generic Writer: (setf cost) (object)
Package

shop3.

Methods
Reader Method: cost ((search-state search-state))
Writer Method: (setf cost) ((search-state search-state))

Cost of partial-plan.

Source

decls.lisp.

Target Slot

cost.

Return a list of forms that set any cross-links for VAL using information in TABLE.

Package

plan-tree.

Source

plan-tree.lisp.

Methods
Generic Reader: current-task (object)
Generic Writer: (setf current-task) (object)
Package

shop3.

Methods
Reader Method: current-task ((search-state search-state))
Writer Method: (setf current-task) ((search-state search-state))

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

Source

decls.lisp.

Target Slot

current-task.

Reader Method: current-task ((choice-entry choice-entry))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

current-task.

Generic Reader: dependencies (object)
Package

shop3.

Methods
Reader Method: dependencies ((add-dependencies add-dependencies))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

dependencies.

Generic Reader: depth (object)
Generic Writer: (setf depth) (object)
Package

shop3.

Methods
Reader Method: depth ((search-state search-state))
Writer Method: (setf depth) ((search-state search-state))

Depth in search. Used by the tracing functions.

Source

decls.lisp.

Target Slot

depth.

Generic Function: do-backtrack (stack-entry state)

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

Package

shop3.

Source

backtrack-stack.lisp.

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

loop-extensions.lisp.

Method: do-backtrack ((entry record-expansion-for-replay) (state search-state))
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-id-for-method-lookup (domain method)
Package

shop3.

Source

decls.lisp.

Methods
Method: domain-id-for-method-lookup ((domain actions-domain-mixin) (method list))
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.

Methods
Method: domain-include-parse ((parent-domain simple-pddl-domain) domain-name path)
Source

pddl.lisp.

Method: domain-include-parse ((parent-domain domain) domain-name path)
Generic Function: domain-items (domain-designator)

Return the source code for the items used to define this DOMAIN.

Package

shop3.

Source

decls.lisp.

Methods
Method: domain-items ((domain-name symbol))
Reader Method: domain-items ((domain domain))

Cached copy of the ITEMS source.

Target Slot

items.

Generic Function: domain-method-id-lookup (domain method-id)
Package

shop3.

Source

decls.lisp.

Methods
Method: domain-method-id-lookup ((domain actions-domain-mixin) (method-id symbol))
Generic Reader: domain-method-to-name-table (object)
Package

shop3.

Methods
Reader 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.

Target Slot

methods-to-names.

Generic Reader: domain-name-to-method-table (object)
Package

shop3.

Methods
Reader Method: domain-name-to-method-table ((actions-domain-mixin actions-domain-mixin))

Map from method IDs (symbols) to methods.

Source

decls.lisp.

Target Slot

names-to-methods.

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.

Method: expand-loop ((engine (eql :ess)) domain task1 state tasks top-tasks in-unifier &optional ess-search-state)
Source

loop-extensions.lisp.

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.

Method: expand-loop-body ((body-key (eql :for)) task-body domain state in-unifier search-state)
Source

loop-extensions.lisp.

Method: expand-loop-body ((body-key (eql :cond)) task-body domain state in-unifier search-state)
Source

loop-extensions.lisp.

Generic Function: expand-primitive-state (state domain)
Package

shop3.

Source

explicit-search.lisp.

Methods
Method: expand-primitive-state (state (domain domain))
Generic Reader: expression (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: expression ((condition incomplete-dependency-error))
Source

decls.lisp.

Target Slot

expression.

Reader Method: expression ((condition incorrect-arity-error))
Source

decls.lisp.

Target Slot

expression.

Reader Method: expression ((condition non-ground-error))
Source

decls.lisp.

Target Slot

expression.

Generic Function: find-decompositions (domain task)
Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: find-decompositions ((domain domain) (task list))
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.

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.

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.

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.

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.

Methods
Method: fluent-function-p ((domain fluents-mixin) (name symbol))
Method: fluent-function-p ((domain fluents-mixin) name)
Generic Reader: fluent-functions (object)
Package

shop3.theorem-prover.

Methods
Reader Method: fluent-functions ((fluents-mixin fluents-mixin))

List of symbols naming metric fluent functions.

Source

fluents.lisp.

Target Slot

fluent-functions.

Generic Function: guidance (domain task table alternatives)

Returns either NIL if no useful guidance is available, or a member of ALTERNATIVES to choose first.

Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: guidance :around (domain task table alternatives)
Method: guidance ((domain domain) (task list) (table hash-table) (alternatives list))
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.

Methods
Method: include-in-tag (action atom (st tagged-state))
Source

tagged-state.lisp.

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.

Methods
Method: initialize-problem ((problem problem) &key state tasks)
Source

input.lisp.

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.

Methods
Method: insert-atom (atom (st bit-state))
Source

state-utils.lisp.

Method: insert-atom (atom (st doubly-hashed-state))
Source

state-utils.lisp.

Method: insert-atom (atom (st mixed-state))
Source

state-utils.lisp.

Method: insert-atom (atom (st hash-state))
Source

state-utils.lisp.

Method: insert-atom (atom (st list-state))
Source

state-utils.lisp.

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.

Methods
Method: install-domain ((domain domain) &optional redefine-ok)
Source

input.lisp.

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.

Methods
Method: logical-keywordp ((g0 (eql shop3.theorem-prover::f-exp-value)) (domain fluents-mixin))
Source

prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:imply)) (domain disjunctive-preconditions-mixin))
Source

prover.lisp.

Method: logical-keywordp ((g0 (eql not)) (domain negative-preconditions-mixin))
Source

prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:exists)) (domain existential-preconditions-mixin))
Source

prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:forall)) (domain universal-preconditions-mixin))
Source

prover.lisp.

Method: logical-keywordp ((keyword (eql shop3.theorem-prover::%cut%)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql and)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:enforce)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql :external)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:bagof)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:setof)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:exists)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:shop-forall)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:forall)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql or)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:imply)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:assign)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.theorem-prover:assign*)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql shop3.common:call)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql eval)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp ((g0 (eql not)) domain)
Source

theorem-prover.lisp.

Method: logical-keywordp (symbol domain)
Generic Reader: logical-op (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: logical-op ((condition incomplete-dependency-error))
Source

decls.lisp.

Target Slot

logical-op.

Generic Reader: lookup-table (object)
Package

shop3.

Methods
Reader Method: lookup-table ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

lookup-table.

Generic Function: make-instantiator (obj)

Return an s-expression instantiating a copy of OBJ.
The returned form will *not* include links to other objects to make the result loadable

Package

plan-tree.

Source

plan-tree.lisp.

Methods
Method: make-instantiator ((obj top-node))
Method: make-instantiator ((obj complex-tree-node))
Method: make-instantiator ((obj primitive-tree-node))
Method: make-instantiator ((obj dependency))
Method: make-instantiator (obj)
Method: make-instantiator ((obj symbol))
Method: make-instantiator ((obj list))

LISTS should be tasks or propositions

Generic Function: make-plan-return (domain which &key state plan replay-table repairable &allow-other-keys)

Make and return a PLAN-RETURN structure. How return values are collected is directed by DOMAIN and WHICH arguments.

Package

shop3.

Source

explicit-search.lisp.

Methods
Method: make-plan-return ((domain domain) (which (eql :all)) &key state plan replay-table repairable)
Method: make-plan-return ((domain domain) (which (eql :first)) &key plan state replay-table repairable)
Generic Function: make-table-entries (node)

Traverse the plan tree, populating *TABLE-FOR-LOAD-FORM* dynamic variable and building a toplogically sorted list of nodes.

Package

plan-tree.

Source

plan-tree.lisp.

Methods
Method: make-table-entries ((obj complex-tree-node))
Method: make-table-entries ((obj dependency))
Method: make-table-entries ((obj tree-node))
Generic Function: method-definition-keywords (domain-designator)

Keywords that are acceptable for use in method definitions. Used for checking domain definitions.

Package

shop3.

Source

decls.lisp.

Methods
Method: method-definition-keywords :around ((domain-name symbol))
Method: method-definition-keywords ((domain domain))
Generic Function: method-expression-body (domain method-expr)

Helper function for parsing a method expression.
Returns the method expression’s body: the remainder of the method expression after the method keyword, the optional label, and the task have been removed.

Package

shop3.

Source

input.lisp.

Methods
Method: method-expression-body ((domain domain) (method-expr list))
Generic Function: method-expression-task (domain method-expr)

Helper function for parsing a method expression.
Returns the method expression’s task: skipping over the optional label, if any.

Package

shop3.

Source

input.lisp.

Methods
Method: method-expression-task ((domain domain) (method-expr list))
Generic Function: method-head (domain method)
Package

shop3.

Source

decls.lisp.

Methods
Method: method-head ((domain domain) (method list))
Generic Reader: method-id (object)
Package

shop3.

Methods
Reader Method: method-id ((record-expansion-for-replay record-expansion-for-replay))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

method-id.

Generic Function: method-name (domain sexpr)
Package

shop3.

Source

decls.lisp.

Methods
Method: method-name ((domain simple-pddl-domain) (sexpr list))
Source

pddl.lisp.

Method: method-name ((domain domain) (sexpr list))
Generic Function: method-p (domain sexpr)

Is SEXPR a method object relative to DOMAIN?

Package

shop3.

Source

decls.lisp.

Methods
Method: method-p ((domain simple-pddl-domain) (sexpr list))
Source

pddl.lisp.

Method: method-p ((domain domain) obj)
Method: method-p ((domain domain) (sexpr list))
Generic Function: method-preconditions (domain sexpr)
Package

shop3.

Source

decls.lisp.

Methods
Method: method-preconditions ((domain domain) (sexpr list))
Generic Function: method-task (domain sexpr)
Package

shop3.

Source

decls.lisp.

Methods
Method: method-task ((domain domain) (sexpr list))
Generic Function: method-task-net (domain sexpr)
Package

shop3.

Source

decls.lisp.

Methods
Method: method-task-net ((domain domain) (sexpr list))
Generic Reader: mode (object)
Generic Writer: (setf mode) (object)
Package

shop3.

Methods
Reader Method: mode ((search-state search-state))
Writer Method: (setf mode) ((search-state search-state))

Holds the mode – the name – of the current "instruction" in the explicit search virtual machine.

Source

decls.lisp.

Target Slot

mode.

Reader Method: mode ((choice-entry choice-entry))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

mode.

Generic Reader: old-name (condition)
Package

shop3.

Methods
Reader Method: old-name ((condition non-unique-method-name-mixin))
Source

decls.lisp.

Target Slot

old-name.

Generic Reader: op (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: op ((condition incorrect-arity-error))
Source

decls.lisp.

Target Slot

op.

Generic Function: operator (domain task-name)

Return the SHOP operator (if any) defined for TASK-NAME in DOMAIN.

Package

shop3.

Source

decls.lisp.

Methods
Method: operator :around ((domain-name symbol) op-name)
Method: operator ((domain domain) (name symbol))
Generic Reader: operators-dont-fail (object)
Package

shop3.

Methods
Reader Method: operators-dont-fail ((actions-domain-mixin actions-domain-mixin))

Boolean. If true, then it is an error if an operator
fails – all operators are expected to be put in the plan in states that satisfy their preconditions. Debugging util.

Source

decls.lisp.

Target Slot

operators-dont-fail.

Generic Reader: parent (object)
Package

shop3.

Methods
Reader Method: parent ((add-child-to-tree add-child-to-tree))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

parent.

Generic Function: parse-domain-item (domain item-keyword item)

The default method for parse-domain-items
will invoke this method to process a single item s-expression. The addition of this generic function makes SHOP’s syntax more extensible.

Package

shop3.

Source

decls.lisp.

Methods
Method: parse-domain-item ((domain simple-pddl-domain) (item-key (eql :pddl-method)) method)
Source

pddl.lisp.

Method: parse-domain-item ((domain simple-pddl-domain) (item-key (eql :requirements)) item)

For now, simply ignore requirements. Later we should check that they match the domain class.

Source

pddl.lisp.

Method: parse-domain-item ((domain fluents-mixin) (item-key (eql :functions)) item)
Source

pddl.lisp.

Method: parse-domain-item ((domain pddl-typing-mixin) (item-key (eql :types)) item)
Source

pddl.lisp.

Method: parse-domain-item ((domain simple-pddl-domain) (item-key (eql :predicates)) item)

For now, since SHOP doesn’t typecheck, we simply ignore these declarations.

Source

pddl.lisp.

Method: parse-domain-item ((domain domain) (item-key (eql :pddl-method)) item)
Source

pddl.lisp.

Method: parse-domain-item ((domain simple-pddl-domain) (item-key (eql :action)) item)
Source

pddl.lisp.

Method: parse-domain-item ((d static-predicates-mixin) (keyword (eql :static)) static-decl)
Source

input.lisp.

Method: parse-domain-item ((domain domain) (item-key (eql :-)) item)
Source

input.lisp.

Method: parse-domain-item ((domain domain) (item-key (eql :op)) item)
Source

input.lisp.

Method: parse-domain-item ((domain domain) (item-key (eql :operator)) item)
Source

input.lisp.

Method: parse-domain-item ((domain domain) (item-key (eql :method)) item)
Source

input.lisp.

Generic Reader: partial-plan (object)
Generic Writer: (setf partial-plan) (object)
Package

shop3.

Methods
Reader Method: partial-plan ((search-state search-state))
Writer Method: (setf partial-plan) ((search-state search-state))

List: current plan prefix.

Source

decls.lisp.

Target Slot

partial-plan.

Reader Method: partial-plan ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

partial-plan.

Generic Reader: partial-plan-cost (object)
Package

shop3.

Methods
Reader Method: partial-plan-cost ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

partial-plan-cost.

Generic Function: pddl-method-p (domain sexpr)
Package

shop3.

Source

pddl.lisp.

Methods
Method: pddl-method-p ((domain domain) obj)
Method: pddl-method-p ((domain simple-pddl-domain) (sexpr list))
Generic Function: pddl-plan (domain plan &key package)

Return a PDDL plan representation of PLAN for
DOMAIN (a SHOP ddomain). When PACKAGE is supplied, put the symbols into that package (instead of into the value of *PACKAGE*, which should be the default).

Package

shop3.

Source

decls.lisp.

Methods
Method: pddl-plan ((domain domain) (plan cons) &key package)
Source

pddl.lisp.

Generic Reader: pddl-types (object)
Package

shop3.

Methods
Reader Method: pddl-types ((pddl-typing-mixin pddl-typing-mixin))

automatically generated reader method

Source

pddl.lisp.

Target Slot

pddl-types.

Generic Writer: (setf pddl-types) (object)
Package

shop3.

Methods
Writer Method: (setf pddl-types) ((pddl-typing-mixin pddl-typing-mixin))

automatically generated writer method

Source

pddl.lisp.

Target Slot

pddl-types.

Generic Reader: plan (object)
Package

shop3.

Methods
Reader Method: plan ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

plan.

Generic Function: plan-cost (plan)

Return a float that is the cost of the plan argument.

Package

shop3.

Source

decls.lisp.

Methods
Method: plan-cost ((pr plan-return))
Source

decls.lisp.

Method: plan-cost ((plan list))
Source

output.lisp.

Generic Reader: plan-tree (object)
Package

shop3.

Methods
Reader Method: plan-tree ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

plan-tree.

Generic Reader: plan-tree-lookup (object)
Package

shop3.

Methods
Reader Method: plan-tree-lookup ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

plan-tree-lookup.

Generic Reader: plans-found (object)
Package

shop3.

Methods
Reader Method: plans-found ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

plans-found.

Generic Writer: (setf plans-found) (object)
Package

shop3.

Methods
Writer Method: (setf plans-found) ((search-state search-state))

automatically generated writer method

Source

decls.lisp.

Target Slot

plans-found.

Generic Reader: predicate (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: predicate ((condition bad-argument))
Source

decls.lisp.

Target Slot

predicate.

Reader Method: predicate ((condition instantiation-error))
Source

decls.lisp.

Target Slot

predicate.

Generic Function: problem->state (domain problem)

Translate PROBLEM into a list of arguments to make-initial-state.
Allows DOMAIN-specific rules for extracting special problem-components.
Note that this must return a LIST of arguments for apply, so that, for example, the default method will return a list whose only element is a list of atoms, not a simple list of atoms.

Package

shop3.

Source

decls.lisp.

Methods
Method: problem->state ((domain domain) problem)
Source

input.lisp.

Generic Function: problem-state (problem)

Alias for get-state.

Package

shop3.

Source

decls.lisp.

Methods
Method: problem-state ((problem problem))
Method: problem-state ((name symbol))
Generic Function: problem-tasks (problem)

Alias for get-tasks.

Package

shop3.

Source

decls.lisp.

Methods
Method: problem-tasks ((problem problem))
Method: problem-tasks ((name symbol))
Generic Function: process-action (domain action-def)

PDDL has actions (vanilla SHOP3 has operators), so we
add code for processing the actions that is parallel to process-operator.

Package

shop3.

Source

pddl.lisp.

Methods
Method: process-action ((domain simple-pddl-domain) action-def)
Generic Function: process-add-or-delete (domain expression &optional context-name)

Preprocess add and delete lists, finding the forall conditions and replacing the variables in them. Extendable for subtypes of the DOMAIN class.

Package

shop3.

Source

decls.lisp.

Methods
Method: process-add-or-delete ((domain domain) expr &optional context-name)
Source

input.lisp.

Generic Function: process-method-pre (domain precondition method-id &key strict)

Wrapper around process-pre that takes responsibility for
handling method-specific processing. If STRICT is non-NIL, warn about implicit conjunctions.

Package

shop3.

Source

decls.lisp.

Methods
Method: process-method-pre :around ((domain universal-preconditions-mixin) precond method-name &key strict)
Source

pddl.lisp.

Method: process-method-pre :around ((domain domain) precond method-name &key strict)
Source

input.lisp.

Method: process-method-pre ((domain domain) precondition method-id &key strict)
Generic Function: process-pre (domain precondition &optional context-name)

Preprocess the PRECONDITION in accordance with
rules established by the DOMAIN class. Default method is to standardize universal quantification, creating new variable names for the bound variables in quantified expressions.

Package

shop3.

Source

decls.lisp.

Methods
Method: process-pre (domain pre &optional context-name)

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

Source

input.lisp.

Generic Reader: protections (object)
Generic Writer: (setf protections) (object)
Package

shop3.

Methods
Reader Method: protections ((search-state search-state))
Writer Method: (setf protections) ((search-state search-state))

Set of protections in the current state.

Source

decls.lisp.

Target Slot

protections.

Reader Method: protections ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

protections.

Generic Function: real-seek-satisfiers-for (domain goal-head goal other-goals state bindings level just1 dependencies-in)

Define how a semantically meaningful logical
connective should be interpreted in the given domain.

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.

Methods
Method: real-seek-satisfiers-for ((domain fluents-mixin) (g0 (eql shop3.theorem-prover::f-exp-value)) goal other-goals state bindings level just1 dependencies-in)
Source

prover.lisp.

Method: real-seek-satisfiers-for ((domain disjunctive-preconditions-mixin) (g0 (eql shop3.theorem-prover:imply)) goal other-goals state bindings level just1 dependencies-in)
Source

prover.lisp.

Method: real-seek-satisfiers-for ((domain negative-preconditions-mixin) (g0 (eql not)) goal other-goals state bindings level just1 dependencies-in)
Source

prover.lisp.

Method: real-seek-satisfiers-for ((domain existential-preconditions-mixin) (g0 (eql shop3.theorem-prover:exists)) goal other-goals state bindings level just1 dependencies-in)
Source

prover.lisp.

Method: real-seek-satisfiers-for ((domain universal-preconditions-mixin) (g0 (eql shop3.theorem-prover:forall)) goal other-goals state bindings level just1 dependencies-in)
Source

prover.lisp.

Method: real-seek-satisfiers-for (domain (keyword (eql shop3.theorem-prover::%cut%)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql and)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:enforce)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql :external)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:bagof)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:setof)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:exists)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:shop-forall)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:forall)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql or)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:imply)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:assign)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.theorem-prover:assign*)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql shop3.common:call)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql eval)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for :before (domain (op (eql not)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain (g0 (eql not)) goal other-goals state bindings level just1 dependencies-in)
Source

theorem-prover.lisp.

Method: real-seek-satisfiers-for (domain goal-head goal other-goals state bindings level just1 dependencies-in)

The default method catches the non-keyword case: goal is an atomic predicate, so try to satisfy it. The goal-head is intact in the goal, so we ignore the extra reference.

Source

theorem-prover.lisp.

Generic Function: record-decomposition (domain task method-id &optional backtrack-stack)

Record that TASK was achieved by the method with identifier METHOD-ID
onto BACKTRACK-STACK.

Recording method may be chosen based on the class of DOMAIN.

New primary methods for this generic function should have argument specifiers that are strictly MORE specific than (domain list symbol list) in order to shadow the default method.

Package

shop3.

Source

analogical-replay.lisp.

Methods
Method: record-decomposition :after (domain task method-id &optional backtrack-stack)
Method: record-decomposition ((domain domain) (task list) (method-id symbol) &optional backtrack-stack)
Generic Function: redo-state-update (state-update-keyword state-update state)

Redo the state update instantiated in state-update.
Chooses how to do this based on state-update-keyword. Side-effecting. Used in plan repair.

Package

shop3.common.

Source

state-decls.lisp.

Methods
Method: redo-state-update ((keyword (eql shop3.common::redundant-delete)) change state)
Source

tagged-state.lisp.

Method: redo-state-update ((keyword (eql shop3.common::redundant-add)) change state)
Source

tagged-state.lisp.

Method: redo-state-update ((keyword (eql delete)) change state)
Source

tagged-state.lisp.

Method: redo-state-update ((keyword (eql shop3.common::add)) change state)
Source

tagged-state.lisp.

Generic Function: regularize-axiom (domain axiom-def)

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

Package

shop3.

Source

decls.lisp.

Methods
Method: regularize-axiom ((domain domain) axiom)
Source

input.lisp.

Generic Function: remove-atom (atom state)

Delete the atom from the statebody. 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.

Methods
Method: remove-atom (atom (st bit-state))
Source

state-utils.lisp.

Method: remove-atom (atom (st doubly-hashed-state))
Source

state-utils.lisp.

Method: remove-atom (atom (st mixed-state))
Source

state-utils.lisp.

Method: remove-atom (atom (st hash-state))
Source

state-utils.lisp.

Method: remove-atom (atom (st list-state))
Source

state-utils.lisp.

Generic Reader: replay-table (object)
Package

shop3.

Methods
Reader Method: replay-table ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

replay-table.

Generic Reader: search-state (object)
Package

shop3.

Methods
Reader Method: search-state ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

search-state.

Generic Function: seek-plans (domain state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)

Top-level task-decomposition function.

Package

shop3.

Source

decls.lisp.

Methods
Method: seek-plans ((domain domain) state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)
Source

search.lisp.

Generic Function: seek-plans-loop (domain task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections in-unifier)
Package

shop3.

Methods
Method: seek-plans-loop ((domain looping-domain) task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections in-unifier)
Source

loop-extensions.lisp.

Generic Function: seek-plans-nonprimitive (domain task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)

Applies the HTN method to the current TASK1 and generates the subtasks of TASK.
Recursively calls the task-decomposition routine to decompose the subtasks. In the LTML context, What should it do with the OUTPUTS and/or the RESULTS of that method? (TBD)

Package

shop3.

Source

decls.lisp.

Methods
Method: seek-plans-nonprimitive ((domain domain) task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections in-unifier)
Source

search.lisp.

Generic Function: seek-plans-task (domain task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)

This is a wrapper function that checks whether the current task to be decomposed is primitive or not,
and depending on the task’s type, it invokes either SEEK-PLANS-PRIMITIVE or SEEK-PLANS-NONPRIMITIVE, which are the real task-decomposition workhorses.

Package

shop3.

Source

decls.lisp.

Methods
Method: seek-plans-task ((domain looping-domain) task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)
Source

loop-extensions.lisp.

Method: seek-plans-task ((domain domain) task1 state tasks top-tasks partial-plan partial-plan-cost depth which-plans protections unifier)
Source

search.lisp.

Generic Function: slot-fillers (obj)
Package

plan-tree.

Source

plan-tree.lisp.

Methods
Method: slot-fillers ((obj top-node))
Method: slot-fillers ((obj tree-node))
Method: slot-fillers (obj)
Generic Function: store-plan! (domain which-plans plan state unifier)
Package

shop3.

Source

search.lisp.

Methods
Method: store-plan! ((domain domain) (which-plans symbol) plan state unifier)
Generic Reader: tag (object)
Package

shop3.

Methods
Reader Method: tag ((state-tag state-tag))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

tag.

Generic Reader: task (condition)
Package

shop3.

Methods
Reader Method: task ((record-expansion-for-replay record-expansion-for-replay))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

task.

Reader Method: task ((condition non-unique-method-name-mixin))
Source

decls.lisp.

Target Slot

task.

Generic Reader: task-arity-mismatch-library-entry (condition)
Package

shop3.

Methods
Reader Method: task-arity-mismatch-library-entry ((condition task-arity-mismatch))
Source

decls.lisp.

Target Slot

library-entry.

Generic Reader: task-arity-mismatch-library-task (condition)
Package

shop3.

Methods
Reader Method: task-arity-mismatch-library-task ((condition task-arity-mismatch))
Source

decls.lisp.

Target Slot

library-task.

Generic Reader: task-arity-mismatch-task (condition)
Package

shop3.

Methods
Reader Method: task-arity-mismatch-task ((condition task-arity-mismatch))
Source

decls.lisp.

Target Slot

task.

Generic Reader: tasks (object)
Generic Writer: (setf tasks) (object)
Package

shop3.

Methods
Reader Method: tasks ((search-state search-state))
Writer Method: (setf tasks) ((search-state search-state))

Current task network.

Source

decls.lisp.

Target Slot

tasks.

Reader Method: tasks ((loop-state-expand loop-state-expand))

automatically generated reader method

Source

loop-extensions.lisp.

Target Slot

tasks.

Reader Method: tasks ((method-instantiation method-instantiation))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

tasks.

Reader Method: tasks ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

tasks.

Reader Method: tasks ((problem problem))

automatically generated reader method

Source

decls.lisp.

Target Slot

tasks.

Generic Reader: top-tasks (object)
Generic Writer: (setf top-tasks) (object)
Package

shop3.

Methods
Reader Method: top-tasks ((search-state search-state))
Writer Method: (setf top-tasks) ((search-state search-state))

Current set of tasks with no predecessors; eligible to be planned.

Source

decls.lisp.

Target Slot

top-tasks.

Reader Method: top-tasks ((loop-state-expand loop-state-expand))

automatically generated reader method

Source

loop-extensions.lisp.

Target Slot

top-tasks.

Reader Method: top-tasks ((method-instantiation method-instantiation))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

top-tasks.

Reader Method: top-tasks ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

top-tasks.

Generic Function: translate-effect (domain expression)

This generic function is used to translate PDDL-style effects
into SHOP3-style syntax. The rewriting is done based on the domain so that different syntax features can be turned on and off.

Package

shop3.

Source

pddl.lisp.

Methods
Method: translate-effect :around ((domain fluents-mixin) effect)

This method translates any metric effects into updates using ASSIGN-FLUENT. It then invokes the next method, to insure that all the other
PDDL - SHOP3 constructs are translated.

Method: translate-effect ((domain conditional-effects-mixin) effect)

This method translates any forall expressions in a PDDL effect into the slightly-different SHOP3 FORALL syntax.
It then invokes the next method, to insure that all PDDL - SHOP3 constructs are translated.

Method: translate-effect ((domain simple-pddl-domain) effect)

Basis method for translating a PDDL effect into SHOP3 syntax is to just leave it alone.

Generic Function: translate-precondition (domain expression)

This generic function is used to translate PDDL-style preconditions into SHOP3-style syntax. The rewriting is done based on the domain so that different syntax features can be turned on and off.

Package

shop3.

Source

pddl.lisp.

Methods
Method: translate-precondition :around ((domain fluents-mixin) expression)
Method: translate-precondition ((domain existential-preconditions-mixin) expression)

This method translates any exists expressions in a PDDL precondition into the slightly-different SHOP3 EXISTS syntax.
It then invokes the next method, to insure that all PDDL - SHOP3 constructs are translated.

Method: translate-precondition ((domain universal-preconditions-mixin) expression)

This method translates any forall expressions in a PDDL precondition into the slightly-different SHOP3 FORALL syntax.
It then invokes the next method, to insure that all PDDL - SHOP3 constructs are translated.

Method: translate-precondition ((domain simple-pddl-domain) expression)

Basis method for translating a PDDL precondition into SHOP3 syntax is to just leave it alone.

Generic Reader: tree (object)
Package

shop3.

Methods
Reader Method: tree ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

tree.

Generic Reader: tree-node (object)
Package

shop3.

Methods
Reader Method: tree-node ((record-expansion record-expansion))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

tree-node.

Generic Function: undo-state-update (state-update-keyword state-update state)

Undo the state update instantiated in state-update.
Chooses how to do this based on state-update-keyword. Side-effecting. Used inside RETRACT-STATE-CHANGES.

Package

shop3.common.

Source

state-decls.lisp.

Methods
Method: undo-state-update ((keyword (eql shop3.common::redundant-delete)) change state)
Source

tagged-state.lisp.

Method: undo-state-update ((keyword (eql shop3.common::redundant-add)) change state)
Source

tagged-state.lisp.

Method: undo-state-update ((keyword (eql delete)) change state)
Source

tagged-state.lisp.

Method: undo-state-update ((keyword (eql shop3.common::add)) change state)
Source

tagged-state.lisp.

Generic Function: unfold-loop-task (domain state)

Driver for the looping tasks.

Package

shop3.

Source

explicit-search.lisp.

Methods
Method: unfold-loop-task ((domain looping-domain) ess-search-state)
Source

loop-extensions.lisp.

Generic Reader: unifier (object)
Package

shop3.

Methods
Reader Method: unifier ((loop-state-expand loop-state-expand))

automatically generated reader method

Source

loop-extensions.lisp.

Target Slot

unifier.

Reader Method: unifier ((method-instantiation method-instantiation))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

unifier.

Reader Method: unifier ((prim-state-expand prim-state-expand))

automatically generated reader method

Source

backtrack-stack.lisp.

Target Slot

unifier.

Reader Method: unifier ((search-state search-state))

automatically generated reader method

Source

decls.lisp.

Target Slot

unifier.

Generic Writer: (setf unifier) (object)
Package

shop3.

Methods
Writer Method: (setf unifier) ((search-state search-state))

automatically generated writer method

Source

decls.lisp.

Target Slot

unifier.

Generic Reader: var (condition)
Package

shop3.theorem-prover.

Methods
Reader Method: var ((condition non-ground-error))
Source

decls.lisp.

Target Slot

var.

Generic Reader: variable-names (condition)
Package

shop3.

Methods
Reader Method: variable-names ((condition singleton-variable))
Source

decls.lisp.

Target Slot

variable-names.

Generic Reader: world-state (object)
Generic Writer: (setf world-state) (object)
Package

shop3.

Methods
Reader Method: world-state ((search-state search-state))
Writer Method: (setf world-state) ((search-state search-state))

SHOP2 world state object.

Source

decls.lisp.

Target Slot

world-state.

Reader Method: world-state ((plan-return plan-return))

automatically generated reader method

Source

decls.lisp.

Target Slot

world-state.


6.2.6 Conditions

Condition: cut-commit
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses

condition.

Condition: domain-item-parse-warning

We have a separate class for warnings generated while parsing
a shop domain. This is done because the items in the SHOP domain parsing are processed in reverse order, so we would like to grab up all of these warnings and then re-issue them in lexical order.

Package

shop3.

Source

decls.lisp.

Direct superclasses

domain-parse-warning.

Direct subclasses

singleton-variable.

Condition: domain-parse-error
Package

shop3.

Source

decls.lisp.

Direct superclasses
Direct subclasses

non-unique-method-name-error.

Condition: domain-parse-warning
Package

shop3.

Source

decls.lisp.

Direct superclasses
Direct subclasses

domain-item-parse-warning.

Condition: domain-style-warning
Package

shop3.

Source

decls.lisp.

Direct superclasses
Direct subclasses
Condition: implicit-conjunction-warning
Package

shop3.

Source

decls.lisp.

Direct superclasses

domain-style-warning.

Direct slots
Slot: bad-conjunction
Initargs

:bad-conjunction

Slot: context-type
Initargs

:context-type

Slot: context-name
Initargs

:context-name

Slot: replacement
Initargs

:replacement

Condition: incorrect-arity-error
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses
Direct methods
Direct slots
Slot: op
Initargs

:op

Readers

op.

Writers

This slot is read-only.

Slot: correct-arity
Initargs

:correct-arity

Readers

correct-arity.

Writers

This slot is read-only.

Slot: expression
Initargs

:expression

Readers

expression.

Writers

This slot is read-only.

Condition: no-failed-task
Package

shop3.

Source

plan-repair.lisp.

Direct superclasses

condition.

Condition: non-unique-method-name-error
Package

shop3.

Source

decls.lisp.

Direct superclasses
Condition: non-unique-method-name-mixin
Package

shop3.

Source

decls.lisp.

Direct superclasses

condition.

Direct subclasses
Direct methods
Direct slots
Slot: old-name
Initargs

:old-name

Readers

old-name.

Writers

This slot is read-only.

Slot: task
Initargs

:task

Readers

task.

Writers

This slot is read-only.

Condition: non-unique-method-name-warning
Package

shop3.

Source

decls.lisp.

Direct superclasses
Condition: search-failed

Condition to be signaled when the system has backtracked to the bottom of the stack.

Package

shop3.

Source

decls.lisp.

Direct superclasses

condition.

Condition: shop-condition

A condition that should be added to all conditions defined in SHOP.

Package

shop3.

Source

decls.lisp.

Direct superclasses

condition.

Direct subclasses
Condition: shop-error

A convenient superclass for SHOP error conditions.

Package

shop3.

Source

decls.lisp.

Direct superclasses
Direct subclasses

6.2.7 Structures

Structure: binding

A binding is a structure with a variable and a value.

Package

shop3.unifier.

Source

unify.lisp.

Direct superclasses

structure-object.

Direct methods

make-load-form.

Direct slots
Slot: var
Readers

binding-var.

Writers

(setf binding-var).

Slot: val
Readers

binding-val.

Writers

(setf binding-val).

Structure: bit-state
Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

tagged-state.

Direct methods
Structure: doubly-hashed-state

A ‘:doubly-hashed‘ state is like singly-hashed (‘:mixed‘) state. I.e., the body is represented as a hash table, hashed on the predicate, not on
the entire state atom (as in the ‘:hash‘ type state). *Unlike* a singly-hashed state, the entry for a predicate will be a sub-hash table for the second argument.

Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

tagged-state.

Direct methods
Structure: hash-state
Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

tagged-state.

Direct methods
Structure: list-state
Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

tagged-state.

Direct methods
Structure: mixed-state

A ‘:mixed‘ state is a singly-hashed state. I.e., the body is represented as a hash table, hashed on the predicate, not on the entire state atom (as in the ‘:hash‘ type state).

Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

tagged-state.

Direct methods
Structure: raw-depend

Raw dependency record, computed by the theorem-prover before using it to build dependency records in the enhanced plan trees.

Package

shop3.theorem-prover.

Source

decls.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: prop
Readers

rd-prop.

Writers

(setf rd-prop).

Slot: est
Readers

rd-est.

Writers

(setf rd-est).

Structure: replay-table-entry
Package

shop3.

Source

analogical-replay.lisp.

Direct superclasses

structure-object.

Direct methods

%update-singleton.

Direct slots
Slot: singleton
Type

symbol

Readers

replay-table-entry-singleton.

Writers

(setf replay-table-entry-singleton).

Slot: alist
Type

list

Readers

replay-table-entry-alist.

Writers

(setf replay-table-entry-alist).

Structure: state-update
Package

shop3.common.

Source

state-decls.lisp.

Direct superclasses

structure-object.

Direct slots
Slot: action
Type

shop3.common::action-type

Initform

(quote shop3.common::add)

Readers

state-update-action.

Writers

(setf state-update-action).

Slot: literal
Type

list

Readers

state-update-literal.

Writers

(setf state-update-literal).


6.2.8 Classes

Class: actions-domain-mixin
Package

shop3.

Source

decls.lisp.

Direct subclasses

domain.

Direct methods
Direct Default Initargs
InitargValue
:operators-dont-failnil
Direct slots
Slot: methods
Initargs

:methods

Readers

domain-methods.

Writers

This slot is read-only.

Slot: operators
Initargs

:operators

Readers

domain-operators.

Writers

This slot is read-only.

Slot: methods-to-names

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

Initform

(make-hash-table :test (quote eq))

Readers

domain-method-to-name-table.

Writers

This slot is read-only.

Slot: names-to-methods

Map from method IDs (symbols) to methods.

Initform

(make-hash-table :test (quote eq))

Readers

domain-name-to-method-table.

Writers

This slot is read-only.

Slot: operators-dont-fail

Boolean. If true, then it is an error if an operator
fails – all operators are expected to be put in the plan in states that satisfy their preconditions. Debugging util.

Initargs

:operators-dont-fail

Readers

operators-dont-fail.

Writers

This slot is read-only.

Class: add-child-to-tree
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: parent
Type

(or plan-tree:complex-tree-node null)

Initargs

:parent

Readers

parent.

Writers

This slot is read-only.

Slot: child
Type

(or plan-tree:tree-node null)

Initargs

:child

Readers

child.

Writers

This slot is read-only.

Class: add-dependencies
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: dependencies
Initargs

:dependencies

Readers

dependencies.

Writers

This slot is read-only.

Class: bottom-of-stack

Sentinel value for the bottom of the backtrack stack.

Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Class: choice-entry
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: mode
Type

symbol

Initargs

:mode

Readers

mode.

Writers

This slot is read-only.

Slot: current-task
Initargs

:current-task

Readers

current-task.

Writers

This slot is read-only.

Slot: alternatives
Initargs

:alternatives

Readers

alternatives.

Writers

This slot is read-only.

Class: cl-file
Package

shop-asd.

Direct subclasses

tester-cl-source-file.

Class: domain-core

Core class that is the parent of all domain classes, both theorem-prover and SHOP3.

Package

shop3.common.

Source

state-decls.lisp.

Direct subclasses

thpr-domain.

Class: fluents-mixin

MIXIN that adds support for PDDL metric fluents.

Package

shop3.theorem-prover.

Source

fluents.lisp.

Direct methods
Direct slots
Slot: fluent-functions

List of symbols naming metric fluent functions.

Initargs

:fluent-functions

Readers

fluent-functions.

Writers

This slot is read-only.

Class: has-axioms-mixin
Package

shop3.theorem-prover.

Source

decls.lisp.

Direct subclasses

thpr-domain.

Direct methods
Direct slots
Slot: axioms
Initform

(make-hash-table :test (quote eq))

Readers

domain-axioms.

Writers

This slot is read-only.

Class: loop-state-expand
Package

shop3.

Source

loop-extensions.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: top-tasks
Initargs

:top-tasks

Readers

top-tasks.

Writers

This slot is read-only.

Slot: tasks
Initargs

:tasks

Readers

tasks.

Writers

This slot is read-only.

Slot: unifier
Initargs

:unifier

Readers

unifier.

Writers

This slot is read-only.

Class: looping-domain

Mixin domain class for HTNs with LOOP tasks in them.

Package

shop3.

Source

loop-extensions.lisp.

Direct superclasses

domain.

Direct methods
Class: method-instantiation
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: unifier
Initargs

:unifier

Readers

unifier.

Writers

This slot is read-only.

Slot: top-tasks
Initargs

:top-tasks

Readers

top-tasks.

Writers

This slot is read-only.

Slot: tasks
Initargs

:tasks

Readers

tasks.

Writers

This slot is read-only.

Class: plan-return

Store the multiple return aspects for a single SHOP plan.

Package

shop3.

Source

decls.lisp.

Direct methods
Direct slots
Slot: plan
Initargs

:plan

Readers

plan.

Writers

This slot is read-only.

Slot: tree
Type

(or null plan-tree:top-node)

Initargs

:tree

Readers

tree.

Writers

This slot is read-only.

Slot: lookup-table
Initargs

:lookup-table

Readers

lookup-table.

Writers

This slot is read-only.

Slot: replay-table
Initargs

:replay-table

Readers

replay-table.

Writers

This slot is read-only.

Slot: world-state
Initargs

:world-state

Readers

world-state.

Writers

This slot is read-only.

Slot: search-state
Initargs

:search-state

Readers

search-state.

Writers

This slot is read-only.

Class: prim-state-expand
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: top-tasks
Initargs

:top-tasks

Readers

top-tasks.

Writers

This slot is read-only.

Slot: tasks
Initargs

:tasks

Readers

tasks.

Writers

This slot is read-only.

Slot: protections
Initargs

:protections

Readers

protections.

Writers

This slot is read-only.

Slot: partial-plan
Initargs

:partial-plan

Readers

partial-plan.

Writers

This slot is read-only.

Slot: unifier
Initargs

:unifier

Readers

unifier.

Writers

This slot is read-only.

Slot: partial-plan-cost
Initargs

:partial-plan-cost

Readers

partial-plan-cost.

Writers

This slot is read-only.

Class: record-expansion

Record the expansion of a TASK into an EXPANDED-TASK.
What this means is that we are recording the match of the TASK as a template against a standardized EXPANDED-TASK from the plan library.

Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: tree-node
Type

plan-tree:tree-node

Initargs

:tree-node

Readers

tree-node.

Writers

This slot is read-only.

Class: record-expansion-for-replay

Record the expansion of TASK according to METHOD-ID. This may later be used by the analogical replay code.

Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: task
Type

list

Initargs

:task

Readers

task.

Writers

This slot is read-only.

Slot: method-id
Type

symbol

Initargs

:method-id

Readers

method-id.

Writers

This slot is read-only.

Class: search-state
Package

shop3.

Source

decls.lisp.

Direct methods
Direct slots
Slot: mode

Holds the mode – the name – of the current "instruction" in the explicit search virtual machine.

Type

symbol

Initargs

:mode

Readers

mode.

Writers

(setf mode).

Slot: current-task

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

Type

(or list null)

Initargs

:current-task

Readers

current-task.

Writers

(setf current-task).

Slot: alternatives
Initargs

:alternatives

Readers

alternatives.

Writers

(setf alternatives).

Slot: world-state

SHOP2 world state object.

Initargs

:world-state, :state

Readers
Writers
Slot: protections

Set of protections in the current state.

Initargs

:protections

Readers

protections.

Writers

(setf protections).

Slot: tasks

Current task network.

Initargs

:tasks

Readers

tasks.

Writers

(setf tasks).

Slot: top-tasks

Current set of tasks with no predecessors; eligible to be planned.

Initargs

:top-tasks

Readers

top-tasks.

Writers

(setf top-tasks).

Slot: partial-plan

List: current plan prefix.

Initargs

:partial-plan

Readers

partial-plan.

Writers

(setf partial-plan).

Slot: cost

Cost of partial-plan.

Type

number

Initform

0

Initargs

:cost

Readers

cost.

Writers

(setf cost).

Slot: unifier
Initargs

:unifier

Readers

unifier.

Writers

(setf unifier).

Slot: depth

Depth in search. Used by the tracing functions.

Type

integer

Initform

0

Initargs

:depth

Readers

depth.

Writers

(setf depth).

Slot: backtrack-stack
Initform

(list (make-instance (quote shop3::bottom-of-stack)))

Initargs

:backtrack-stack

Readers

backtrack-stack.

Writers

(setf backtrack-stack).

Slot: plans-found
Initargs

:plans-found

Readers

plans-found.

Writers

(setf plans-found).

Slot: plan-tree
Initargs

:plan-tree

Readers

plan-tree.

Writers

This slot is read-only.

Slot: plan-tree-lookup
Initform

(make-hash-table :test (quote eq))

Readers

plan-tree-lookup.

Writers

This slot is read-only.

Class: shop-fiveam-tester
Package

shop-asd.

Source

shop3.asd.

Direct superclasses
Class: shop-tester-mixin

Mixin that adds silent functioning of SHOP3.

Package

shop-asd.

Source

shop3.asd.

Direct subclasses

shop-fiveam-tester.

Class: stack-entry

"Abstract" stack entry class, ancestor to all real stack-entry classes.

Package

shop3.

Source

backtrack-stack.lisp.

Direct subclasses
Class: state-tag
Package

shop3.

Source

backtrack-stack.lisp.

Direct superclasses

stack-entry.

Direct methods
Direct slots
Slot: tag
Initargs

:tag

Readers

tag.

Writers

This slot is read-only.

Class: tester-cl-source-file

Special class that will have to recompile no matter what...

Package

shop-asd.

Source

shop3.asd.

Direct superclasses

cl-file.

Direct methods

operation-done-p.


6.2.9 Types

Type: action-type ()
Package

shop3.common.

Source

state-decls.lisp.

Type: complex-node ()
Package

shop3.

Source

tree-accessors.lisp.

Type: divergence-list ()
Package

shop3.

Source

plan-repair.lisp.

Type: list-raw-depend-lists ()
Package

shop3.theorem-prover.

Source

decls.lisp.

Type: operator ()
Package

shop3.

Source

decls.lisp.

Type: pddl-action ()
Package

shop3.

Source

decls.lisp.

Type: primitive-node ()
Package

shop3.

Source

tree-accessors.lisp.

Type: raw-depend-list ()
Package

shop3.theorem-prover.

Source

decls.lisp.

Type: tree-node ()
Package

shop3.

Source

tree-accessors.lisp.

Type: values! (&rest types)

Like ‘cl:values’, but implicit additional values are forbidden.

Package

shop3.

Source

decls.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   Q   R   S   T   U   V   W  
Index Entry  Section

%
%delete-a-decomposition: Private generic functions
%delete-a-decomposition: Private generic functions
%make-bit-state: Private ordinary functions
%new-method-id: Private ordinary functions
%record-a-decomposition: Private generic functions
%record-a-decomposition: Private generic functions
%update-singleton: Private generic functions
%update-singleton: Private generic functions

(
(setf alternatives): Private generic functions
(setf alternatives): Private generic functions
(setf backtrack-stack): Private generic functions
(setf backtrack-stack): Private generic functions
(setf binding-val): Public ordinary functions
(setf binding-var): Public ordinary functions
(setf bit-state-block-at): Private ordinary functions
(setf bit-state-body): Private ordinary functions
(setf bit-state-tags-info): Private ordinary functions
(setf complex-node-children): Public ordinary functions
(setf complex-node-task): Public ordinary functions
(setf complex-tree-node-children): Public ordinary functions
(setf complex-tree-node-dependencies): Private ordinary functions
(setf complex-tree-node-expanded-task): Private ordinary functions
(setf complex-tree-node-method-name): Public ordinary functions
(setf complex-tree-node-parent): Private ordinary functions
(setf complex-tree-node-task): Private ordinary functions
(setf consumer): Public ordinary functions
(setf cost): Private generic functions
(setf cost): Private generic functions
(setf current-task): Private generic functions
(setf current-task): Private generic functions
(setf depth): Private generic functions
(setf depth): Private generic functions
(setf doubly-hashed-state-block-at): Private ordinary functions
(setf doubly-hashed-state-body): Private ordinary functions
(setf doubly-hashed-state-tags-info): Private ordinary functions
(setf establisher): Public ordinary functions
(setf hash-state-block-at): Private ordinary functions
(setf hash-state-body): Private ordinary functions
(setf hash-state-tags-info): Private ordinary functions
(setf list-state-block-at): Private ordinary functions
(setf list-state-body): Private ordinary functions
(setf list-state-tags-info): Private ordinary functions
(setf mixed-state-block-at): Private ordinary functions
(setf mixed-state-body): Private ordinary functions
(setf mixed-state-tags-info): Private ordinary functions
(setf mode): Private generic functions
(setf mode): Private generic functions
(setf operator-additions): Private ordinary functions
(setf operator-cost-fun): Private ordinary functions
(setf operator-deletions): Private ordinary functions
(setf operator-head): Private ordinary functions
(setf operator-preconditions): Private ordinary functions
(setf ordered-tree-node-children): Private ordinary functions
(setf ordered-tree-node-dependencies): Private ordinary functions
(setf ordered-tree-node-expanded-task): Private ordinary functions
(setf ordered-tree-node-method-name): Private ordinary functions
(setf ordered-tree-node-parent): Private ordinary functions
(setf ordered-tree-node-task): Private ordinary functions
(setf partial-plan): Private generic functions
(setf partial-plan): Private generic functions
(setf pddl-action-cost-fun): Private ordinary functions
(setf pddl-action-effect): Private ordinary functions
(setf pddl-action-head): Private ordinary functions
(setf pddl-action-precondition): Private ordinary functions
(setf pddl-types): Private generic functions
(setf pddl-types): Private generic functions
(setf plans-found): Private generic functions
(setf plans-found): Private generic functions
(setf primitive-node-cost): Public ordinary functions
(setf primitive-node-position): Public ordinary functions
(setf primitive-node-task): Public ordinary functions
(setf primitive-tree-node-dependencies): Private ordinary functions
(setf primitive-tree-node-expanded-task): Private ordinary functions
(setf primitive-tree-node-parent): Private ordinary functions
(setf primitive-tree-node-task): Private ordinary functions
(setf prop): Public ordinary functions
(setf protections): Private generic functions
(setf protections): Private generic functions
(setf pseudo-node-children): Private ordinary functions
(setf pseudo-node-dependencies): Private ordinary functions
(setf pseudo-node-expanded-task): Private ordinary functions
(setf pseudo-node-method-name): Private ordinary functions
(setf pseudo-node-parent): Private ordinary functions
(setf pseudo-node-task): Private ordinary functions
(setf rd-est): Private ordinary functions
(setf rd-prop): Private ordinary functions
(setf replay-table-entry-alist): Private ordinary functions
(setf replay-table-entry-singleton): Private ordinary functions
(setf state): Public generic functions
(setf state): Public generic functions
(setf state-body): Private ordinary functions
(setf state-update-action): Private ordinary functions
(setf state-update-literal): Private ordinary functions
(setf tagged-state-block-at): Private ordinary functions
(setf tagged-state-body): Private ordinary functions
(setf tagged-state-tags-info): Private ordinary functions
(setf tasks): Private generic functions
(setf tasks): Private generic functions
(setf top-node-children): Private ordinary functions
(setf top-node-dependencies): Private ordinary functions
(setf top-node-expanded-task): Private ordinary functions
(setf top-node-lookup-table): Private ordinary functions
(setf top-node-method-name): Private ordinary functions
(setf top-node-parent): Private ordinary functions
(setf top-node-task): Private ordinary functions
(setf top-tasks): Private generic functions
(setf top-tasks): Private generic functions
(setf tree-node-dependencies): Public ordinary functions
(setf tree-node-expanded-task): Public ordinary functions
(setf tree-node-parent): Public ordinary functions
(setf tree-node-task): Public ordinary functions
(setf tree-node-task): Public ordinary functions
(setf unifier): Private generic functions
(setf unifier): Private generic functions
(setf unordered-tree-node-children): Private ordinary functions
(setf unordered-tree-node-dependencies): Private ordinary functions
(setf unordered-tree-node-expanded-task): Private ordinary functions
(setf unordered-tree-node-method-name): Private ordinary functions
(setf unordered-tree-node-parent): Private ordinary functions
(setf unordered-tree-node-task): Private ordinary functions
(setf world-state): Private generic functions
(setf world-state): Private generic functions

A
acceptable-cost-p: Private ordinary functions
add-atom-to-state: Public generic functions
add-atom-to-state: Public generic functions
add-protection: Private ordinary functions
add-source: Private ordinary functions
all-elements-bindings: Private ordinary functions
all-primitive-nodes: Public ordinary functions
all-raw-depends-lists-p: Private ordinary functions
all-raw-depends-p: Private ordinary functions
all-roots: Private ordinary functions
already-immediate-p: Private ordinary functions
alternatives: Private generic functions
alternatives: Private generic functions
alternatives: Private generic functions
anonymous-var-p: Public ordinary functions
anonymous-var-symbol-p: Private ordinary functions
answer-set-union: Private ordinary functions
appendf: Private macros
apply-action: Private ordinary functions
apply-method: Private generic functions
apply-method: Private generic functions
apply-method-bindings: Private ordinary functions
apply-operator: Public generic functions
apply-operator: Public generic functions
apply-substitution: Public macros
apply-substitution-to-tree: Private ordinary functions
argno: Private generic functions
argno: Private generic functions
argno: Private generic functions
assign-domain-method-id: Private generic functions
assign-domain-method-id: Private generic functions
atom-in-state-p: Private generic functions
atom-in-state-p: Private generic functions
atom-in-state-p: Private generic functions
atom-in-state-p: Private generic functions
atom-in-state-p: Private generic functions
atom-in-state-p: Private generic functions
axiom-sexp-p: Private ordinary functions
axioms: Public generic functions
axioms: Public generic functions
axioms: Public generic functions

B
backtrack: Private ordinary functions
backtrack-stack: Private generic functions
backtrack-stack: Private generic functions
binding-list-value: Public ordinary functions
binding-p: Private ordinary functions
binding-val: Public ordinary functions
binding-var: Public ordinary functions
bit-state-block-at: Private ordinary functions
bit-state-body: Private ordinary functions
bit-state-p: Private ordinary functions
bit-state-tags-info: Private ordinary functions
bit-statebody-increment-position: Private ordinary functions
bit-statebody-search-array: Private ordinary functions
branch-number: Private generic functions
branch-number: Private generic functions

C
call: Public macros
canonically-order: Private ordinary functions
catch-internal-time: Private macros
check-constraints: Private ordinary functions
check-for-singletons: Private ordinary functions
child: Private generic functions
child: Private generic functions
choose-immediate-task: Private ordinary functions
choose-immediate-task-state: Private ordinary functions
choose-method-bindings-state: Private ordinary functions
choose-method-state: Private ordinary functions
choose-toplevel-task: Private ordinary functions
clear-replay-table: Private generic functions
clear-replay-table: Private generic functions
clear-replay-table: Private generic functions
clobbered-p: Private ordinary functions
comment: Private generic functions
comment: Private generic functions
complex-node-children: Public ordinary functions
complex-node-p: Public ordinary functions
complex-node-task: Public ordinary functions
complex-tree-node-children: Public ordinary functions
complex-tree-node-dependencies: Private ordinary functions
complex-tree-node-expanded-task: Private ordinary functions
complex-tree-node-method-name: Public ordinary functions
complex-tree-node-p: Private ordinary functions
complex-tree-node-parent: Private ordinary functions
complex-tree-node-task: Private ordinary functions
compose-substitutions: Public ordinary functions
compute-fluent-updates: Private ordinary functions
construct: Private generic functions
construct: Private generic functions
construct-name: Private generic functions
construct-name: Private generic functions
construct-type: Private generic functions
construct-type: Private generic functions
consumer: Public ordinary functions
copy-binding: Private ordinary functions
copy-complex-node: Private ordinary functions
copy-complex-tree-node: Private ordinary functions
copy-dependency: Private ordinary functions
copy-hash-table: Private ordinary functions
copy-operator: Private ordinary functions
copy-ordered-tree-node: Private ordinary functions
copy-pddl-action: Private ordinary functions
copy-plan-tree: Public ordinary functions
copy-plan-tree: Public ordinary functions
copy-plan-tree-node: Private generic functions
copy-plan-tree-node: Private generic functions
copy-plan-tree-node: Private generic functions
copy-plan-tree-node: Private generic functions
copy-plan-tree-node: Private generic functions
copy-plan-tree-node: Private generic functions
copy-primitive-node: Private ordinary functions
copy-primitive-tree-node: Private ordinary functions
copy-pseudo-node: Private ordinary functions
copy-raw-depend: Private ordinary functions
copy-replay-table-entry: Private ordinary functions
copy-shop-problem: Public generic functions
copy-shop-problem: Public generic functions
copy-state: Public generic functions
copy-state: Public generic functions
copy-state: Public generic functions
copy-state: Public generic functions
copy-state: Public generic functions
copy-state: Public generic functions
copy-state-update: Private ordinary functions
copy-task-tree: Private ordinary functions
copy-top-node: Private ordinary functions
copy-tree-node: Private ordinary functions
copy-unordered-tree-node: Private ordinary functions
correct-arity: Private generic functions
correct-arity: Private generic functions
cost: Private generic functions
cost: Private generic functions
count-method-branches: Private ordinary functions
create-node-children-table: Private ordinary functions
cross-links-for: Private generic functions
cross-links-for: Private generic functions
cross-links-for: Private generic functions
cross-links-for: Private generic functions
current-task: Private generic functions
current-task: Private generic functions
current-task: Private generic functions

D
decode-tag: Public ordinary functions
decode-task: Private ordinary functions
def-logical-keyword: Public macros
def-problem-set: Public macros
default-state-type: Public generic functions
default-state-type: Public generic functions
defconstant: Private macros
defdomain: Public macros
defproblem: Public macros
delete-atom-from-state: Public generic functions
delete-atom-from-state: Public generic functions
delete-domain: Public generic functions
delete-domain: Public generic functions
delete-domain: Public generic functions
delete-problem: Public generic functions
delete-problem: Public generic functions
delete-problem: Public generic functions
delete-protection: Private ordinary functions
delete-protections: Private ordinary functions
delete-state-tag-decoder: Public ordinary functions
delete-tag-map: Public ordinary functions
delete-task-main-list: Private ordinary functions
delete-task-top-list: Private ordinary functions
dependencies: Private generic functions
dependencies: Private generic functions
dependency-for-negation: Private ordinary functions
dependency-p: Private ordinary functions
depth: Private generic functions
depth: Private generic functions
determine-verbosity: Private ordinary functions
divergence-list-p: Private ordinary functions
divergence-op-p: Private ordinary functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-backtrack: Private generic functions
do-conjunct: Private ordinary functions
do-conjunct-from-atoms: Private ordinary functions
do-conjunct-from-axiom: Private ordinary functions
do-conjunct-from-axioms: Private ordinary functions
do-problems: Public ordinary functions
domain-axioms: Public generic functions
domain-axioms: Public generic functions
domain-id-for-method-lookup: Private generic functions
domain-id-for-method-lookup: Private generic functions
domain-include-parse: Private generic functions
domain-include-parse: Private generic functions
domain-include-parse: Private generic functions
domain-include-search: Private ordinary functions
domain-items: Private generic functions
domain-items: Private generic functions
domain-items: Private generic functions
domain-method-id-lookup: Private generic functions
domain-method-id-lookup: Private generic functions
domain-method-to-name-table: Private generic functions
domain-method-to-name-table: Private generic functions
domain-methods: Public generic functions
domain-methods: Public generic functions
domain-methods: Public generic functions
domain-name: Public generic functions
domain-name: Public generic functions
domain-name: Public generic functions
domain-name: Public generic functions
domain-name-to-method-table: Private generic functions
domain-name-to-method-table: Private generic functions
domain-operators: Public generic functions
domain-operators: Public generic functions
domain-operators: Public generic functions
doubly-hashed-state-block-at: Private ordinary functions
doubly-hashed-state-body: Private ordinary functions
doubly-hashed-state-p: Private ordinary functions
doubly-hashed-state-tags-info: Private ordinary functions
dummy-external-access-hook: Private ordinary functions
dump-higher-cost-plans!: Private ordinary functions
dump-previous-plans!: Private ordinary functions

E
empty-p: Private ordinary functions
establisher: Public ordinary functions
expand-include: Private ordinary functions
expand-includes: Private ordinary functions
expand-loop: Private generic functions
expand-loop: Private generic functions
expand-loop: Private generic functions
expand-loop-body: Private generic functions
expand-loop-body: Private generic functions
expand-loop-body: Private generic functions
expand-loop-body: Private generic functions
expand-primitive-state: Private generic functions
expand-primitive-state: Private generic functions
explain-satisfier: Public ordinary functions
expression: Private generic functions
expression: Private generic functions
expression: Private generic functions
expression: Private generic functions
extend-plan-tree-nodes: Private ordinary functions
external-find-satisfiers: Private ordinary functions
external-query: Private ordinary functions
extract-adds-and-deletes: Private ordinary functions
extract-method-id: Private ordinary functions
extract-subtasks: Private ordinary functions
extract-subtree: Private ordinary functions
extract-suffix: Private ordinary functions
extract-tree: Private ordinary functions
extract-trees: Private ordinary functions
extract-variables: Public ordinary functions

F
filter-singletons: Private ordinary functions
find-adder: Private ordinary functions
find-all-complex-node-for-task: Public ordinary functions
find-all-complex-node-if: Public ordinary functions
find-all-primitive-nodes-if: Public ordinary functions
find-binding: Private ordinary functions
find-checking-path: Private ordinary functions
find-complex-node-for-task: Public ordinary functions
find-complex-node-if: Public ordinary functions
find-decompositions: Private generic functions
find-decompositions: Private generic functions
find-deleter: Private ordinary functions
find-domain: Public ordinary functions
find-failed-choice-entry: Private generic functions
find-failed-choice-entry: Private generic functions
find-failed-choice-entry: Private generic functions
find-failed-stack-entry: Private generic functions
find-failed-stack-entry: Private generic functions
find-failed-stack-entry: Private generic functions
find-failed-task: Public generic functions
find-failed-task: Public generic functions
find-failed-task: Public generic functions
find-failed-task: Public generic functions
find-next-main-list: Private ordinary functions
find-plan-step: Public ordinary functions
find-plan-suffix: Private ordinary functions
find-plans: Public ordinary functions
find-plans-1: Private ordinary functions
find-plans-stack: Public ordinary functions
find-primitive-node-for-task: Public ordinary functions
find-primitive-node-if: Public ordinary functions
find-problem: Public ordinary functions
find-satisfiers: Public ordinary functions
find-task-in-tree: Public ordinary functions
find-tree-node-if: Public ordinary functions
find-variable: Private ordinary functions
first-word-equal: Private ordinary functions
fix-uninterned-bindings: Public ordinary functions
fluent-comparison-p: Private generic functions
fluent-comparison-p: Private generic functions
fluent-comparison-p: Private generic functions
fluent-expr-p: Private generic functions
fluent-expr-p: Private generic functions
fluent-expr-p: Private generic functions
fluent-expr-p: Private generic functions
fluent-function-p: Private generic functions
fluent-function-p: Private generic functions
fluent-function-p: Private generic functions
fluent-functions: Private generic functions
fluent-functions: Private generic functions
force-immediate: Private ordinary functions
force-immediate-reduction: Private ordinary functions
force-immediate-unordered: Private ordinary functions
freeze-state: Private ordinary functions
fully-instantiated-goal: Private ordinary functions
Function, %make-bit-state: Private ordinary functions
Function, %new-method-id: Private ordinary functions
Function, (setf binding-val): Public ordinary functions
Function, (setf binding-var): Public ordinary functions
Function, (setf bit-state-block-at): Private ordinary functions
Function, (setf bit-state-body): Private ordinary functions
Function, (setf bit-state-tags-info): Private ordinary functions
Function, (setf complex-node-children): Public ordinary functions
Function, (setf complex-node-task): Public ordinary functions
Function, (setf complex-tree-node-children): Public ordinary functions
Function, (setf complex-tree-node-dependencies): Private ordinary functions
Function, (setf complex-tree-node-expanded-task): Private ordinary functions
Function, (setf complex-tree-node-method-name): Public ordinary functions
Function, (setf complex-tree-node-parent): Private ordinary functions
Function, (setf complex-tree-node-task): Private ordinary functions
Function, (setf consumer): Public ordinary functions
Function, (setf doubly-hashed-state-block-at): Private ordinary functions
Function, (setf doubly-hashed-state-body): Private ordinary functions
Function, (setf doubly-hashed-state-tags-info): Private ordinary functions
Function, (setf establisher): Public ordinary functions
Function, (setf hash-state-block-at): Private ordinary functions
Function, (setf hash-state-body): Private ordinary functions
Function, (setf hash-state-tags-info): Private ordinary functions
Function, (setf list-state-block-at): Private ordinary functions
Function, (setf list-state-body): Private ordinary functions
Function, (setf list-state-tags-info): Private ordinary functions
Function, (setf mixed-state-block-at): Private ordinary functions
Function, (setf mixed-state-body): Private ordinary functions
Function, (setf mixed-state-tags-info): Private ordinary functions
Function, (setf operator-additions): Private ordinary functions
Function, (setf operator-cost-fun): Private ordinary functions
Function, (setf operator-deletions): Private ordinary functions
Function, (setf operator-head): Private ordinary functions
Function, (setf operator-preconditions): Private ordinary functions
Function, (setf ordered-tree-node-children): Private ordinary functions
Function, (setf ordered-tree-node-dependencies): Private ordinary functions
Function, (setf ordered-tree-node-expanded-task): Private ordinary functions
Function, (setf ordered-tree-node-method-name): Private ordinary functions
Function, (setf ordered-tree-node-parent): Private ordinary functions
Function, (setf ordered-tree-node-task): Private ordinary functions
Function, (setf pddl-action-cost-fun): Private ordinary functions
Function, (setf pddl-action-effect): Private ordinary functions
Function, (setf pddl-action-head): Private ordinary functions
Function, (setf pddl-action-precondition): Private ordinary functions
Function, (setf primitive-node-cost): Public ordinary functions
Function, (setf primitive-node-position): Public ordinary functions
Function, (setf primitive-node-task): Public ordinary functions
Function, (setf primitive-tree-node-dependencies): Private ordinary functions
Function, (setf primitive-tree-node-expanded-task): Private ordinary functions
Function, (setf primitive-tree-node-parent): Private ordinary functions
Function, (setf primitive-tree-node-task): Private ordinary functions
Function, (setf prop): Public ordinary functions
Function, (setf pseudo-node-children): Private ordinary functions
Function, (setf pseudo-node-dependencies): Private ordinary functions
Function, (setf pseudo-node-expanded-task): Private ordinary functions
Function, (setf pseudo-node-method-name): Private ordinary functions
Function, (setf pseudo-node-parent): Private ordinary functions
Function, (setf pseudo-node-task): Private ordinary functions
Function, (setf rd-est): Private ordinary functions
Function, (setf rd-prop): Private ordinary functions
Function, (setf replay-table-entry-alist): Private ordinary functions
Function, (setf replay-table-entry-singleton): Private ordinary functions
Function, (setf state-body): Private ordinary functions
Function, (setf state-update-action): Private ordinary functions
Function, (setf state-update-literal): Private ordinary functions
Function, (setf tagged-state-block-at): Private ordinary functions
Function, (setf tagged-state-body): Private ordinary functions
Function, (setf tagged-state-tags-info): Private ordinary functions
Function, (setf top-node-children): Private ordinary functions
Function, (setf top-node-dependencies): Private ordinary functions
Function, (setf top-node-expanded-task): Private ordinary functions
Function, (setf top-node-lookup-table): Private ordinary functions
Function, (setf top-node-method-name): Private ordinary functions
Function, (setf top-node-parent): Private ordinary functions
Function, (setf top-node-task): Private ordinary functions
Function, (setf tree-node-dependencies): Public ordinary functions
Function, (setf tree-node-expanded-task): Public ordinary functions
Function, (setf tree-node-parent): Public ordinary functions
Function, (setf tree-node-task): Public ordinary functions
Function, (setf unordered-tree-node-children): Private ordinary functions
Function, (setf unordered-tree-node-dependencies): Private ordinary functions
Function, (setf unordered-tree-node-expanded-task): Private ordinary functions
Function, (setf unordered-tree-node-method-name): Private ordinary functions
Function, (setf unordered-tree-node-parent): Private ordinary functions
Function, (setf unordered-tree-node-task): Private ordinary functions
Function, acceptable-cost-p: Private ordinary functions
Function, add-protection: Private ordinary functions
Function, add-source: Private ordinary functions
Function, all-elements-bindings: Private ordinary functions
Function, all-primitive-nodes: Public ordinary functions
Function, all-raw-depends-lists-p: Private ordinary functions
Function, all-raw-depends-p: Private ordinary functions
Function, all-roots: Private ordinary functions
Function, already-immediate-p: Private ordinary functions
Function, anonymous-var-p: Public ordinary functions
Function, anonymous-var-symbol-p: Private ordinary functions
Function, answer-set-union: Private ordinary functions
Function, apply-action: Private ordinary functions
Function, apply-method-bindings: Private ordinary functions
Function, apply-substitution-to-tree: Private ordinary functions
Function, axiom-sexp-p: Private ordinary functions
Function, backtrack: Private ordinary functions
Function, binding-list-value: Public ordinary functions
Function, binding-p: Private ordinary functions
Function, binding-val: Public ordinary functions
Function, binding-var: Public ordinary functions
Function, bit-state-block-at: Private ordinary functions
Function, bit-state-body: Private ordinary functions
Function, bit-state-p: Private ordinary functions
Function, bit-state-tags-info: Private ordinary functions
Function, bit-statebody-increment-position: Private ordinary functions
Function, bit-statebody-search-array: Private ordinary functions
Function, canonically-order: Private ordinary functions
Function, check-constraints: Private ordinary functions
Function, check-for-singletons: Private ordinary functions
Function, choose-immediate-task: Private ordinary functions
Function, choose-immediate-task-state: Private ordinary functions
Function, choose-method-bindings-state: Private ordinary functions
Function, choose-method-state: Private ordinary functions
Function, choose-toplevel-task: Private ordinary functions
Function, clobbered-p: Private ordinary functions
Function, complex-node-children: Public ordinary functions
Function, complex-node-p: Public ordinary functions
Function, complex-node-task: Public ordinary functions
Function, complex-tree-node-children: Public ordinary functions
Function, complex-tree-node-dependencies: Private ordinary functions
Function, complex-tree-node-expanded-task: Private ordinary functions
Function, complex-tree-node-method-name: Public ordinary functions
Function, complex-tree-node-p: Private ordinary functions
Function, complex-tree-node-parent: Private ordinary functions
Function, complex-tree-node-task: Private ordinary functions
Function, compose-substitutions: Public ordinary functions
Function, compute-fluent-updates: Private ordinary functions
Function, consumer: Public ordinary functions
Function, copy-binding: Private ordinary functions
Function, copy-complex-node: Private ordinary functions
Function, copy-complex-tree-node: Private ordinary functions
Function, copy-dependency: Private ordinary functions
Function, copy-hash-table: Private ordinary functions
Function, copy-operator: Private ordinary functions
Function, copy-ordered-tree-node: Private ordinary functions
Function, copy-pddl-action: Private ordinary functions
Function, copy-plan-tree: Public ordinary functions
Function, copy-plan-tree: Public ordinary functions
Function, copy-primitive-node: Private ordinary functions
Function, copy-primitive-tree-node: Private ordinary functions
Function, copy-pseudo-node: Private ordinary functions
Function, copy-raw-depend: Private ordinary functions
Function, copy-replay-table-entry: Private ordinary functions
Function, copy-state-update: Private ordinary functions
Function, copy-task-tree: Private ordinary functions
Function, copy-top-node: Private ordinary functions
Function, copy-tree-node: Private ordinary functions
Function, copy-unordered-tree-node: Private ordinary functions
Function, count-method-branches: Private ordinary functions
Function, create-node-children-table: Private ordinary functions
Function, decode-tag: Public ordinary functions
Function, decode-task: Private ordinary functions
Function, delete-protection: Private ordinary functions
Function, delete-protections: Private ordinary functions
Function, delete-state-tag-decoder: Public ordinary functions
Function, delete-tag-map: Public ordinary functions
Function, delete-task-main-list: Private ordinary functions
Function, delete-task-top-list: Private ordinary functions
Function, dependency-for-negation: Private ordinary functions
Function, dependency-p: Private ordinary functions
Function, determine-verbosity: Private ordinary functions
Function, divergence-list-p: Private ordinary functions
Function, divergence-op-p: Private ordinary functions
Function, do-conjunct: Private ordinary functions
Function, do-conjunct-from-atoms: Private ordinary functions
Function, do-conjunct-from-axiom: Private ordinary functions
Function, do-conjunct-from-axioms: Private ordinary functions
Function, do-problems: Public ordinary functions
Function, domain-include-search: Private ordinary functions
Function, doubly-hashed-state-block-at: Private ordinary functions
Function, doubly-hashed-state-body: Private ordinary functions
Function, doubly-hashed-state-p: Private ordinary functions
Function, doubly-hashed-state-tags-info: Private ordinary functions
Function, dummy-external-access-hook: Private ordinary functions
Function, dump-higher-cost-plans!: Private ordinary functions
Function, dump-previous-plans!: Private ordinary functions
Function, empty-p: Private ordinary functions
Function, establisher: Public ordinary functions
Function, expand-include: Private ordinary functions
Function, expand-includes: Private ordinary functions
Function, explain-satisfier: Public ordinary functions
Function, extend-plan-tree-nodes: Private ordinary functions
Function, external-find-satisfiers: Private ordinary functions
Function, external-query: Private ordinary functions
Function, extract-adds-and-deletes: Private ordinary functions
Function, extract-method-id: Private ordinary functions
Function, extract-subtasks: Private ordinary functions
Function, extract-subtree: Private ordinary functions
Function, extract-suffix: Private ordinary functions
Function, extract-tree: Private ordinary functions
Function, extract-trees: Private ordinary functions
Function, extract-variables: Public ordinary functions
Function, filter-singletons: Private ordinary functions
Function, find-adder: Private ordinary functions
Function, find-all-complex-node-for-task: Public ordinary functions
Function, find-all-complex-node-if: Public ordinary functions
Function, find-all-primitive-nodes-if: Public ordinary functions
Function, find-binding: Private ordinary functions
Function, find-checking-path: Private ordinary functions
Function, find-complex-node-for-task: Public ordinary functions
Function, find-complex-node-if: Public ordinary functions
Function, find-deleter: Private ordinary functions
Function, find-domain: Public ordinary functions
Function, find-next-main-list: Private ordinary functions
Function, find-plan-step: Public ordinary functions
Function, find-plan-suffix: Private ordinary functions
Function, find-plans: Public ordinary functions
Function, find-plans-1: Private ordinary functions
Function, find-plans-stack: Public ordinary functions
Function, find-primitive-node-for-task: Public ordinary functions
Function, find-primitive-node-if: Public ordinary functions
Function, find-problem: Public ordinary functions
Function, find-satisfiers: Public ordinary functions
Function, find-task-in-tree: Public ordinary functions
Function, find-tree-node-if: Public ordinary functions
Function, find-variable: Private ordinary functions
Function, first-word-equal: Private ordinary functions
Function, fix-uninterned-bindings: Public ordinary functions
Function, force-immediate: Private ordinary functions
Function, force-immediate-reduction: Private ordinary functions
Function, force-immediate-unordered: Private ordinary functions
Function, freeze-state: Private ordinary functions
Function, fully-instantiated-goal: Private ordinary functions
Function, generate-reductions: Private ordinary functions
Function, get-alist: Public ordinary functions
Function, get-attribution: Private ordinary functions
Function, get-immediate-list: Private ordinary functions
Function, get-method-name: Private ordinary functions
Function, get-problems: Public ordinary functions
Function, get-task-body: Private ordinary functions
Function, get-task-name: Private ordinary functions
Function, get-top-tasks: Private ordinary functions
Function, goal-equalp: Private ordinary functions
Function, groundp: Public ordinary functions
Function, harvest-variables: Private ordinary functions
Function, hash-state-block-at: Private ordinary functions
Function, hash-state-body: Private ordinary functions
Function, hash-state-p: Private ordinary functions
Function, hash-state-tags-info: Private ordinary functions
Function, id-search: Private ordinary functions
Function, immediate-tasks: Private ordinary functions
Function, incorporate-unifiers: Private ordinary functions
Function, indented-format: Private ordinary functions
Function, index-method-on-domain: Private ordinary functions
Function, insert-if-necessary: Private ordinary functions
Function, internal-operator-p: Public ordinary functions
Function, invoke-external-query: Private ordinary functions
Function, leftmost-p: Private ordinary functions
Function, list-insert-atom-into-statebody: Private ordinary functions
Function, list-remove-atom-from-statebody: Private ordinary functions
Function, list-state-block-at: Private ordinary functions
Function, list-state-body: Private ordinary functions
Function, list-state-p: Private ordinary functions
Function, list-state-tags-info: Private ordinary functions
Function, loop-body-item: Private ordinary functions
Function, loop-body-item-inner: Private ordinary functions
Function, loop-item: Private ordinary functions
Function, looping-p: Private ordinary functions
Function, make-add-child-to-tree: Private ordinary functions
Function, make-add-dependencies: Private ordinary functions
Function, make-binding: Public ordinary functions
Function, make-binding-list: Public ordinary functions
Function, make-bit-state: Private ordinary functions
Function, make-complex-node: Public ordinary functions
Function, make-complex-tree-node: Public ordinary functions
Function, make-cross-links: Private ordinary functions
Function, make-cs-state: Private ordinary functions
Function, make-dependencies: Private ordinary functions
Function, make-dependency: Public ordinary functions
Function, make-domain: Private ordinary functions
Function, make-doubly-hashed-state: Private ordinary functions
Function, make-hash-state: Private ordinary functions
Function, make-list-state: Private ordinary functions
Function, make-loop-state-expand: Private ordinary functions
Function, make-method-instantiation: Private ordinary functions
Function, make-mixed-state: Private ordinary functions
Function, make-operator: Private ordinary functions
Function, make-operator-task-table: Private ordinary functions
Function, make-ordered-tree-node: Public ordinary functions
Function, make-pddl-action: Private ordinary functions
Function, make-plan-copy: Private ordinary functions
Function, make-plan-tree-for-task-net: Private ordinary functions
Function, make-prim-state-expand: Private ordinary functions
Function, make-primitive-node: Private ordinary functions
Function, make-primitive-tree-node: Public ordinary functions
Function, make-problem: Public ordinary functions
Function, make-problem-set: Public ordinary functions
Function, make-pseudo-node: Private ordinary functions
Function, make-raw-depend: Private ordinary functions
Function, make-record-expansion: Private ordinary functions
Function, make-record-expansion-for-replay: Private ordinary functions
Function, make-replay-table-entry: Private ordinary functions
Function, make-state-update: Private ordinary functions
Function, make-subtask-parents-table: Private ordinary functions
Function, make-tag-map: Public ordinary functions
Function, make-top-node: Public ordinary functions
Function, make-tree-node: Private ordinary functions
Function, make-unordered-tree-node: Public ordinary functions
Function, make-world-state-tag: Private ordinary functions
Function, makedoubly-hashedstate: Private ordinary functions
Function, makehashstate: Private ordinary functions
Function, makeliststate: Private ordinary functions
Function, makemixedstate: Private ordinary functions
Function, merge-binding-set-lists: Private ordinary functions
Function, merge-binding-sets: Private ordinary functions
Function, method-printer: Private ordinary functions
Function, method-sexp-p: Private ordinary functions
Function, min-start: Private ordinary functions
Function, mixed-state-block-at: Private ordinary functions
Function, mixed-state-body: Private ordinary functions
Function, mixed-state-p: Private ordinary functions
Function, mixed-state-tags-info: Private ordinary functions
Function, new-symbol: Private ordinary functions
Function, node-children: Private ordinary functions
Function, node-parent: Public ordinary functions
Function, nshuffle-array: Private ordinary functions
Function, nshuffle-list: Private ordinary functions
Function, obj-bindings: Private ordinary functions
Function, occurs: Private ordinary functions
Function, of-type-exprs: Private ordinary functions
Function, op-sexp-p: Private ordinary functions
Function, operator-additions: Private ordinary functions
Function, operator-cost-fun: Private ordinary functions
Function, operator-deletions: Private ordinary functions
Function, operator-head: Private ordinary functions
Function, operator-name: Private ordinary functions
Function, operator-p: Private ordinary functions
Function, operator-preconditions: Private ordinary functions
Function, operator-printer: Private ordinary functions
Function, operator-sexp-p: Private ordinary functions
Function, operator-task: Private ordinary functions
Function, optimize-continue-p: Private ordinary functions
Function, ordered-tree-node-children: Private ordinary functions
Function, ordered-tree-node-dependencies: Private ordinary functions
Function, ordered-tree-node-expanded-task: Private ordinary functions
Function, ordered-tree-node-method-name: Private ordinary functions
Function, ordered-tree-node-p: Private ordinary functions
Function, ordered-tree-node-parent: Private ordinary functions
Function, ordered-tree-node-task: Private ordinary functions
Function, parse-pddl-method: Private ordinary functions
Function, parse-typed-list: Private ordinary functions
Function, pddl-action-cost-fun: Private ordinary functions
Function, pddl-action-effect: Private ordinary functions
Function, pddl-action-head: Private ordinary functions
Function, pddl-action-name: Private ordinary functions
Function, pddl-action-p: Private ordinary functions
Function, pddl-action-precondition: Private ordinary functions
Function, pddl-satisfiers-for-exists: Private ordinary functions
Function, pddl-satisfiers-for-f-exp: Private ordinary functions
Function, pddl-satisfiers-for-forall: Private ordinary functions
Function, pddl-satisfiers-for-imply: Private ordinary functions
Function, pddl-satisfiers-for-not: Private ordinary functions
Function, phase-one: Private ordinary functions
Function, plan-final-state: Public ordinary functions
Function, plan-operator-nodes: Private ordinary functions
Function, plan-returns: Private ordinary functions
Function, plan-states: Public ordinary functions
Function, plan-tree-nodes: Private ordinary functions
Function, populate-plan-return: Private ordinary functions
Function, pprint-plan: Public ordinary functions
Function, pprint-preconds: Private ordinary functions
Function, pprint-step: Private ordinary functions
Function, pprint-task-net: Private ordinary functions
Function, prepare-choose-immediate-task-state: Private ordinary functions
Function, prepare-return-values: Public ordinary functions
Function, prepare-state-tag-decoder: Public ordinary functions
Function, primitive-node-cost: Public ordinary functions
Function, primitive-node-p: Public ordinary functions
Function, primitive-node-position: Public ordinary functions
Function, primitive-node-task: Public ordinary functions
Function, primitive-symbol-p: Private ordinary functions
Function, primitive-tree-node-dependencies: Private ordinary functions
Function, primitive-tree-node-expanded-task: Private ordinary functions
Function, primitive-tree-node-p: Private ordinary functions
Function, primitive-tree-node-parent: Private ordinary functions
Function, primitive-tree-node-task: Private ordinary functions
Function, primitivep: Private ordinary functions
Function, print-axioms: Public ordinary functions
Function, print-belief-state-readably: Public ordinary functions
Function, print-current-plan: Private ordinary functions
Function, print-current-state: Public ordinary functions
Function, print-current-tasks: Private ordinary functions
Function, print-list-on-lines: Private ordinary functions
Function, print-list-suffix-lines: Private ordinary functions
Function, print-methods: Public ordinary functions
Function, print-operator: Private ordinary functions
Function, print-operators: Public ordinary functions
Function, print-output-file: Private ordinary functions
Function, print-stats: Private ordinary functions
Function, print-stats-header: Private ordinary functions
Function, print1: Private ordinary functions
Function, process-add-list: Private ordinary functions
Function, process-axiom: Public ordinary functions
Function, process-delete-list: Private ordinary functions
Function, process-pddl-method-pre: Private ordinary functions
Function, process-task-list: Private ordinary functions
Function, prop: Public ordinary functions
Function, prop-sorter: Public ordinary functions
Function, protection-ok: Private ordinary functions
Function, pseudo-node-children: Private ordinary functions
Function, pseudo-node-dependencies: Private ordinary functions
Function, pseudo-node-expanded-task: Private ordinary functions
Function, pseudo-node-method-name: Private ordinary functions
Function, pseudo-node-p: Private ordinary functions
Function, pseudo-node-parent: Private ordinary functions
Function, pseudo-node-task: Private ordinary functions
Function, pull-tag-info: Private ordinary functions
Function, query-current-state: Private ordinary functions
Function, quotify: Private ordinary functions
Function, randomize-list: Private ordinary functions
Function, raw-depend-p: Private ordinary functions
Function, rd-est: Private ordinary functions
Function, rd-prop: Private ordinary functions
Function, rd-union: Private ordinary functions
Function, real-apply-substitution: Private ordinary functions
Function, real-seek-satisfiers: Private ordinary functions
Function, record-node-expansion: Private ordinary functions
Function, record-operator: Private ordinary functions
Function, record-reduction: Private ordinary functions
Function, remove-costs: Public ordinary functions
Function, remove-internal-operators: Public ordinary functions
Function, remove-subtree-from-table: Private ordinary functions
Function, rename-sym: Private ordinary functions
Function, repair-plan: Public ordinary functions
Function, replace-task-main-list: Private ordinary functions
Function, replace-task-top-list: Private ordinary functions
Function, replan-from-failure: Private ordinary functions
Function, replay-table-entry-alist: Private ordinary functions
Function, replay-table-entry-p: Private ordinary functions
Function, replay-table-entry-singleton: Private ordinary functions
Function, report-no-method: Private ordinary functions
Function, report-task-arity-mismatch: Private ordinary functions
Function, rest-shop2-axiom-p: Private ordinary functions
Function, resymbol-task: Private ordinary functions
Function, search-tree: Private ordinary functions
Function, seek-plans-primitive-1: Private ordinary functions
Function, seek-plans-stack: Private ordinary functions
Function, set-domain: Public ordinary functions
Function, setof-bagof-helper: Private ordinary functions
Function, shop-trace-1: Private ordinary functions
Function, shop-trace-info: Public ordinary functions
Function, shop-union: Public ordinary functions
Function, shop-untrace-1: Private ordinary functions
Function, shop-untrace-all: Private ordinary functions
Function, shop2-axiom-p: Private ordinary functions
Function, shorter-plan: Public ordinary functions
Function, slot-value-translator: Private ordinary functions
Function, stack-backjump: Private ordinary functions
Function, stack-backtrack: Private ordinary functions
Function, standard-satisfiers-for-and: Private ordinary functions
Function, standard-satisfiers-for-assign: Private ordinary functions
Function, standard-satisfiers-for-assign*: Private ordinary functions
Function, standard-satisfiers-for-bagof: Private ordinary functions
Function, standard-satisfiers-for-call: Private ordinary functions
Function, standard-satisfiers-for-enforce: Private ordinary functions
Function, standard-satisfiers-for-eval: Private ordinary functions
Function, standard-satisfiers-for-exists: Private ordinary functions
Function, standard-satisfiers-for-external: Private ordinary functions
Function, standard-satisfiers-for-forall: Private ordinary functions
Function, standard-satisfiers-for-imply: Private ordinary functions
Function, standard-satisfiers-for-not: Private ordinary functions
Function, standard-satisfiers-for-or: Private ordinary functions
Function, standard-satisfiers-for-setof: Private ordinary functions
Function, standardize: Public ordinary functions
Function, state-body: Private ordinary functions
Function, state-p: Private ordinary functions
Function, state-update-action: Private ordinary functions
Function, state-update-literal: Private ordinary functions
Function, state-update-p: Private ordinary functions
Function, static-bounds-p: Private ordinary functions
Function, strip-nops: Private ordinary functions
Function, strip-task-sexp: Private ordinary functions
Function, strip-tree-tags: Private ordinary functions
Function, tag-for-action: Public ordinary functions
Function, tagged-state-block-at: Private ordinary functions
Function, tagged-state-body: Private ordinary functions
Function, tagged-state-p: Private ordinary functions
Function, tagged-state-tags-info: Private ordinary functions
Function, tagged-state-tags-info-tag: Private ordinary functions
Function, task-args: Private ordinary functions
Function, task-name: Public ordinary functions
Function, test-plan-found: Private ordinary functions
Function, time-expired-p: Private ordinary functions
Function, to-string: Private ordinary functions
Function, top-node-children: Private ordinary functions
Function, top-node-dependencies: Private ordinary functions
Function, top-node-expanded-task: Private ordinary functions
Function, top-node-lookup-table: Private ordinary functions
Function, top-node-method-name: Private ordinary functions
Function, top-node-p: Private ordinary functions
Function, top-node-parent: Private ordinary functions
Function, top-node-task: Private ordinary functions
Function, translate-child-links: Private ordinary functions
Function, translate-dependency-links: Private ordinary functions
Function, translate-fluent-precond: Private ordinary functions
Function, translate-include: Private ordinary functions
Function, translate-lookup-table: Private ordinary functions
Function, translate-metric-updates: Private ordinary functions
Function, translate-pddl-quantifier: Private ordinary functions
Function, tree-compare: Private ordinary functions
Function, tree-node-dependencies: Public ordinary functions
Function, tree-node-expanded-task: Public ordinary functions
Function, tree-node-p: Private ordinary functions
Function, tree-node-parent: Public ordinary functions
Function, tree-node-task: Public ordinary functions
Function, tree-node-task: Public ordinary functions
Function, tree-node-task-name: Public ordinary functions
Function, typed-list-vars: Private ordinary functions
Function, unify: Public ordinary functions
Function, unify1: Private ordinary functions
Function, uniquify-anonymous-variables: Public ordinary functions
Function, unordered-tree-node-children: Private ordinary functions
Function, unordered-tree-node-dependencies: Private ordinary functions
Function, unordered-tree-node-expanded-task: Private ordinary functions
Function, unordered-tree-node-method-name: Private ordinary functions
Function, unordered-tree-node-p: Private ordinary functions
Function, unordered-tree-node-parent: Private ordinary functions
Function, unordered-tree-node-task: Private ordinary functions
Function, user-choose-task: Private ordinary functions
Function, validate-plan: Public ordinary functions
Function, variable-gensym: Public ordinary functions
Function, variable-name: Private ordinary functions
Function, variable-symbol-p: Private ordinary functions
Function, variablep: Public ordinary functions
Function, vars-boundp: Private ordinary functions
Function, well-formed-listp: Private ordinary functions
Function, write-pddl-plan: Public ordinary functions

G
generate-reductions: Private ordinary functions
Generic Function, %delete-a-decomposition: Private generic functions
Generic Function, %record-a-decomposition: Private generic functions
Generic Function, %update-singleton: Private generic functions
Generic Function, (setf alternatives): Private generic functions
Generic Function, (setf backtrack-stack): Private generic functions
Generic Function, (setf cost): Private generic functions
Generic Function, (setf current-task): Private generic functions
Generic Function, (setf depth): Private generic functions
Generic Function, (setf mode): Private generic functions
Generic Function, (setf partial-plan): Private generic functions
Generic Function, (setf pddl-types): Private generic functions
Generic Function, (setf plans-found): Private generic functions
Generic Function, (setf protections): Private generic functions
Generic Function, (setf state): Public generic functions
Generic Function, (setf tasks): Private generic functions
Generic Function, (setf top-tasks): Private generic functions
Generic Function, (setf unifier): Private generic functions
Generic Function, (setf world-state): Private generic functions
Generic Function, add-atom-to-state: Public generic functions
Generic Function, alternatives: Private generic functions
Generic Function, apply-method: Private generic functions
Generic Function, apply-operator: Public generic functions
Generic Function, argno: Private generic functions
Generic Function, assign-domain-method-id: Private generic functions
Generic Function, atom-in-state-p: Private generic functions
Generic Function, axioms: Public generic functions
Generic Function, backtrack-stack: Private generic functions
Generic Function, branch-number: Private generic functions
Generic Function, child: Private generic functions
Generic Function, clear-replay-table: Private generic functions
Generic Function, comment: Private generic functions
Generic Function, construct: Private generic functions
Generic Function, construct-name: Private generic functions
Generic Function, construct-type: Private generic functions
Generic Function, copy-plan-tree-node: Private generic functions
Generic Function, copy-shop-problem: Public generic functions
Generic Function, copy-state: Public generic functions
Generic Function, correct-arity: Private generic functions
Generic Function, cost: Private generic functions
Generic Function, cross-links-for: Private generic functions
Generic Function, current-task: Private generic functions
Generic Function, default-state-type: Public generic functions
Generic Function, delete-atom-from-state: Public generic functions
Generic Function, delete-domain: Public generic functions
Generic Function, delete-problem: Public generic functions
Generic Function, dependencies: Private generic functions
Generic Function, depth: Private generic functions
Generic Function, do-backtrack: Private generic functions
Generic Function, domain-axioms: Public generic functions
Generic Function, domain-id-for-method-lookup: Private generic functions
Generic Function, domain-include-parse: Private generic functions
Generic Function, domain-items: Private generic functions
Generic Function, domain-method-id-lookup: Private generic functions
Generic Function, domain-method-to-name-table: Private generic functions
Generic Function, domain-methods: Public generic functions
Generic Function, domain-name: Public generic functions
Generic Function, domain-name-to-method-table: Private generic functions
Generic Function, domain-operators: Public generic functions
Generic Function, expand-loop: Private generic functions
Generic Function, expand-loop-body: Private generic functions
Generic Function, expand-primitive-state: Private generic functions
Generic Function, expression: Private generic functions
Generic Function, find-decompositions: Private generic functions
Generic Function, find-failed-choice-entry: Private generic functions
Generic Function, find-failed-stack-entry: Private generic functions
Generic Function, find-failed-task: Public generic functions
Generic Function, fluent-comparison-p: Private generic functions
Generic Function, fluent-expr-p: Private generic functions
Generic Function, fluent-function-p: Private generic functions
Generic Function, fluent-functions: Private generic functions
Generic Function, get-state: Public generic functions
Generic Function, get-tasks: Public generic functions
Generic Function, guidance: Private generic functions
Generic Function, handle-domain-options: Public generic functions
Generic Function, has-static-preds-p: Public generic functions
Generic Function, include-in-tag: Private generic functions
Generic Function, initialize-problem: Private generic functions
Generic Function, insert-atom: Private generic functions
Generic Function, install-domain: Private generic functions
Generic Function, last-establisher: Public generic functions
Generic Function, logical-keywordp: Private generic functions
Generic Function, logical-op: Private generic functions
Generic Function, lookup-table: Private generic functions
Generic Function, make-initial-state: Public generic functions
Generic Function, make-instantiator: Private generic functions
Generic Function, make-plan-return: Private generic functions
Generic Function, make-table-entries: Private generic functions
Generic Function, method-definition-keywords: Private generic functions
Generic Function, method-expression-body: Private generic functions
Generic Function, method-expression-task: Private generic functions
Generic Function, method-head: Private generic functions
Generic Function, method-id: Private generic functions
Generic Function, method-name: Private generic functions
Generic Function, method-p: Private generic functions
Generic Function, method-preconditions: Private generic functions
Generic Function, method-task: Private generic functions
Generic Function, method-task-net: Private generic functions
Generic Function, methods: Public generic functions
Generic Function, mode: Private generic functions
Generic Function, name: Public generic functions
Generic Function, old-name: Private generic functions
Generic Function, op: Private generic functions
Generic Function, operator: Private generic functions
Generic Function, operators-dont-fail: Private generic functions
Generic Function, parent: Private generic functions
Generic Function, parse-domain-item: Private generic functions
Generic Function, parse-domain-items: Public generic functions
Generic Function, partial-plan: Private generic functions
Generic Function, partial-plan-cost: Private generic functions
Generic Function, pddl-method-p: Private generic functions
Generic Function, pddl-plan: Private generic functions
Generic Function, pddl-types: Private generic functions
Generic Function, plan: Private generic functions
Generic Function, plan-cost: Private generic functions
Generic Function, plan-tree: Private generic functions
Generic Function, plan-tree->sexp: Public generic functions
Generic Function, plan-tree-lookup: Private generic functions
Generic Function, plans-found: Private generic functions
Generic Function, predicate: Private generic functions
Generic Function, problem->state: Private generic functions
Generic Function, problem-name: Public generic functions
Generic Function, problem-state: Private generic functions
Generic Function, problem-tasks: Private generic functions
Generic Function, process-action: Private generic functions
Generic Function, process-add-or-delete: Private generic functions
Generic Function, process-method: Public generic functions
Generic Function, process-method-pre: Private generic functions
Generic Function, process-op: Public generic functions
Generic Function, process-operator: Public generic functions
Generic Function, process-pre: Private generic functions
Generic Function, protections: Private generic functions
Generic Function, query: Public generic functions
Generic Function, real-seek-satisfiers-for: Private generic functions
Generic Function, record-decomposition: Private generic functions
Generic Function, redo-state-update: Private generic functions
Generic Function, regularize-axiom: Private generic functions
Generic Function, remove-atom: Private generic functions
Generic Function, replay-state-changes: Public generic functions
Generic Function, replay-table: Private generic functions
Generic Function, retract-state-changes: Public generic functions
Generic Function, search-state: Private generic functions
Generic Function, seek-plans: Private generic functions
Generic Function, seek-plans-loop: Private generic functions
Generic Function, seek-plans-nonprimitive: Private generic functions
Generic Function, seek-plans-null: Public generic functions
Generic Function, seek-plans-primitive: Public generic functions
Generic Function, seek-plans-task: Private generic functions
Generic Function, set-variable-property: Public generic functions
Generic Function, slot-fillers: Private generic functions
Generic Function, sort-methods: Public generic functions
Generic Function, sort-results: Public generic functions
Generic Function, sort-tasks: Public generic functions
Generic Function, source-pddl-domain: Public generic functions
Generic Function, state: Public generic functions
Generic Function, state->state-type: Public generic functions
Generic Function, state-all-atoms-for-predicate: Public generic functions
Generic Function, state-atoms: Public generic functions
Generic Function, state-candidate-atoms-for-goal: Public generic functions
Generic Function, state-trajectory: Public generic functions
Generic Function, static-preds: Public generic functions
Generic Function, store-plan!: Private generic functions
Generic Function, tag: Private generic functions
Generic Function, tag-state: Public generic functions
Generic Function, task: Private generic functions
Generic Function, task-arity-mismatch-library-entry: Private generic functions
Generic Function, task-arity-mismatch-library-task: Private generic functions
Generic Function, task-arity-mismatch-task: Private generic functions
Generic Function, task-sorter: Public generic functions
Generic Function, tasks: Private generic functions
Generic Function, top-tasks: Private generic functions
Generic Function, translate-effect: Private generic functions
Generic Function, translate-precondition: Private generic functions
Generic Function, tree: Private generic functions
Generic Function, tree-node: Private generic functions
Generic Function, trigger-trace: Public generic functions
Generic Function, undo-state-update: Private generic functions
Generic Function, unfold-loop-task: Private generic functions
Generic Function, unifier: Private generic functions
Generic Function, validator-export: Public generic functions
Generic Function, var: Private generic functions
Generic Function, variable-names: Private generic functions
Generic Function, world-state: Private generic functions
get-alist: Public ordinary functions
get-attribution: Private ordinary functions
get-immediate-list: Private ordinary functions
get-method-name: Private ordinary functions
get-problems: Public ordinary functions
get-state: Public generic functions
get-state: Public generic functions
get-state: Public generic functions
get-task-body: Private ordinary functions
get-task-name: Private ordinary functions
get-tasks: Public generic functions
get-tasks: Public generic functions
get-tasks: Public generic functions
get-top-tasks: Private ordinary functions
goal-equalp: Private ordinary functions
groundp: Public ordinary functions
guidance: Private generic functions
guidance: Private generic functions
guidance: Private generic functions

H
handle-domain-options: Public generic functions
handle-domain-options: Public generic functions
harvest-variables: Private ordinary functions
has-static-preds-p: Public generic functions
has-static-preds-p: Public generic functions
has-static-preds-p: Public generic functions
hash-state-block-at: Private ordinary functions
hash-state-body: Private ordinary functions
hash-state-p: Private ordinary functions
hash-state-tags-info: Private ordinary functions

I
id-search: Private ordinary functions
immediate-tasks: Private ordinary functions
include-in-tag: Private generic functions
include-in-tag: Private generic functions
incorporate-unifiers: Private ordinary functions
indented-format: Private ordinary functions
index-method-on-domain: Private ordinary functions
initialize-problem: Private generic functions
initialize-problem: Private generic functions
insert-atom: Private generic functions
insert-atom: Private generic functions
insert-atom: Private generic functions
insert-atom: Private generic functions
insert-atom: Private generic functions
insert-atom: Private generic functions
insert-if-necessary: Private ordinary functions
install-domain: Private generic functions
install-domain: Private generic functions
internal-operator-p: Public ordinary functions
invoke-external-query: Private ordinary functions

L
last-establisher: Public generic functions
last-establisher: Public generic functions
leftmost-p: Private ordinary functions
list-insert-atom-into-statebody: Private ordinary functions
list-remove-atom-from-statebody: Private ordinary functions
list-state-block-at: Private ordinary functions
list-state-body: Private ordinary functions
list-state-p: Private ordinary functions
list-state-tags-info: Private ordinary functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-keywordp: Private generic functions
logical-op: Private generic functions
logical-op: Private generic functions
lookup-table: Private generic functions
lookup-table: Private generic functions
loop-body-item: Private ordinary functions
loop-body-item-inner: Private ordinary functions
loop-item: Private ordinary functions
looping-p: Private ordinary functions

M
Macro, appendf: Private macros
Macro, apply-substitution: Public macros
Macro, call: Public macros
Macro, catch-internal-time: Private macros
Macro, def-logical-keyword: Public macros
Macro, def-problem-set: Public macros
Macro, defconstant: Private macros
Macro, defdomain: Public macros
Macro, defproblem: Public macros
Macro, print-unreadably: Private macros
Macro, push-last: Private macros
Macro, seek-satisfiers: Private macros
Macro, shop-fail: Public macros
Macro, shop-trace: Public macros
Macro, shop-untrace: Public macros
Macro, simple-backquote: Private macros
Macro, stack-constructor: Private macros
Macro, trace-print: Public macros
Macro, unify-fail: Public macros
Macro, unify-fail-p: Public macros
Macro, unify-p: Public macros
Macro, variable-p: Public macros
Macro, verbose-format: Private macros
Macro, when-done: Private macros
Macro, with-method-name-table: Private macros
make-add-child-to-tree: Private ordinary functions
make-add-dependencies: Private ordinary functions
make-binding: Public ordinary functions
make-binding-list: Public ordinary functions
make-bit-state: Private ordinary functions
make-complex-node: Public ordinary functions
make-complex-tree-node: Public ordinary functions
make-cross-links: Private ordinary functions
make-cs-state: Private ordinary functions
make-dependencies: Private ordinary functions
make-dependency: Public ordinary functions
make-domain: Private ordinary functions
make-doubly-hashed-state: Private ordinary functions
make-hash-state: Private ordinary functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-initial-state: Public generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-instantiator: Private generic functions
make-list-state: Private ordinary functions
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-load-form: Public standalone methods
make-loop-state-expand: Private ordinary functions
make-method-instantiation: Private ordinary functions
make-mixed-state: Private ordinary functions
make-operator: Private ordinary functions
make-operator-task-table: Private ordinary functions
make-ordered-tree-node: Public ordinary functions
make-pddl-action: Private ordinary functions
make-plan-copy: Private ordinary functions
make-plan-return: Private generic functions
make-plan-return: Private generic functions
make-plan-return: Private generic functions
make-plan-tree-for-task-net: Private ordinary functions
make-prim-state-expand: Private ordinary functions
make-primitive-node: Private ordinary functions
make-primitive-tree-node: Public ordinary functions
make-problem: Public ordinary functions
make-problem-set: Public ordinary functions
make-pseudo-node: Private ordinary functions
make-raw-depend: Private ordinary functions
make-record-expansion: Private ordinary functions
make-record-expansion-for-replay: Private ordinary functions
make-replay-table-entry: Private ordinary functions
make-state-update: Private ordinary functions
make-subtask-parents-table: Private ordinary functions
make-table-entries: Private generic functions
make-table-entries: Private generic functions
make-table-entries: Private generic functions
make-table-entries: Private generic functions
make-tag-map: Public ordinary functions
make-top-node: Public ordinary functions
make-tree-node: Private ordinary functions
make-unordered-tree-node: Public ordinary functions
make-world-state-tag: Private ordinary functions
makedoubly-hashedstate: Private ordinary functions
makehashstate: Private ordinary functions
makeliststate: Private ordinary functions
makemixedstate: Private ordinary functions
merge-binding-set-lists: Private ordinary functions
merge-binding-sets: Private ordinary functions
Method, %delete-a-decomposition: Private generic functions
Method, %record-a-decomposition: Private generic functions
Method, %update-singleton: Private generic functions
Method, (setf alternatives): Private generic functions
Method, (setf backtrack-stack): Private generic functions
Method, (setf cost): Private generic functions
Method, (setf current-task): Private generic functions
Method, (setf depth): Private generic functions
Method, (setf mode): Private generic functions
Method, (setf partial-plan): Private generic functions
Method, (setf pddl-types): Private generic functions
Method, (setf plans-found): Private generic functions
Method, (setf protections): Private generic functions
Method, (setf state): Public generic functions
Method, (setf tasks): Private generic functions
Method, (setf top-tasks): Private generic functions
Method, (setf unifier): Private generic functions
Method, (setf world-state): Private generic functions
Method, add-atom-to-state: Public generic functions
Method, alternatives: Private generic functions
Method, alternatives: Private generic functions
Method, apply-method: Private generic functions
Method, apply-operator: Public generic functions
Method, argno: Private generic functions
Method, argno: Private generic functions
Method, assign-domain-method-id: Private generic functions
Method, atom-in-state-p: Private generic functions
Method, atom-in-state-p: Private generic functions
Method, atom-in-state-p: Private generic functions
Method, atom-in-state-p: Private generic functions
Method, atom-in-state-p: Private generic functions
Method, axioms: Public generic functions
Method, axioms: Public generic functions
Method, backtrack-stack: Private generic functions
Method, branch-number: Private generic functions
Method, child: Private generic functions
Method, clear-replay-table: Private generic functions
Method, clear-replay-table: Private generic functions
Method, comment: Private generic functions
Method, construct: Private generic functions
Method, construct-name: Private generic functions
Method, construct-type: Private generic functions
Method, copy-plan-tree-node: Private generic functions
Method, copy-plan-tree-node: Private generic functions
Method, copy-plan-tree-node: Private generic functions
Method, copy-plan-tree-node: Private generic functions
Method, copy-plan-tree-node: Private generic functions
Method, copy-shop-problem: Public generic functions
Method, copy-state: Public generic functions
Method, copy-state: Public generic functions
Method, copy-state: Public generic functions
Method, copy-state: Public generic functions
Method, copy-state: Public generic functions
Method, correct-arity: Private generic functions
Method, cost: Private generic functions
Method, cross-links-for: Private generic functions
Method, cross-links-for: Private generic functions
Method, cross-links-for: Private generic functions
Method, current-task: Private generic functions
Method, current-task: Private generic functions
Method, default-state-type: Public generic functions
Method, delete-atom-from-state: Public generic functions
Method, delete-domain: Public generic functions
Method, delete-domain: Public generic functions
Method, delete-problem: Public generic functions
Method, delete-problem: Public generic functions
Method, dependencies: Private generic functions
Method, depth: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, do-backtrack: Private generic functions
Method, domain-axioms: Public generic functions
Method, domain-id-for-method-lookup: Private generic functions
Method, domain-include-parse: Private generic functions
Method, domain-include-parse: Private generic functions
Method, domain-items: Private generic functions
Method, domain-items: Private generic functions
Method, domain-method-id-lookup: Private generic functions
Method, domain-method-to-name-table: Private generic functions
Method, domain-methods: Public generic functions
Method, domain-methods: Public generic functions
Method, domain-name: Public generic functions
Method, domain-name: Public generic functions
Method, domain-name: Public generic functions
Method, domain-name-to-method-table: Private generic functions
Method, domain-operators: Public generic functions
Method, domain-operators: Public generic functions
Method, expand-loop: Private generic functions
Method, expand-loop: Private generic functions
Method, expand-loop-body: Private generic functions
Method, expand-loop-body: Private generic functions
Method, expand-loop-body: Private generic functions
Method, expand-primitive-state: Private generic functions
Method, expression: Private generic functions
Method, expression: Private generic functions
Method, expression: Private generic functions
Method, find-decompositions: Private generic functions
Method, find-failed-choice-entry: Private generic functions
Method, find-failed-choice-entry: Private generic functions
Method, find-failed-stack-entry: Private generic functions
Method, find-failed-stack-entry: Private generic functions
Method, find-failed-task: Public generic functions
Method, find-failed-task: Public generic functions
Method, find-failed-task: Public generic functions
Method, fluent-comparison-p: Private generic functions
Method, fluent-comparison-p: Private generic functions
Method, fluent-expr-p: Private generic functions
Method, fluent-expr-p: Private generic functions
Method, fluent-expr-p: Private generic functions
Method, fluent-function-p: Private generic functions
Method, fluent-function-p: Private generic functions
Method, fluent-functions: Private generic functions
Method, get-state: Public generic functions
Method, get-state: Public generic functions
Method, get-tasks: Public generic functions
Method, get-tasks: Public generic functions
Method, guidance: Private generic functions
Method, guidance: Private generic functions
Method, handle-domain-options: Public generic functions
Method, has-static-preds-p: Public generic functions
Method, has-static-preds-p: Public generic functions
Method, include-in-tag: Private generic functions
Method, initialize-problem: Private generic functions
Method, insert-atom: Private generic functions
Method, insert-atom: Private generic functions
Method, insert-atom: Private generic functions
Method, insert-atom: Private generic functions
Method, insert-atom: Private generic functions
Method, install-domain: Private generic functions
Method, last-establisher: Public generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-keywordp: Private generic functions
Method, logical-op: Private generic functions
Method, lookup-table: Private generic functions
Method, make-initial-state: Public generic functions
Method, make-initial-state: Public generic functions
Method, make-initial-state: Public generic functions
Method, make-initial-state: Public generic functions
Method, make-initial-state: Public generic functions
Method, make-initial-state: Public generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-instantiator: Private generic functions
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, make-load-form: Public standalone methods
Method, make-plan-return: Private generic functions
Method, make-plan-return: Private generic functions
Method, make-table-entries: Private generic functions
Method, make-table-entries: Private generic functions
Method, make-table-entries: Private generic functions
Method, method-definition-keywords: Private generic functions
Method, method-definition-keywords: Private generic functions
Method, method-expression-body: Private generic functions
Method, method-expression-task: Private generic functions
Method, method-head: Private generic functions
Method, method-id: Private generic functions
Method, method-name: Private generic functions
Method, method-name: Private generic functions
Method, method-p: Private generic functions
Method, method-p: Private generic functions
Method, method-p: Private generic functions
Method, method-preconditions: Private generic functions
Method, method-task: Private generic functions
Method, method-task-net: Private generic functions
Method, methods: Public generic functions
Method, methods: Public generic functions
Method, methods: Public generic functions
Method, mode: Private generic functions
Method, mode: Private generic functions
Method, name: Public generic functions
Method, old-name: Private generic functions
Method, op: Private generic functions
Method, operation-done-p: Public standalone methods
Method, operator: Private generic functions
Method, operator: Private generic functions
Method, operators-dont-fail: Private generic functions
Method, parent: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-item: Private generic functions
Method, parse-domain-items: Public generic functions
Method, parse-domain-items: Public generic functions
Method, parse-domain-items: Public generic functions
Method, parse-domain-items: Public generic functions
Method, partial-plan: Private generic functions
Method, partial-plan: Private generic functions
Method, partial-plan-cost: Private generic functions
Method, pddl-method-p: Private generic functions
Method, pddl-method-p: Private generic functions
Method, pddl-plan: Private generic functions
Method, pddl-types: Private generic functions
Method, plan: Private generic functions
Method, plan-cost: Private generic functions
Method, plan-cost: Private generic functions
Method, plan-tree: Private generic functions
Method, plan-tree->sexp: Public generic functions
Method, plan-tree->sexp: Public generic functions
Method, plan-tree->sexp: Public generic functions
Method, plan-tree->sexp: Public generic functions
Method, plan-tree->sexp: Public generic functions
Method, plan-tree-lookup: Private generic functions
Method, plans-found: Private generic functions
Method, predicate: Private generic functions
Method, predicate: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, problem->state: Private generic functions
Method, problem-name: Public generic functions
Method, problem-state: Private generic functions
Method, problem-state: Private generic functions
Method, problem-tasks: Private generic functions
Method, problem-tasks: Private generic functions
Method, process-action: Private generic functions
Method, process-add-or-delete: Private generic functions
Method, process-method: Public generic functions
Method, process-method: Public generic functions
Method, process-method-pre: Private generic functions
Method, process-method-pre: Private generic functions
Method, process-method-pre: Private generic functions
Method, process-op: Public generic functions
Method, process-operator: Public generic functions
Method, process-pre: Private generic functions
Method, protections: Private generic functions
Method, protections: Private generic functions
Method, query: Public generic functions
Method, query: Public generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, real-seek-satisfiers-for: Private generic functions
Method, record-decomposition: Private generic functions
Method, record-decomposition: Private generic functions
Method, redo-state-update: Private generic functions
Method, redo-state-update: Private generic functions
Method, redo-state-update: Private generic functions
Method, redo-state-update: Private generic functions
Method, regularize-axiom: Private generic functions
Method, remove-atom: Private generic functions
Method, remove-atom: Private generic functions
Method, remove-atom: Private generic functions
Method, remove-atom: Private generic functions
Method, remove-atom: Private generic functions
Method, replay-state-changes: Public generic functions
Method, replay-table: Private generic functions
Method, retract-state-changes: Public generic functions
Method, search-state: Private generic functions
Method, seek-plans: Private generic functions
Method, seek-plans-loop: Private generic functions
Method, seek-plans-nonprimitive: Private generic functions
Method, seek-plans-null: Public generic functions
Method, seek-plans-primitive: Public generic functions
Method, seek-plans-task: Private generic functions
Method, seek-plans-task: Private generic functions
Method, set-variable-property: Public generic functions
Method, slot-fillers: Private generic functions
Method, slot-fillers: Private generic functions
Method, slot-fillers: Private generic functions
Method, sort-methods: Public generic functions
Method, sort-methods: Public generic functions
Method, sort-methods: Public generic functions
Method, sort-results: Public generic functions
Method, sort-results: Public generic functions
Method, sort-tasks: Public generic functions
Method, sort-tasks: Public generic functions
Method, source-pddl-domain: Public generic functions
Method, state: Public generic functions
Method, state->state-type: Public generic functions
Method, state->state-type: Public generic functions
Method, state->state-type: Public generic functions
Method, state->state-type: Public generic functions
Method, state->state-type: Public generic functions
Method, state->state-type: Public generic functions
Method, state-all-atoms-for-predicate: Public generic functions
Method, state-all-atoms-for-predicate: Public generic functions
Method, state-all-atoms-for-predicate: Public generic functions
Method, state-all-atoms-for-predicate: Public generic functions
Method, state-all-atoms-for-predicate: Public generic functions
Method, state-atoms: Public generic functions
Method, state-atoms: Public generic functions
Method, state-atoms: Public generic functions
Method, state-atoms: Public generic functions
Method, state-atoms: Public generic functions
Method, state-atoms: Public generic functions
Method, state-candidate-atoms-for-goal: Public generic functions
Method, state-candidate-atoms-for-goal: Public generic functions
Method, state-candidate-atoms-for-goal: Public generic functions
Method, state-candidate-atoms-for-goal: Public generic functions
Method, state-candidate-atoms-for-goal: Public generic functions
Method, state-trajectory: Public generic functions
Method, static-preds: Public generic functions
Method, store-plan!: Private generic functions
Method, tag: Private generic functions
Method, tag-state: Public generic functions
Method, task: Private generic functions
Method, task: Private generic functions
Method, task-arity-mismatch-library-entry: Private generic functions
Method, task-arity-mismatch-library-task: Private generic functions
Method, task-arity-mismatch-task: Private generic functions
Method, task-sorter: Public generic functions
Method, tasks: Private generic functions
Method, tasks: Private generic functions
Method, tasks: Private generic functions
Method, tasks: Private generic functions
Method, tasks: Private generic functions
Method, top-tasks: Private generic functions
Method, top-tasks: Private generic functions
Method, top-tasks: Private generic functions
Method, top-tasks: Private generic functions
Method, translate-effect: Private generic functions
Method, translate-effect: Private generic functions
Method, translate-effect: Private generic functions
Method, translate-precondition: Private generic functions
Method, translate-precondition: Private generic functions
Method, translate-precondition: Private generic functions
Method, translate-precondition: Private generic functions
Method, tree: Private generic functions
Method, tree-node: Private generic functions
Method, trigger-trace: Public generic functions
Method, trigger-trace: Public generic functions
Method, trigger-trace: Public generic functions
Method, trigger-trace: Public generic functions
Method, trigger-trace: Public generic functions
Method, undo-state-update: Private generic functions
Method, undo-state-update: Private generic functions
Method, undo-state-update: Private generic functions
Method, undo-state-update: Private generic functions
Method, unfold-loop-task: Private generic functions
Method, unifier: Private generic functions
Method, unifier: Private generic functions
Method, unifier: Private generic functions
Method, unifier: Private generic functions
Method, validator-export: Public generic functions
Method, var: Private generic functions
Method, variable-names: Private generic functions
Method, world-state: Private generic functions
Method, world-state: Private generic functions
method-definition-keywords: Private generic functions
method-definition-keywords: Private generic functions
method-definition-keywords: Private generic functions
method-expression-body: Private generic functions
method-expression-body: Private generic functions
method-expression-task: Private generic functions
method-expression-task: Private generic functions
method-head: Private generic functions
method-head: Private generic functions
method-id: Private generic functions
method-id: Private generic functions
method-name: Private generic functions
method-name: Private generic functions
method-name: Private generic functions
method-p: Private generic functions
method-p: Private generic functions
method-p: Private generic functions
method-p: Private generic functions
method-preconditions: Private generic functions
method-preconditions: Private generic functions
method-printer: Private ordinary functions
method-sexp-p: Private ordinary functions
method-task: Private generic functions
method-task: Private generic functions
method-task-net: Private generic functions
method-task-net: Private generic functions
methods: Public generic functions
methods: Public generic functions
methods: Public generic functions
methods: Public generic functions
min-start: Private ordinary functions
mixed-state-block-at: Private ordinary functions
mixed-state-body: Private ordinary functions
mixed-state-p: Private ordinary functions
mixed-state-tags-info: Private ordinary functions
mode: Private generic functions
mode: Private generic functions
mode: Private generic functions

N
name: Public generic functions
name: Public generic functions
new-symbol: Private ordinary functions
node-children: Private ordinary functions
node-parent: Public ordinary functions
nshuffle-array: Private ordinary functions
nshuffle-list: Private ordinary functions

O
obj-bindings: Private ordinary functions
occurs: Private ordinary functions
of-type-exprs: Private ordinary functions
old-name: Private generic functions
old-name: Private generic functions
op: Private generic functions
op: Private generic functions
op-sexp-p: Private ordinary functions
operation-done-p: Public standalone methods
operator: Private generic functions
operator: Private generic functions
operator: Private generic functions
operator-additions: Private ordinary functions
operator-cost-fun: Private ordinary functions
operator-deletions: Private ordinary functions
operator-head: Private ordinary functions
operator-name: Private ordinary functions
operator-p: Private ordinary functions
operator-preconditions: Private ordinary functions
operator-printer: Private ordinary functions
operator-sexp-p: Private ordinary functions
operator-task: Private ordinary functions
operators-dont-fail: Private generic functions
operators-dont-fail: Private generic functions
optimize-continue-p: Private ordinary functions
ordered-tree-node-children: Private ordinary functions
ordered-tree-node-dependencies: Private ordinary functions
ordered-tree-node-expanded-task: Private ordinary functions
ordered-tree-node-method-name: Private ordinary functions
ordered-tree-node-p: Private ordinary functions
ordered-tree-node-parent: Private ordinary functions
ordered-tree-node-task: Private ordinary functions

P
parent: Private generic functions
parent: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-item: Private generic functions
parse-domain-items: Public generic functions
parse-domain-items: Public generic functions
parse-domain-items: Public generic functions
parse-domain-items: Public generic functions
parse-domain-items: Public generic functions
parse-pddl-method: Private ordinary functions
parse-typed-list: Private ordinary functions
partial-plan: Private generic functions
partial-plan: Private generic functions
partial-plan: Private generic functions
partial-plan-cost: Private generic functions
partial-plan-cost: Private generic functions
pddl-action-cost-fun: Private ordinary functions
pddl-action-effect: Private ordinary functions
pddl-action-head: Private ordinary functions
pddl-action-name: Private ordinary functions
pddl-action-p: Private ordinary functions
pddl-action-precondition: Private ordinary functions
pddl-method-p: Private generic functions
pddl-method-p: Private generic functions
pddl-method-p: Private generic functions
pddl-plan: Private generic functions
pddl-plan: Private generic functions
pddl-satisfiers-for-exists: Private ordinary functions
pddl-satisfiers-for-f-exp: Private ordinary functions
pddl-satisfiers-for-forall: Private ordinary functions
pddl-satisfiers-for-imply: Private ordinary functions
pddl-satisfiers-for-not: Private ordinary functions
pddl-types: Private generic functions
pddl-types: Private generic functions
phase-one: Private ordinary functions
plan: Private generic functions
plan: Private generic functions
plan-cost: Private generic functions
plan-cost: Private generic functions
plan-cost: Private generic functions
plan-final-state: Public ordinary functions
plan-operator-nodes: Private ordinary functions
plan-returns: Private ordinary functions
plan-states: Public ordinary functions
plan-tree: Private generic functions
plan-tree: Private generic functions
plan-tree->sexp: Public generic functions
plan-tree->sexp: Public generic functions
plan-tree->sexp: Public generic functions
plan-tree->sexp: Public generic functions
plan-tree->sexp: Public generic functions
plan-tree->sexp: Public generic functions
plan-tree-lookup: Private generic functions
plan-tree-lookup: Private generic functions
plan-tree-nodes: Private ordinary functions
plans-found: Private generic functions
plans-found: Private generic functions
populate-plan-return: Private ordinary functions
pprint-plan: Public ordinary functions
pprint-preconds: Private ordinary functions
pprint-step: Private ordinary functions
pprint-task-net: Private ordinary functions
predicate: Private generic functions
predicate: Private generic functions
predicate: Private generic functions
prepare-choose-immediate-task-state: Private ordinary functions
prepare-return-values: Public ordinary functions
prepare-state-tag-decoder: Public ordinary functions
primitive-node-cost: Public ordinary functions
primitive-node-p: Public ordinary functions
primitive-node-position: Public ordinary functions
primitive-node-task: Public ordinary functions
primitive-symbol-p: Private ordinary functions
primitive-tree-node-dependencies: Private ordinary functions
primitive-tree-node-expanded-task: Private ordinary functions
primitive-tree-node-p: Private ordinary functions
primitive-tree-node-parent: Private ordinary functions
primitive-tree-node-task: Private ordinary functions
primitivep: Private ordinary functions
print-axioms: Public ordinary functions
print-belief-state-readably: Public ordinary functions
print-current-plan: Private ordinary functions
print-current-state: Public ordinary functions
print-current-tasks: Private ordinary functions
print-list-on-lines: Private ordinary functions
print-list-suffix-lines: Private ordinary functions
print-methods: Public ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-operator: Private ordinary functions
print-operators: Public ordinary functions
print-output-file: Private ordinary functions
print-stats: Private ordinary functions
print-stats-header: Private ordinary functions
print-unreadably: Private macros
print1: Private ordinary functions
problem->state: Private generic functions
problem->state: Private generic functions
problem-name: Public generic functions
problem-name: Public generic functions
problem-state: Private generic functions
problem-state: Private generic functions
problem-state: Private generic functions
problem-tasks: Private generic functions
problem-tasks: Private generic functions
problem-tasks: Private generic functions
process-action: Private generic functions
process-action: Private generic functions
process-add-list: Private ordinary functions
process-add-or-delete: Private generic functions
process-add-or-delete: Private generic functions
process-axiom: Public ordinary functions
process-delete-list: Private ordinary functions
process-method: Public generic functions
process-method: Public generic functions
process-method: Public generic functions
process-method-pre: Private generic functions
process-method-pre: Private generic functions
process-method-pre: Private generic functions
process-method-pre: Private generic functions
process-op: Public generic functions
process-op: Public generic functions
process-operator: Public generic functions
process-operator: Public generic functions
process-pddl-method-pre: Private ordinary functions
process-pre: Private generic functions
process-pre: Private generic functions
process-task-list: Private ordinary functions
prop: Public ordinary functions
prop-sorter: Public ordinary functions
protection-ok: Private ordinary functions
protections: Private generic functions
protections: Private generic functions
protections: Private generic functions
pseudo-node-children: Private ordinary functions
pseudo-node-dependencies: Private ordinary functions
pseudo-node-expanded-task: Private ordinary functions
pseudo-node-method-name: Private ordinary functions
pseudo-node-p: Private ordinary functions
pseudo-node-parent: Private ordinary functions
pseudo-node-task: Private ordinary functions
pull-tag-info: Private ordinary functions
push-last: Private macros

Q
query: Public generic functions
query: Public generic functions
query: Public generic functions
query-current-state: Private ordinary functions
quotify: Private ordinary functions

R
randomize-list: Private ordinary functions
raw-depend-p: Private ordinary functions
rd-est: Private ordinary functions
rd-prop: Private ordinary functions
rd-union: Private ordinary functions
real-apply-substitution: Private ordinary functions
real-seek-satisfiers: Private ordinary functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
real-seek-satisfiers-for: Private generic functions
record-decomposition: Private generic functions
record-decomposition: Private generic functions
record-decomposition: Private generic functions
record-node-expansion: Private ordinary functions
record-operator: Private ordinary functions
record-reduction: Private ordinary functions
redo-state-update: Private generic functions
redo-state-update: Private generic functions
redo-state-update: Private generic functions
redo-state-update: Private generic functions
redo-state-update: Private generic functions
regularize-axiom: Private generic functions
regularize-axiom: Private generic functions
remove-atom: Private generic functions
remove-atom: Private generic functions
remove-atom: Private generic functions
remove-atom: Private generic functions
remove-atom: Private generic functions
remove-atom: Private generic functions
remove-costs: Public ordinary functions
remove-internal-operators: Public ordinary functions
remove-subtree-from-table: Private ordinary functions
rename-sym: Private ordinary functions
repair-plan: Public ordinary functions
replace-task-main-list: Private ordinary functions
replace-task-top-list: Private ordinary functions
replan-from-failure: Private ordinary functions
replay-state-changes: Public generic functions
replay-state-changes: Public generic functions
replay-table: Private generic functions
replay-table: Private generic functions
replay-table-entry-alist: Private ordinary functions
replay-table-entry-p: Private ordinary functions
replay-table-entry-singleton: Private ordinary functions
report-no-method: Private ordinary functions
report-task-arity-mismatch: Private ordinary functions
rest-shop2-axiom-p: Private ordinary functions
resymbol-task: Private ordinary functions
retract-state-changes: Public generic functions
retract-state-changes: Public generic functions

S
search-state: Private generic functions
search-state: Private generic functions
search-tree: Private ordinary functions
seek-plans: Private generic functions
seek-plans: Private generic functions
seek-plans-loop: Private generic functions
seek-plans-loop: Private generic functions
seek-plans-nonprimitive: Private generic functions
seek-plans-nonprimitive: Private generic functions
seek-plans-null: Public generic functions
seek-plans-null: Public generic functions
seek-plans-primitive: Public generic functions
seek-plans-primitive: Public generic functions
seek-plans-primitive-1: Private ordinary functions
seek-plans-stack: Private ordinary functions
seek-plans-task: Private generic functions
seek-plans-task: Private generic functions
seek-plans-task: Private generic functions
seek-satisfiers: Private macros
set-domain: Public ordinary functions
set-variable-property: Public generic functions
set-variable-property: Public generic functions
Setf Expander, (setf tree-node-task): Public ordinary functions
setof-bagof-helper: Private ordinary functions
shop-fail: Public macros
shop-trace: Public macros
shop-trace-1: Private ordinary functions
shop-trace-info: Public ordinary functions
shop-union: Public ordinary functions
shop-untrace: Public macros
shop-untrace-1: Private ordinary functions
shop-untrace-all: Private ordinary functions
shop2-axiom-p: Private ordinary functions
shorter-plan: Public ordinary functions
simple-backquote: Private macros
slot-fillers: Private generic functions
slot-fillers: Private generic functions
slot-fillers: Private generic functions
slot-fillers: Private generic functions
slot-value-translator: Private ordinary functions
sort-methods: Public generic functions
sort-methods: Public generic functions
sort-methods: Public generic functions
sort-methods: Public generic functions
sort-results: Public generic functions
sort-results: Public generic functions
sort-results: Public generic functions
sort-tasks: Public generic functions
sort-tasks: Public generic functions
sort-tasks: Public generic functions
source-pddl-domain: Public generic functions
source-pddl-domain: Public generic functions
stack-backjump: Private ordinary functions
stack-backtrack: Private ordinary functions
stack-constructor: Private macros
standard-satisfiers-for-and: Private ordinary functions
standard-satisfiers-for-assign: Private ordinary functions
standard-satisfiers-for-assign*: Private ordinary functions
standard-satisfiers-for-bagof: Private ordinary functions
standard-satisfiers-for-call: Private ordinary functions
standard-satisfiers-for-enforce: Private ordinary functions
standard-satisfiers-for-eval: Private ordinary functions
standard-satisfiers-for-exists: Private ordinary functions
standard-satisfiers-for-external: Private ordinary functions
standard-satisfiers-for-forall: Private ordinary functions
standard-satisfiers-for-imply: Private ordinary functions
standard-satisfiers-for-not: Private ordinary functions
standard-satisfiers-for-or: Private ordinary functions
standard-satisfiers-for-setof: Private ordinary functions
standardize: Public ordinary functions
state: Public generic functions
state: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state->state-type: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-all-atoms-for-predicate: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-atoms: Public generic functions
state-body: Private ordinary functions
state-candidate-atoms-for-goal: Public generic functions
state-candidate-atoms-for-goal: Public generic functions
state-candidate-atoms-for-goal: Public generic functions
state-candidate-atoms-for-goal: Public generic functions
state-candidate-atoms-for-goal: Public generic functions
state-candidate-atoms-for-goal: Public generic functions
state-p: Private ordinary functions
state-trajectory: Public generic functions
state-trajectory: Public generic functions
state-update-action: Private ordinary functions
state-update-literal: Private ordinary functions
state-update-p: Private ordinary functions
static-bounds-p: Private ordinary functions
static-preds: Public generic functions
static-preds: Public generic functions
store-plan!: Private generic functions
store-plan!: Private generic functions
strip-nops: Private ordinary functions
strip-task-sexp: Private ordinary functions
strip-tree-tags: Private ordinary functions

T
tag: Private generic functions
tag: Private generic functions
tag-for-action: Public ordinary functions
tag-state: Public generic functions
tag-state: Public generic functions
tagged-state-block-at: Private ordinary functions
tagged-state-body: Private ordinary functions
tagged-state-p: Private ordinary functions
tagged-state-tags-info: Private ordinary functions
tagged-state-tags-info-tag: Private ordinary functions
task: Private generic functions
task: Private generic functions
task: Private generic functions
task-args: Private ordinary functions
task-arity-mismatch-library-entry: Private generic functions
task-arity-mismatch-library-entry: Private generic functions
task-arity-mismatch-library-task: Private generic functions
task-arity-mismatch-library-task: Private generic functions
task-arity-mismatch-task: Private generic functions
task-arity-mismatch-task: Private generic functions
task-name: Public ordinary functions
task-sorter: Public generic functions
task-sorter: Public generic functions
tasks: Private generic functions
tasks: Private generic functions
tasks: Private generic functions
tasks: Private generic functions
tasks: Private generic functions
tasks: Private generic functions
test-plan-found: Private ordinary functions
time-expired-p: Private ordinary functions
to-string: Private ordinary functions
top-node-children: Private ordinary functions
top-node-dependencies: Private ordinary functions
top-node-expanded-task: Private ordinary functions
top-node-lookup-table: Private ordinary functions
top-node-method-name: Private ordinary functions
top-node-p: Private ordinary functions
top-node-parent: Private ordinary functions
top-node-task: Private ordinary functions
top-tasks: Private generic functions
top-tasks: Private generic functions
top-tasks: Private generic functions
top-tasks: Private generic functions
top-tasks: Private generic functions
trace-print: Public macros
translate-child-links: Private ordinary functions
translate-dependency-links: Private ordinary functions
translate-effect: Private generic functions
translate-effect: Private generic functions
translate-effect: Private generic functions
translate-effect: Private generic functions
translate-fluent-precond: Private ordinary functions
translate-include: Private ordinary functions
translate-lookup-table: Private ordinary functions
translate-metric-updates: Private ordinary functions
translate-pddl-quantifier: Private ordinary functions
translate-precondition: Private generic functions
translate-precondition: Private generic functions
translate-precondition: Private generic functions
translate-precondition: Private generic functions
translate-precondition: Private generic functions
tree: Private generic functions
tree: Private generic functions
tree-compare: Private ordinary functions
tree-node: Private generic functions
tree-node: Private generic functions
tree-node-dependencies: Public ordinary functions
tree-node-expanded-task: Public ordinary functions
tree-node-p: Private ordinary functions
tree-node-parent: Public ordinary functions
tree-node-task: Public ordinary functions
tree-node-task: Public ordinary functions
tree-node-task-name: Public ordinary functions
trigger-trace: Public generic functions
trigger-trace: Public generic functions
trigger-trace: Public generic functions
trigger-trace: Public generic functions
trigger-trace: Public generic functions
trigger-trace: Public generic functions
typed-list-vars: Private ordinary functions

U
undo-state-update: Private generic functions
undo-state-update: Private generic functions
undo-state-update: Private generic functions
undo-state-update: Private generic functions
undo-state-update: Private generic functions
unfold-loop-task: Private generic functions
unfold-loop-task: Private generic functions
unifier: Private generic functions
unifier: Private generic functions
unifier: Private generic functions
unifier: Private generic functions
unifier: Private generic functions
unify: Public ordinary functions
unify-fail: Public macros
unify-fail-p: Public macros
unify-p: Public macros
unify1: Private ordinary functions
uniquify-anonymous-variables: Public ordinary functions
unordered-tree-node-children: Private ordinary functions
unordered-tree-node-dependencies: Private ordinary functions
unordered-tree-node-expanded-task: Private ordinary functions
unordered-tree-node-method-name: Private ordinary functions
unordered-tree-node-p: Private ordinary functions
unordered-tree-node-parent: Private ordinary functions
unordered-tree-node-task: Private ordinary functions
user-choose-task: Private ordinary functions

V
validate-plan: Public ordinary functions
validator-export: Public generic functions
validator-export: Public generic functions
var: Private generic functions
var: Private generic functions
variable-gensym: Public ordinary functions
variable-name: Private ordinary functions
variable-names: Private generic functions
variable-names: Private generic functions
variable-p: Public macros
variable-symbol-p: Private ordinary functions
variablep: Public ordinary functions
vars-boundp: Private ordinary functions
verbose-format: Private macros

W
well-formed-listp: Private ordinary functions
when-done: Private macros
with-method-name-table: Private macros
world-state: Private generic functions
world-state: Private generic functions
world-state: Private generic functions
write-pddl-plan: Public ordinary functions


A.3 Variables

Jump to:   *   +  
A   B   C   D   E   F   I   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

*
*action-to-tag-map*: Private special variables
*all-method-names*: Private special variables
*all-problems*: Private special variables
*analogical-replay*: Private special variables
*analogical-replay-table*: Private special variables
*attribution-list*: Public special variables
*back-quote-name*: Private special variables
*before-extract-trees-hook*: Private special variables
*break-on-backtrack*: Private special variables
*collect-state*: Private special variables
*current-plan*: Private special variables
*current-state*: Public special variables
*current-tasks*: Private special variables
*defdomain-pathname*: Private special variables
*defdomain-verbose*: Public special variables
*define-silently*: Public special variables
*depth-cutoff*: Private special variables
*domain*: Public special variables
*enhanced-plan-tree*: Private special variables
*establishers*: Public special variables
*expansions*: Private special variables
*explanation*: Private special variables
*external-access*: Public special variables
*gc*: Private special variables
*hand-steer*: Private special variables
*ignore-singleton-variables*: Private special variables
*include-rationale*: Private special variables
*inferences*: Public special variables
*internal-time-limit*: Private special variables
*internal-time-tag*: Private special variables
*leashed*: Private special variables
*literals*: Public special variables
*make-analogy-table*: Private special variables
*more-tasks-p*: Private special variables
*negation-deps-ok*: Private special variables
*no-dependencies*: Private special variables
*node-children-table*: Private special variables
*node-list*: Private special variables
*old-depth*: Private special variables
*operator-tasks*: Private special variables
*optimal-cost*: Private special variables
*optimal-plan*: Private special variables
*optimize-cost*: Private special variables
*optimize-first-retrieval*: Private special variables
*plan-num-limit*: Private special variables
*plan-tree*: Private special variables
*plans-found*: Private special variables
*pp*: Private special variables
*print-plans*: Private special variables
*print-stats*: Private special variables
*problem*: Private special variables
*protections*: Private special variables
*pshort*: Private special variables
*record-dependencies-p*: Public special variables
*shop-pprint-table*: Private special variables
*shop-trace*: Public special variables
*shop-trace-stream*: Public special variables
*shop-version*: Private special variables
*start-real-time*: Private special variables
*start-run-time*: Private special variables
*state*: Public special variables
*state-encoding*: Public special variables
*state-tag-map*: Private special variables
*states-found*: Private special variables
*subtask-parents*: Private special variables
*table-for-load-form*: Private special variables
*task-operator*: Private special variables
*tasklist*: Private special variables
*time-limit*: Private special variables
*trace-query*: Public special variables
*traced-axioms*: Private special variables
*traced-goals*: Private special variables
*traced-methods*: Private special variables
*traced-tasks*: Private special variables
*unifiers-found*: Private special variables
*unique-method-names*: Private special variables
*validator-progname*: Private special variables
*verbose*: Private special variables
*which*: Public special variables

+
+anonymous-property-name+: Private constants
+binary-numerical-operators+: Private special variables
+fluent-updates+: Private special variables
+method-definition-keywords+: Private special variables
+numerical-comparisons+: Private special variables
+pddl-requirements-keywords+: Private special variables
+primitive-property-name+: Private constants
+shop-trace-items+: Private constants
+shopyright+: Private constants
+singleton-term+: Private constants
+variable-property-name+: Private constants
+variable-term+: Private constants

A
action: Private structures
alist: Private structures
alternatives: Private classes
alternatives: Private classes
argno: Public conditions
argno: Public conditions
axioms: Private classes

B
backtrack-stack: Private classes
bad-conjunction: Private conditions
block-at: Public structures
body: Public structures
branch-number: Public conditions

C
child: Private classes
children: Public structures
comment: Public conditions
Constant, +anonymous-property-name+: Private constants
Constant, +primitive-property-name+: Private constants
Constant, +shop-trace-items+: Private constants
Constant, +shopyright+: Private constants
Constant, +singleton-term+: Private constants
Constant, +variable-property-name+: Private constants
Constant, +variable-term+: Private constants
construct: Public conditions
construct-name: Public conditions
construct-type: Public conditions
consumer: Public structures
context-name: Private conditions
context-type: Private conditions
correct-arity: Private conditions
cost: Private classes
current-task: Private classes
current-task: Private classes

D
default-state-type: Public classes
dependencies: Public structures
dependencies: Private classes
depth: Private classes
domain-name: Public classes
domain-name: Public classes

E
est: Private structures
establisher: Public structures
expanded-task: Public structures
expression: Public conditions
expression: Public conditions
expression: Private conditions

F
fluent-functions: Private classes

I
items: Public classes

L
library-entry: Public conditions
library-task: Public conditions
literal: Private structures
logical-op: Public conditions
lookup-table: Public structures
lookup-table: Private classes

M
method-id: Private classes
method-name: Public structures
methods: Private classes
methods-to-names: Private classes
mode: Private classes
mode: Private classes

N
name: Public classes
names-to-methods: Private classes

O
old-name: Private conditions
op: Private conditions
operators: Private classes
operators-dont-fail: Private classes

P
parent: Public structures
parent: Private classes
partial-plan: Private classes
partial-plan: Private classes
partial-plan-cost: Private classes
pddl-types: Public classes
plan: Private classes
plan-tree: Private classes
plan-tree-lookup: Private classes
plans-found: Private classes
predicate: Public conditions
predicate: Public conditions
prop: Public structures
prop: Private structures
protections: Private classes
protections: Private classes

R
replacement: Private conditions
replay-table: Private classes

S
search-state: Private classes
singleton: Private structures
Slot, action: Private structures
Slot, alist: Private structures
Slot, alternatives: Private classes
Slot, alternatives: Private classes
Slot, argno: Public conditions
Slot, argno: Public conditions
Slot, axioms: Private classes
Slot, backtrack-stack: Private classes
Slot, bad-conjunction: Private conditions
Slot, block-at: Public structures
Slot, body: Public structures
Slot, branch-number: Public conditions
Slot, child: Private classes
Slot, children: Public structures
Slot, comment: Public conditions
Slot, construct: Public conditions
Slot, construct-name: Public conditions
Slot, construct-type: Public conditions
Slot, consumer: Public structures
Slot, context-name: Private conditions
Slot, context-type: Private conditions
Slot, correct-arity: Private conditions
Slot, cost: Private classes
Slot, current-task: Private classes
Slot, current-task: Private classes
Slot, default-state-type: Public classes
Slot, dependencies: Public structures
Slot, dependencies: Private classes
Slot, depth: Private classes
Slot, domain-name: Public classes
Slot, domain-name: Public classes
Slot, est: Private structures
Slot, establisher: Public structures
Slot, expanded-task: Public structures
Slot, expression: Public conditions
Slot, expression: Public conditions
Slot, expression: Private conditions
Slot, fluent-functions: Private classes
Slot, items: Public classes
Slot, library-entry: Public conditions
Slot, library-task: Public conditions
Slot, literal: Private structures
Slot, logical-op: Public conditions
Slot, lookup-table: Public structures
Slot, lookup-table: Private classes
Slot, method-id: Private classes
Slot, method-name: Public structures
Slot, methods: Private classes
Slot, methods-to-names: Private classes
Slot, mode: Private classes
Slot, mode: Private classes
Slot, name: Public classes
Slot, names-to-methods: Private classes
Slot, old-name: Private conditions
Slot, op: Private conditions
Slot, operators: Private classes
Slot, operators-dont-fail: Private classes
Slot, parent: Public structures
Slot, parent: Private classes
Slot, partial-plan: Private classes
Slot, partial-plan: Private classes
Slot, partial-plan-cost: Private classes
Slot, pddl-types: Public classes
Slot, plan: Private classes
Slot, plan-tree: Private classes
Slot, plan-tree-lookup: Private classes
Slot, plans-found: Private classes
Slot, predicate: Public conditions
Slot, predicate: Public conditions
Slot, prop: Public structures
Slot, prop: Private structures
Slot, protections: Private classes
Slot, protections: Private classes
Slot, replacement: Private conditions
Slot, replay-table: Private classes
Slot, search-state: Private classes
Slot, singleton: Private structures
Slot, source-pddl-domain: Public classes
Slot, state-atoms: Public classes
Slot, static-preds: Public classes
Slot, tag: Private classes
Slot, tags-info: Public structures
Slot, task: Public conditions
Slot, task: Public structures
Slot, task: Private conditions
Slot, task: Private classes
Slot, task-name: Public conditions
Slot, tasks: Public classes
Slot, tasks: Private classes
Slot, tasks: Private classes
Slot, tasks: Private classes
Slot, tasks: Private classes
Slot, top-tasks: Private classes
Slot, top-tasks: Private classes
Slot, top-tasks: Private classes
Slot, top-tasks: Private classes
Slot, tree: Private classes
Slot, tree-node: Private classes
Slot, unifier: Private classes
Slot, unifier: Private classes
Slot, unifier: Private classes
Slot, unifier: Private classes
Slot, val: Private structures
Slot, var: Public conditions
Slot, var: Private structures
Slot, variable-names: Public conditions
Slot, world-state: Private classes
Slot, world-state: Private classes
source-pddl-domain: Public classes
Special Variable, *action-to-tag-map*: Private special variables
Special Variable, *all-method-names*: Private special variables
Special Variable, *all-problems*: Private special variables
Special Variable, *analogical-replay*: Private special variables
Special Variable, *analogical-replay-table*: Private special variables
Special Variable, *attribution-list*: Public special variables
Special Variable, *back-quote-name*: Private special variables
Special Variable, *before-extract-trees-hook*: Private special variables
Special Variable, *break-on-backtrack*: Private special variables
Special Variable, *collect-state*: Private special variables
Special Variable, *current-plan*: Private special variables
Special Variable, *current-state*: Public special variables
Special Variable, *current-tasks*: Private special variables
Special Variable, *defdomain-pathname*: Private special variables
Special Variable, *defdomain-verbose*: Public special variables
Special Variable, *define-silently*: Public special variables
Special Variable, *depth-cutoff*: Private special variables
Special Variable, *domain*: Public special variables
Special Variable, *enhanced-plan-tree*: Private special variables
Special Variable, *establishers*: Public special variables
Special Variable, *expansions*: Private special variables
Special Variable, *explanation*: Private special variables
Special Variable, *external-access*: Public special variables
Special Variable, *gc*: Private special variables
Special Variable, *hand-steer*: Private special variables
Special Variable, *ignore-singleton-variables*: Private special variables
Special Variable, *include-rationale*: Private special variables
Special Variable, *inferences*: Public special variables
Special Variable, *internal-time-limit*: Private special variables
Special Variable, *internal-time-tag*: Private special variables
Special Variable, *leashed*: Private special variables
Special Variable, *literals*: Public special variables
Special Variable, *make-analogy-table*: Private special variables
Special Variable, *more-tasks-p*: Private special variables
Special Variable, *negation-deps-ok*: Private special variables
Special Variable, *no-dependencies*: Private special variables
Special Variable, *node-children-table*: Private special variables
Special Variable, *node-list*: Private special variables
Special Variable, *old-depth*: Private special variables
Special Variable, *operator-tasks*: Private special variables
Special Variable, *optimal-cost*: Private special variables
Special Variable, *optimal-plan*: Private special variables
Special Variable, *optimize-cost*: Private special variables
Special Variable, *optimize-first-retrieval*: Private special variables
Special Variable, *plan-num-limit*: Private special variables
Special Variable, *plan-tree*: Private special variables
Special Variable, *plans-found*: Private special variables
Special Variable, *pp*: Private special variables
Special Variable, *print-plans*: Private special variables
Special Variable, *print-stats*: Private special variables
Special Variable, *problem*: Private special variables
Special Variable, *protections*: Private special variables
Special Variable, *pshort*: Private special variables
Special Variable, *record-dependencies-p*: Public special variables
Special Variable, *shop-pprint-table*: Private special variables
Special Variable, *shop-trace*: Public special variables
Special Variable, *shop-trace-stream*: Public special variables
Special Variable, *shop-version*: Private special variables
Special Variable, *start-real-time*: Private special variables
Special Variable, *start-run-time*: Private special variables
Special Variable, *state*: Public special variables
Special Variable, *state-encoding*: Public special variables
Special Variable, *state-tag-map*: Private special variables
Special Variable, *states-found*: Private special variables
Special Variable, *subtask-parents*: Private special variables
Special Variable, *table-for-load-form*: Private special variables
Special Variable, *task-operator*: Private special variables
Special Variable, *tasklist*: Private special variables
Special Variable, *time-limit*: Private special variables
Special Variable, *trace-query*: Public special variables
Special Variable, *traced-axioms*: Private special variables
Special Variable, *traced-goals*: Private special variables
Special Variable, *traced-methods*: Private special variables
Special Variable, *traced-tasks*: Private special variables
Special Variable, *unifiers-found*: Private special variables
Special Variable, *unique-method-names*: Private special variables
Special Variable, *validator-progname*: Private special variables
Special Variable, *verbose*: Private special variables
Special Variable, *which*: Public special variables
Special Variable, +binary-numerical-operators+: Private special variables
Special Variable, +fluent-updates+: Private special variables
Special Variable, +method-definition-keywords+: Private special variables
Special Variable, +numerical-comparisons+: Private special variables
Special Variable, +pddl-requirements-keywords+: Private special variables
state-atoms: Public classes
static-preds: Public classes

T
tag: Private classes
tags-info: Public structures
task: Public conditions
task: Public structures
task: Private conditions
task: Private classes
task-name: Public conditions
tasks: Public classes
tasks: Private classes
tasks: Private classes
tasks: Private classes
tasks: Private classes
top-tasks: Private classes
top-tasks: Private classes
top-tasks: Private classes
top-tasks: Private classes
tree: Private classes
tree-node: Private classes

U
unifier: Private classes
unifier: Private classes
unifier: Private classes
unifier: Private classes

V
val: Private structures
var: Public conditions
var: Private structures
variable-names: Public conditions

W
world-state: Private classes
world-state: Private classes


A.4 Data types

Jump to:   %  
A   B   C   D   E   F   H   I   L   M   N   O   P   Q   R   S   T   U   V  
Index Entry  Section

%
%shop3-common-private%: The %shop3-common-private% package

A
action-type: Private types
actions-domain-mixin: Private classes
add-child-to-tree: Private classes
add-dependencies: Private classes
adl-domain: Public classes
adl-mixin: Public classes
analogical-replay.lisp: The shop3/explicit-stack-search/analogical-replay․lisp file

B
backtrack-stack.lisp: The shop3/explicit-stack-search/backtrack-stack․lisp file
bad-argument: Public conditions
binding: Private structures
binding-list: Public types
bit-state: Private structures
bottom-of-stack: Private classes

C
choice-entry: Private classes
cl-file: Private classes
Class, actions-domain-mixin: Private classes
Class, add-child-to-tree: Private classes
Class, add-dependencies: Private classes
Class, adl-domain: Public classes
Class, adl-mixin: Public classes
Class, bottom-of-stack: Private classes
Class, choice-entry: Private classes
Class, cl-file: Private classes
Class, conditional-effects-mixin: Public classes
Class, costs-mixin: Public classes
Class, disjunctive-preconditions-mixin: Public classes
Class, domain: Public classes
Class, domain-core: Private classes
Class, equality-mixin: Public classes
Class, existential-preconditions-mixin: Public classes
Class, fluents-mixin: Private classes
Class, has-axioms-mixin: Private classes
Class, loop-state-expand: Private classes
Class, looping-domain: Private classes
Class, method-instantiation: Private classes
Class, negative-preconditions-mixin: Public classes
Class, pddl-domain: Public classes
Class, pddl-typing-mixin: Public classes
Class, plan-return: Private classes
Class, prim-state-expand: Private classes
Class, problem: Public classes
Class, pure-logic-domain-mixin: Public classes
Class, quantified-preconditions-mixin: Public classes
Class, record-expansion: Private classes
Class, record-expansion-for-replay: Private classes
Class, search-state: Private classes
Class, shop-fiveam-tester: Private classes
Class, shop-tester-mixin: Private classes
Class, simple-pddl-domain: Public classes
Class, stack-entry: Private classes
Class, state-tag: Private classes
Class, static-predicates-mixin: Public classes
Class, tester-cl-source-file: Private classes
Class, thpr-domain: Public classes
Class, universal-preconditions-mixin: Public classes
common.lisp: The shop3/common/common․lisp file
complex-node: Private types
complex-tree-node: Public structures
Condition, bad-argument: Public conditions
Condition, cut-commit: Private conditions
Condition, domain-item-parse-warning: Private conditions
Condition, domain-parse-error: Private conditions
Condition, domain-parse-warning: Private conditions
Condition, domain-style-warning: Private conditions
Condition, implicit-conjunction-warning: Private conditions
Condition, incomplete-dependency-error: Public conditions
Condition, incorrect-arity-error: Private conditions
Condition, instantiation-error: Public conditions
Condition, no-failed-task: Private conditions
Condition, no-method-for-task: Public conditions
Condition, non-ground-error: Public conditions
Condition, non-unique-method-name-error: Private conditions
Condition, non-unique-method-name-mixin: Private conditions
Condition, non-unique-method-name-warning: Private conditions
Condition, search-failed: Private conditions
Condition, shop-condition: Private conditions
Condition, shop-error: Private conditions
Condition, singleton-variable: Public conditions
Condition, task-arity-mismatch: Public conditions
Condition, theorem-prover-condition: Public conditions
conditional-effects-mixin: Public classes
costs-mixin: Public classes
cut-commit: Private conditions

D
debugging.lisp: The shop3/io/debugging․lisp file
decls.lisp: The shop3/decls․lisp file
decls.lisp: The shop3/pddl/decls․lisp file
decls.lisp: The shop3/explicit-stack-search/decls․lisp file
decls.lisp: The shop3/minimal-subtree/decls․lisp file
decls.lisp: The shop3/theorem-prover/decls․lisp file
dependency: Public structures
disjunctive-preconditions-mixin: Public classes
divergence-list: Private types
domain: Public classes
domain-core: Private classes
domain-item-parse-warning: Private conditions
domain-parse-error: Private conditions
domain-parse-warning: Private conditions
domain-style-warning: Private conditions
doubly-hashed-state: Private structures

E
equality-mixin: Public classes
existential-preconditions-mixin: Public classes
explicit-search.lisp: The shop3/explicit-stack-search/explicit-search․lisp file
explicit-stack-search: The shop3/explicit-stack-search module

F
File, analogical-replay.lisp: The shop3/explicit-stack-search/analogical-replay․lisp file
File, backtrack-stack.lisp: The shop3/explicit-stack-search/backtrack-stack․lisp file
File, common.lisp: The shop3/common/common․lisp file
File, debugging.lisp: The shop3/io/debugging․lisp file
File, decls.lisp: The shop3/decls․lisp file
File, decls.lisp: The shop3/pddl/decls․lisp file
File, decls.lisp: The shop3/explicit-stack-search/decls․lisp file
File, decls.lisp: The shop3/minimal-subtree/decls․lisp file
File, decls.lisp: The shop3/theorem-prover/decls․lisp file
File, explicit-search.lisp: The shop3/explicit-stack-search/explicit-search․lisp file
File, fluents.lisp: The shop3/pddl/fluents․lisp file
File, input.lisp: The shop3/io/input․lisp file
File, loop-extensions.lisp: The shop3/looping-tasks/loop-extensions․lisp file
File, minimal-subtree.lisp: The shop3/minimal-subtree/minimal-subtree․lisp file
File, output.lisp: The shop3/io/output․lisp file
File, package-common.lisp: The shop3/common/package-common․lisp file
File, package-thpr.lisp: The shop3/theorem-prover/package-thpr․lisp file
File, package-unifier.lisp: The shop3/unifier/package-unifier․lisp file
File, package.lisp: The shop3/package․lisp file
File, package.lisp: The shop3/minimal-subtree/package․lisp file
File, pddl.lisp: The shop3/pddl/pddl․lisp file
File, plan-printer.lisp: The shop3/plan-printer․lisp file
File, plan-repair.lisp: The shop3/plan-repair․lisp file
File, plan-trajectory.lisp: The shop3/search/plan-trajectory․lisp file
File, plan-tree.lisp: The shop3/explicit-stack-search/plan-tree․lisp file
File, prepare-return-values.lisp: The shop3/explicit-stack-search/prepare-return-values․lisp file
File, protections.lisp: The shop3/search/protections․lisp file
File, prover.lisp: The shop3/pddl/prover․lisp file
File, search.lisp: The shop3/search/search․lisp file
File, shop-pprint.lisp: The shop3/io/shop-pprint․lisp file
File, shop3.asd: The shop3/shop3․asd file
File, shop3.lisp: The shop3/shop3․lisp file
File, state-decls.lisp: The shop3/common/state-decls․lisp file
File, state-utils.lisp: The shop3/common/state-utils․lisp file
File, tagged-state.lisp: The shop3/common/tagged-state․lisp file
File, task-reductions.lisp: The shop3/search/task-reductions․lisp file
File, theorem-prover.lisp: The shop3/theorem-prover/theorem-prover․lisp file
File, tracer.lisp: The shop3/unifier/tracer․lisp file
File, tree-accessors.lisp: The shop3/tree/tree-accessors․lisp file
File, tree-reductions.lisp: The shop3/tree/tree-reductions․lisp file
File, unify.lisp: The shop3/unifier/unify․lisp file
fluents-mixin: Private classes
fluents.lisp: The shop3/pddl/fluents․lisp file

H
has-axioms-mixin: Private classes
hash-state: Private structures

I
implicit-conjunction-warning: Private conditions
incomplete-dependency-error: Public conditions
incorrect-arity-error: Private conditions
input.lisp: The shop3/io/input․lisp file
instantiation-error: Public conditions
io: The shop3/io module

L
list-raw-depend-lists: Private types
list-state: Private structures
loop-extensions.lisp: The shop3/looping-tasks/loop-extensions․lisp file
loop-state-expand: Private classes
looping-domain: Private classes
looping-tasks: The shop3/looping-tasks module

M
method-instantiation: Private classes
minimal-subtree: The shop3/minimal-subtree module
minimal-subtree.lisp: The shop3/minimal-subtree/minimal-subtree․lisp file
mixed-state: Private structures
Module, explicit-stack-search: The shop3/explicit-stack-search module
Module, io: The shop3/io module
Module, looping-tasks: The shop3/looping-tasks module
Module, minimal-subtree: The shop3/minimal-subtree module
Module, pddl: The shop3/pddl module
Module, search: The shop3/search module
Module, tree: The shop3/tree module

N
negative-preconditions-mixin: Public classes
no-failed-task: Private conditions
no-method-for-task: Public conditions
non-ground-error: Public conditions
non-unique-method-name-error: Private conditions
non-unique-method-name-mixin: Private conditions
non-unique-method-name-warning: Private conditions

O
operator: Private types
ordered-tree-node: Public structures
output.lisp: The shop3/io/output․lisp file

P
Package, %shop3-common-private%: The %shop3-common-private% package
Package, plan-tree: The plan-tree package
Package, prepare-return-values: The prepare-return-values package
Package, shop-asd: The shop-asd package
Package, shop3: The shop3 package
Package, shop3-minimal-subtree: The shop3-minimal-subtree package
Package, shop3-pprint: The shop3-pprint package
Package, shop3-user: The shop3-user package
Package, shop3.common: The shop3․common package
Package, shop3.theorem-prover: The shop3․theorem-prover package
Package, shop3.unifier: The shop3․unifier package
package-common.lisp: The shop3/common/package-common․lisp file
package-thpr.lisp: The shop3/theorem-prover/package-thpr․lisp file
package-unifier.lisp: The shop3/unifier/package-unifier․lisp file
package.lisp: The shop3/package․lisp file
package.lisp: The shop3/minimal-subtree/package․lisp file
pddl: The shop3/pddl module
pddl-action: Private types
pddl-domain: Public classes
pddl-typing-mixin: Public classes
pddl.lisp: The shop3/pddl/pddl․lisp file
plan-printer.lisp: The shop3/plan-printer․lisp file
plan-repair.lisp: The shop3/plan-repair․lisp file
plan-return: Private classes
plan-trajectory.lisp: The shop3/search/plan-trajectory․lisp file
plan-tree: The plan-tree package
plan-tree.lisp: The shop3/explicit-stack-search/plan-tree․lisp file
prepare-return-values: The prepare-return-values package
prepare-return-values.lisp: The shop3/explicit-stack-search/prepare-return-values․lisp file
prim-state-expand: Private classes
primitive-node: Private types
primitive-tree-node: Public structures
problem: Public classes
protections.lisp: The shop3/search/protections․lisp file
prover.lisp: The shop3/pddl/prover․lisp file
pseudo-node: Public structures
pure-logic-domain-mixin: Public classes

Q
quantified-preconditions-mixin: Public classes

R
raw-depend: Private structures
raw-depend-list: Private types
record-expansion: Private classes
record-expansion-for-replay: Private classes
replay-table-entry: Private structures

S
search: The shop3/search module
search-failed: Private conditions
search-state: Private classes
search.lisp: The shop3/search/search․lisp file
shop-asd: The shop-asd package
shop-condition: Private conditions
shop-error: Private conditions
shop-fiveam-tester: Private classes
shop-pprint.lisp: The shop3/io/shop-pprint․lisp file
shop-tester-mixin: Private classes
shop-variable: Public types
shop3: The shop3 system
shop3: The shop3 package
shop3-minimal-subtree: The shop3-minimal-subtree package
shop3-pprint: The shop3-pprint package
shop3-user: The shop3-user package
shop3.asd: The shop3/shop3․asd file
shop3.common: The shop3․common package
shop3.lisp: The shop3/shop3․lisp file
shop3.theorem-prover: The shop3․theorem-prover package
shop3.unifier: The shop3․unifier package
shop3/common: The shop3/common system
shop3/theorem-prover: The shop3/theorem-prover system
shop3/unifier: The shop3/unifier system
simple-pddl-domain: Public classes
singleton-variable: Public conditions
stack-entry: Private classes
state: Public structures
state-decls.lisp: The shop3/common/state-decls․lisp file
state-tag: Private classes
state-update: Private structures
state-utils.lisp: The shop3/common/state-utils․lisp file
static-predicates-mixin: Public classes
Structure, binding: Private structures
Structure, bit-state: Private structures
Structure, complex-tree-node: Public structures
Structure, dependency: Public structures
Structure, doubly-hashed-state: Private structures
Structure, hash-state: Private structures
Structure, list-state: Private structures
Structure, mixed-state: Private structures
Structure, ordered-tree-node: Public structures
Structure, primitive-tree-node: Public structures
Structure, pseudo-node: Public structures
Structure, raw-depend: Private structures
Structure, replay-table-entry: Private structures
Structure, state: Public structures
Structure, state-update: Private structures
Structure, tagged-state: Public structures
Structure, top-node: Public structures
Structure, tree-node: Public structures
Structure, unordered-tree-node: Public structures
System, shop3: The shop3 system
System, shop3/common: The shop3/common system
System, shop3/theorem-prover: The shop3/theorem-prover system
System, shop3/unifier: The shop3/unifier system

T
tagged-state: Public structures
tagged-state.lisp: The shop3/common/tagged-state․lisp file
task-arity-mismatch: Public conditions
task-reductions.lisp: The shop3/search/task-reductions․lisp file
tester-cl-source-file: Private classes
theorem-prover-condition: Public conditions
theorem-prover.lisp: The shop3/theorem-prover/theorem-prover․lisp file
thpr-domain: Public classes
top-node: Public structures
tracer.lisp: The shop3/unifier/tracer․lisp file
tree: The shop3/tree module
tree-accessors.lisp: The shop3/tree/tree-accessors․lisp file
tree-node: Public structures
tree-node: Private types
tree-reductions.lisp: The shop3/tree/tree-reductions․lisp file
Type, action-type: Private types
Type, binding-list: Public types
Type, complex-node: Private types
Type, divergence-list: Private types
Type, list-raw-depend-lists: Private types
Type, operator: Private types
Type, pddl-action: Private types
Type, primitive-node: Private types
Type, raw-depend-list: Private types
Type, shop-variable: Public types
Type, tree-node: Private types
Type, values!: Private types

U
unify.lisp: The shop3/unifier/unify․lisp file
universal-preconditions-mixin: Public classes
unordered-tree-node: Public structures

V
values!: Private types