This is the shop3 Reference Manual, version 3.10.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Nov 06 14:53:13 2023 GMT+0.
shop3/shop3.asd
shop3/package.lisp
shop3/decls.lisp
shop3/io/input.lisp
shop3/io/output.lisp
shop3/io/debugging.lisp
shop3/io/shop-pprint.lisp
shop3/pddl/decls.lisp
shop3/pddl/fluents.lisp
shop3/pddl/pddl.lisp
shop3/pddl/prover.lisp
shop3/search/protections.lisp
shop3/search/task-reductions.lisp
shop3/search/search.lisp
shop3/search/plan-trajectory.lisp
shop3/explicit-stack-search/plan-tree.lisp
shop3/explicit-stack-search/decls.lisp
shop3/explicit-stack-search/prepare-return-values.lisp
shop3/explicit-stack-search/backtrack-stack.lisp
shop3/explicit-stack-search/analogical-replay.lisp
shop3/explicit-stack-search/explicit-search.lisp
shop3/looping-tasks/loop-extensions.lisp
shop3/tree/tree-accessors.lisp
shop3/tree/tree-reductions.lisp
shop3/minimal-subtree/package.lisp
shop3/minimal-subtree/decls.lisp
shop3/minimal-subtree/minimal-subtree.lisp
shop3/plan-repair.lisp
shop3/shop3.lisp
shop3/plan-printer.lisp
shop3/common/package-common.lisp
shop3/common/common.lisp
shop3/common/state-decls.lisp
shop3/common/state-utils.lisp
shop3/common/tagged-state.lisp
shop3/unifier/package-unifier.lisp
shop3/unifier/tracer.lisp
shop3/unifier/unify.lisp
shop3/theorem-prover/package-thpr.lisp
shop3/theorem-prover/decls.lisp
shop3/theorem-prover/theorem-prover.lisp
The main system appears first, followed by any subsystem dependency.
shop3
Mozilla Public License
3.10.0
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).
package.lisp
(file).
decls.lisp
(file).
io
(module).
pddl
(module).
search
(module).
explicit-stack-search
(module).
looping-tasks
(module).
tree
(module).
minimal-subtree
(module).
plan-repair.lisp
(file).
shop3.lisp
(file).
plan-printer.lisp
(file).
shop3/common
Mozilla Public License
3.10.0
shop3/unifier
(system).
iterate
(system).
alexandria
(system).
package-common.lisp
(file).
common.lisp
(file).
state-decls.lisp
(file).
state-utils.lisp
(file).
tagged-state.lisp
(file).
shop3/unifier
Mozilla Public License
3.10.0
alexandria
(system).
package-unifier.lisp
(file).
tracer.lisp
(file).
unify.lisp
(file).
shop3/theorem-prover
Mozilla Public License
3.10.0
shop3/common
(system).
shop3/unifier
(system).
package-thpr.lisp
(file).
decls.lisp
(file).
theorem-prover.lisp
(file).
Modules are listed depth-first from the system components tree.
shop3/io
shop3/pddl
shop3/search
shop3/explicit-stack-search
shop3/looping-tasks
shop3/tree
shop3/minimal-subtree
shop3/io
decls.lisp
(file).
shop3
(system).
input.lisp
(file).
output.lisp
(file).
debugging.lisp
(file).
shop-pprint.lisp
(file).
shop3/pddl
io
(module).
shop3
(system).
decls.lisp
(file).
fluents.lisp
(file).
pddl.lisp
(file).
prover.lisp
(file).
shop3/search
pddl
(module).
shop3
(system).
protections.lisp
(file).
task-reductions.lisp
(file).
search.lisp
(file).
plan-trajectory.lisp
(file).
shop3/explicit-stack-search
search
(module).
shop3
(system).
plan-tree.lisp
(file).
decls.lisp
(file).
prepare-return-values.lisp
(file).
backtrack-stack.lisp
(file).
analogical-replay.lisp
(file).
explicit-search.lisp
(file).
shop3/looping-tasks
explicit-stack-search
(module).
shop3
(system).
loop-extensions.lisp
(file).
shop3/tree
looping-tasks
(module).
shop3
(system).
tree-accessors.lisp
(file).
tree-reductions.lisp
(file).
shop3/minimal-subtree
When there’s an upset in plan execution, find a minimal affected subtree.
tree
(module).
shop3
(system).
package.lisp
(file).
decls.lisp
(file).
minimal-subtree.lisp
(file).
Files are sorted by type and then listed depth-first from the systems components trees.
shop3/shop3.asd
shop3/package.lisp
shop3/decls.lisp
shop3/io/input.lisp
shop3/io/output.lisp
shop3/io/debugging.lisp
shop3/io/shop-pprint.lisp
shop3/pddl/decls.lisp
shop3/pddl/fluents.lisp
shop3/pddl/pddl.lisp
shop3/pddl/prover.lisp
shop3/search/protections.lisp
shop3/search/task-reductions.lisp
shop3/search/search.lisp
shop3/search/plan-trajectory.lisp
shop3/explicit-stack-search/plan-tree.lisp
shop3/explicit-stack-search/decls.lisp
shop3/explicit-stack-search/prepare-return-values.lisp
shop3/explicit-stack-search/backtrack-stack.lisp
shop3/explicit-stack-search/analogical-replay.lisp
shop3/explicit-stack-search/explicit-search.lisp
shop3/looping-tasks/loop-extensions.lisp
shop3/tree/tree-accessors.lisp
shop3/tree/tree-reductions.lisp
shop3/minimal-subtree/package.lisp
shop3/minimal-subtree/decls.lisp
shop3/minimal-subtree/minimal-subtree.lisp
shop3/plan-repair.lisp
shop3/shop3.lisp
shop3/plan-printer.lisp
shop3/common/package-common.lisp
shop3/common/common.lisp
shop3/common/state-decls.lisp
shop3/common/state-utils.lisp
shop3/common/tagged-state.lisp
shop3/unifier/package-unifier.lisp
shop3/unifier/tracer.lisp
shop3/unifier/unify.lisp
shop3/theorem-prover/package-thpr.lisp
shop3/theorem-prover/decls.lisp
shop3/theorem-prover/theorem-prover.lisp
shop3/shop3.asd
shop3
(system).
operation-done-p
(method).
shop-fiveam-tester
(class).
shop-tester-mixin
(class).
tester-cl-source-file
(class).
shop3/decls.lisp
package.lisp
(file).
shop3
(system).
*which*
(special variable).
apply-operator
(generic function).
call
(macro).
copy-shop-problem
(generic function).
delete-problem
(generic function).
domain
(class).
domain-methods
(generic function).
domain-name
(method).
domain-name
(reader method).
domain-operators
(generic function).
find-problem
(function).
get-state
(generic function).
get-tasks
(generic function).
handle-domain-options
(generic function).
make-load-form
(method).
methods
(generic function).
name
(reader method).
no-method-for-task
(condition).
parse-domain-items
(generic function).
print-object
(method).
print-object
(method).
problem
(class).
problem-name
(reader method).
process-method
(generic function).
process-op
(generic function).
process-operator
(generic function).
pure-logic-domain-mixin
(class).
seek-plans-null
(generic function).
seek-plans-primitive
(generic function).
singleton-variable
(condition).
sort-methods
(generic function).
sort-results
(generic function).
sort-tasks
(generic function).
state-atoms
(reader method).
task-arity-mismatch
(condition).
task-sorter
(generic function).
*all-problems*
(special variable).
*analogical-replay*
(special variable).
*back-quote-name*
(special variable).
*before-extract-trees-hook*
(special variable).
*break-on-backtrack*
(special variable).
*collect-state*
(special variable).
*current-plan*
(special variable).
*current-tasks*
(special variable).
*depth-cutoff*
(special variable).
*expansions*
(special variable).
*explanation*
(special variable).
*gc*
(special variable).
*hand-steer*
(special variable).
*internal-time-limit*
(special variable).
*internal-time-tag*
(special variable).
*leashed*
(special variable).
*make-analogy-table*
(special variable).
*more-tasks-p*
(special variable).
*old-depth*
(special variable).
*operator-tasks*
(special variable).
*optimal-cost*
(special variable).
*optimal-plan*
(special variable).
*optimize-cost*
(special variable).
*plan-num-limit*
(special variable).
*plan-tree*
(special variable).
*plans-found*
(special variable).
*pp*
(special variable).
*print-plans*
(special variable).
*print-stats*
(special variable).
*problem*
(special variable).
*protections*
(special variable).
*pshort*
(special variable).
*shop-pprint-table*
(special variable).
*shop-version*
(special variable).
*states-found*
(special variable).
*subtask-parents*
(special variable).
*task-operator*
(special variable).
*tasklist*
(special variable).
*time-limit*
(special variable).
*unifiers-found*
(special variable).
*unique-method-names*
(special variable).
*verbose*
(special variable).
+method-definition-keywords+
(special variable).
actions-domain-mixin
(class).
apply-method
(generic function).
assign-domain-method-id
(generic function).
branch-number
(reader method).
catch-internal-time
(macro).
construct
(reader method).
construct-name
(reader method).
construct-type
(reader method).
defconstant
(macro).
domain-id-for-method-lookup
(generic function).
domain-item-parse-warning
(condition).
domain-items
(generic function).
domain-method-id-lookup
(generic function).
domain-method-to-name-table
(reader method).
domain-name-to-method-table
(reader method).
domain-parse-error
(condition).
domain-parse-warning
(condition).
domain-style-warning
(condition).
implicit-conjunction-warning
(condition).
initialize-problem
(generic function).
install-domain
(generic function).
make-operator
(function).
method-definition-keywords
(generic function).
method-head
(generic function).
method-name
(generic function).
method-p
(generic function).
method-preconditions
(generic function).
method-task
(generic function).
method-task-net
(generic function).
non-unique-method-name-error
(condition).
non-unique-method-name-mixin
(condition).
non-unique-method-name-warning
(condition).
nshuffle-array
(function).
nshuffle-list
(function).
old-name
(reader method).
operator
(generic function).
operator
(type).
operator-additions
(function).
(setf operator-additions)
(function).
operator-cost-fun
(function).
(setf operator-cost-fun)
(function).
operator-deletions
(function).
(setf operator-deletions)
(function).
operator-head
(function).
(setf operator-head)
(function).
operator-name
(function).
operator-p
(function).
operator-preconditions
(function).
(setf operator-preconditions)
(function).
operators-dont-fail
(reader method).
parse-domain-item
(generic function).
pddl-action
(type).
pddl-plan
(generic function).
plan-cost
(generic function).
primitivep
(function).
problem->state
(generic function).
problem-state
(generic function).
problem-tasks
(generic function).
process-add-or-delete
(generic function).
process-method-pre
(generic function).
process-pre
(generic function).
push-last
(macro).
quotify
(function).
randomize-list
(function).
regularize-axiom
(generic function).
report-no-method
(function).
report-task-arity-mismatch
(function).
seek-plans
(generic function).
seek-plans-nonprimitive
(generic function).
seek-plans-task
(generic function).
shop-condition
(condition).
shop-error
(condition).
simple-backquote
(macro).
task
(reader method).
task-arity-mismatch-library-entry
(reader method).
task-arity-mismatch-library-task
(reader method).
task-arity-mismatch-task
(reader method).
tasks
(reader method).
values!
(type).
variable-names
(reader method).
shop3/io/input.lisp
io
(module).
*defdomain-verbose*
(special variable).
*define-silently*
(special variable).
def-problem-set
(macro).
defdomain
(macro).
defproblem
(macro).
delete-domain
(generic function).
do-problems
(function).
find-domain
(function).
get-problems
(function).
handle-domain-options
(method).
make-problem
(function).
make-problem-set
(function).
parse-domain-items
(method).
process-axiom
(function).
process-method
(method).
process-method
(method).
process-op
(method).
process-operator
(method).
query
(method).
set-domain
(function).
%new-method-id
(function).
*all-method-names*
(special variable).
*defdomain-pathname*
(special variable).
*ignore-singleton-variables*
(special variable).
check-for-singletons
(function).
count-method-branches
(function).
domain-include-parse
(generic function).
domain-include-search
(function).
expand-include
(function).
expand-includes
(function).
extract-method-id
(function).
filter-singletons
(function).
get-method-name
(function).
harvest-variables
(function).
index-method-on-domain
(function).
initialize-problem
(method).
install-domain
(method).
make-domain
(function).
method-expression-body
(generic function).
method-expression-task
(generic function).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
problem->state
(method).
process-add-or-delete
(method).
process-method-pre
(method).
process-pre
(method).
process-task-list
(function).
regularize-axiom
(method).
rest-shop2-axiom-p
(function).
search-tree
(function).
shop2-axiom-p
(function).
translate-include
(function).
with-method-name-table
(macro).
shop3/io/output.lisp
io
(module).
print-current-state
(function).
backtrack
(function).
determine-verbosity
(function).
indented-format
(function).
plan-cost
(method).
print-current-plan
(function).
print-current-tasks
(function).
print-output-file
(function).
print-stats
(function).
print-stats-header
(function).
print1
(function).
query-current-state
(function).
to-string
(function).
shop3/io/debugging.lisp
io
(module).
print-methods
(function).
print-operators
(function).
shop-trace
(macro).
shop-trace-info
(function).
shop-untrace
(macro).
trigger-trace
(method).
trigger-trace
(method).
trigger-trace
(method).
trigger-trace
(method).
*start-real-time*
(special variable).
*start-run-time*
(special variable).
*traced-axioms*
(special variable).
*traced-goals*
(special variable).
*traced-methods*
(special variable).
*traced-tasks*
(special variable).
+shop-trace-items+
(constant).
print-operator
(function).
shop-trace-1
(function).
shop-untrace-1
(function).
shop-untrace-all
(function).
shop3/io/shop-pprint.lisp
io
(module).
axiom-sexp-p
(function).
method-printer
(function).
method-sexp-p
(function).
op-sexp-p
(function).
operator-printer
(function).
operator-sexp-p
(function).
pprint-preconds
(function).
pprint-task-net
(function).
print-list-on-lines
(function).
print-list-suffix-lines
(function).
shop3/pddl/decls.lisp
pddl
(module).
+pddl-requirements-keywords+
(special variable).
shop3/pddl/fluents.lisp
decls.lisp
(file).
pddl
(module).
+binary-numerical-operators+
(special variable).
+numerical-comparisons+
(special variable).
fluent-comparison-p
(generic function).
fluent-expr-p
(generic function).
fluent-function-p
(generic function).
fluent-functions
(reader method).
fluents-mixin
(class).
shop3/pddl/pddl.lisp
fluents.lisp
(file).
pddl
(module).
adl-domain
(class).
adl-mixin
(class).
conditional-effects-mixin
(class).
costs-mixin
(class).
disjunctive-preconditions-mixin
(class).
equality-mixin
(class).
existential-preconditions-mixin
(class).
make-initial-state
(method).
negative-preconditions-mixin
(class).
parse-domain-items
(method).
parse-domain-items
(method).
parse-domain-items
(method).
pddl-domain
(class).
pddl-typing-mixin
(class).
quantified-preconditions-mixin
(class).
simple-pddl-domain
(class).
source-pddl-domain
(reader method).
universal-preconditions-mixin
(class).
validate-plan
(function).
validator-export
(generic function).
write-pddl-plan
(function).
*validator-progname*
(special variable).
+fluent-updates+
(special variable).
apply-action
(function).
compute-fluent-updates
(function).
domain-include-parse
(method).
extract-adds-and-deletes
(function).
make-pddl-action
(function).
method-name
(method).
method-p
(method).
of-type-exprs
(function).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-domain-item
(method).
parse-pddl-method
(function).
parse-typed-list
(function).
pddl-action-cost-fun
(function).
(setf pddl-action-cost-fun)
(function).
pddl-action-effect
(function).
(setf pddl-action-effect)
(function).
pddl-action-head
(function).
(setf pddl-action-head)
(function).
pddl-action-name
(function).
pddl-action-p
(function).
pddl-action-precondition
(function).
(setf pddl-action-precondition)
(function).
pddl-method-p
(generic function).
pddl-plan
(method).
pddl-types
(reader method).
(setf pddl-types)
(writer method).
process-action
(generic function).
process-method-pre
(method).
process-pddl-method-pre
(function).
translate-effect
(generic function).
translate-fluent-precond
(function).
translate-metric-updates
(function).
translate-pddl-quantifier
(function).
translate-precondition
(generic function).
typed-list-vars
(function).
shop3/pddl/prover.lisp
pddl.lisp
(file).
pddl
(module).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
pddl-satisfiers-for-exists
(function).
pddl-satisfiers-for-f-exp
(function).
pddl-satisfiers-for-forall
(function).
pddl-satisfiers-for-imply
(function).
pddl-satisfiers-for-not
(function).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
vars-boundp
(function).
shop3/search/protections.lisp
search
(module).
add-protection
(function).
delete-protection
(function).
protection-ok
(function).
shop3/search/task-reductions.lisp
search
(module).
apply-operator
(method).
internal-operator-p
(function).
already-immediate-p
(function).
apply-method
(method).
copy-task-tree
(function).
delete-protections
(function).
delete-task-main-list
(function).
delete-task-top-list
(function).
find-next-main-list
(function).
force-immediate
(function).
force-immediate-reduction
(function).
force-immediate-unordered
(function).
get-task-body
(function).
get-task-name
(function).
get-top-tasks
(function).
process-add-list
(function).
process-delete-list
(function).
replace-task-main-list
(function).
replace-task-top-list
(function).
strip-nops
(function).
well-formed-listp
(function).
shop3/search/search.lisp
search
(module).
remove-costs
(function).
seek-plans-null
(method).
seek-plans-primitive
(method).
shorter-plan
(function).
acceptable-cost-p
(function).
apply-method-bindings
(function).
choose-immediate-task
(function).
dump-higher-cost-plans!
(function).
dump-previous-plans!
(function).
get-immediate-list
(function).
optimize-continue-p
(function).
seek-plans
(method).
seek-plans-nonprimitive
(method).
seek-plans-primitive-1
(function).
seek-plans-task
(method).
store-plan!
(generic function).
time-expired-p
(function).
user-choose-task
(function).
when-done
(macro).
shop3/search/plan-trajectory.lisp
search
(module).
plan-final-state
(function).
plan-states
(function).
shop3/explicit-stack-search/plan-tree.lisp
explicit-stack-search
(module).
complex-tree-node
(structure).
complex-tree-node-children
(reader).
(setf complex-tree-node-children)
(writer).
complex-tree-node-method-name
(reader).
(setf complex-tree-node-method-name)
(writer).
consumer
(reader).
(setf consumer)
(writer).
copy-plan-tree
(function).
dependency
(structure).
establisher
(reader).
(setf establisher)
(writer).
find-plan-step
(function).
find-task-in-tree
(function).
find-tree-node-if
(function).
make-complex-tree-node
(function).
make-dependency
(function).
make-load-form
(method).
make-ordered-tree-node
(function).
make-primitive-tree-node
(function).
make-top-node
(function).
make-unordered-tree-node
(function).
ordered-tree-node
(structure).
plan-tree->sexp
(generic function).
primitive-tree-node
(structure).
print-object
(method).
print-object
(method).
print-object
(method).
print-object
(method).
print-object
(method).
print-object
(method).
prop
(reader).
(setf prop)
(writer).
pseudo-node
(structure).
top-node
(structure).
tree-node
(structure).
tree-node-dependencies
(reader).
(setf tree-node-dependencies)
(writer).
tree-node-expanded-task
(reader).
(setf tree-node-expanded-task)
(writer).
tree-node-parent
(reader).
(setf tree-node-parent)
(writer).
tree-node-task
(reader).
(setf tree-node-task)
(writer).
unordered-tree-node
(structure).
*node-list*
(special variable).
*table-for-load-form*
(special variable).
complex-tree-node-dependencies
(function).
(setf complex-tree-node-dependencies)
(function).
complex-tree-node-expanded-task
(function).
(setf complex-tree-node-expanded-task)
(function).
complex-tree-node-p
(function).
complex-tree-node-parent
(function).
(setf complex-tree-node-parent)
(function).
complex-tree-node-task
(function).
(setf complex-tree-node-task)
(function).
copy-complex-tree-node
(function).
copy-dependency
(function).
copy-ordered-tree-node
(function).
copy-plan-tree-node
(generic function).
copy-primitive-tree-node
(function).
copy-pseudo-node
(function).
copy-top-node
(function).
copy-tree-node
(function).
copy-unordered-tree-node
(function).
cross-links-for
(generic function).
dependency-p
(function).
insert-if-necessary
(function).
make-cross-links
(function).
make-instantiator
(generic function).
make-pseudo-node
(function).
make-table-entries
(generic function).
make-tree-node
(function).
obj-bindings
(function).
ordered-tree-node-children
(function).
(setf ordered-tree-node-children)
(function).
ordered-tree-node-dependencies
(function).
(setf ordered-tree-node-dependencies)
(function).
ordered-tree-node-expanded-task
(function).
(setf ordered-tree-node-expanded-task)
(function).
ordered-tree-node-method-name
(function).
(setf ordered-tree-node-method-name)
(function).
ordered-tree-node-p
(function).
ordered-tree-node-parent
(function).
(setf ordered-tree-node-parent)
(function).
ordered-tree-node-task
(function).
(setf ordered-tree-node-task)
(function).
primitive-tree-node-dependencies
(function).
(setf primitive-tree-node-dependencies)
(function).
primitive-tree-node-expanded-task
(function).
(setf primitive-tree-node-expanded-task)
(function).
primitive-tree-node-p
(function).
primitive-tree-node-parent
(function).
(setf primitive-tree-node-parent)
(function).
primitive-tree-node-task
(function).
(setf primitive-tree-node-task)
(function).
print-unreadably
(macro).
pseudo-node-children
(function).
(setf pseudo-node-children)
(function).
pseudo-node-dependencies
(function).
(setf pseudo-node-dependencies)
(function).
pseudo-node-expanded-task
(function).
(setf pseudo-node-expanded-task)
(function).
pseudo-node-method-name
(function).
(setf pseudo-node-method-name)
(function).
pseudo-node-p
(function).
pseudo-node-parent
(function).
(setf pseudo-node-parent)
(function).
pseudo-node-task
(function).
(setf pseudo-node-task)
(function).
slot-fillers
(generic function).
slot-value-translator
(function).
top-node-children
(function).
(setf top-node-children)
(function).
top-node-dependencies
(function).
(setf top-node-dependencies)
(function).
top-node-expanded-task
(function).
(setf top-node-expanded-task)
(function).
top-node-lookup-table
(reader).
(setf top-node-lookup-table)
(writer).
top-node-method-name
(function).
(setf top-node-method-name)
(function).
top-node-p
(function).
top-node-parent
(function).
(setf top-node-parent)
(function).
top-node-task
(function).
(setf top-node-task)
(function).
tree-node-p
(function).
unordered-tree-node-children
(function).
(setf unordered-tree-node-children)
(function).
unordered-tree-node-dependencies
(function).
(setf unordered-tree-node-dependencies)
(function).
unordered-tree-node-expanded-task
(function).
(setf unordered-tree-node-expanded-task)
(function).
unordered-tree-node-method-name
(function).
(setf unordered-tree-node-method-name)
(function).
unordered-tree-node-p
(function).
unordered-tree-node-parent
(function).
(setf unordered-tree-node-parent)
(function).
unordered-tree-node-task
(function).
(setf unordered-tree-node-task)
(function).
shop3/explicit-stack-search/decls.lisp
plan-tree.lisp
(file).
explicit-stack-search
(module).
state
(reader method).
(setf state)
(writer method).
alternatives
(reader method).
(setf alternatives)
(writer method).
appendf
(macro).
backtrack-stack
(reader method).
(setf backtrack-stack)
(writer method).
cost
(reader method).
(setf cost)
(writer method).
current-task
(reader method).
(setf current-task)
(writer method).
depth
(reader method).
(setf depth)
(writer method).
lookup-table
(reader method).
mode
(reader method).
(setf mode)
(writer method).
partial-plan
(reader method).
(setf partial-plan)
(writer method).
plan
(reader method).
plan-cost
(method).
plan-return
(class).
plan-tree
(reader method).
plan-tree-lookup
(reader method).
plans-found
(reader method).
(setf plans-found)
(writer method).
protections
(reader method).
(setf protections)
(writer method).
replay-table
(reader method).
search-failed
(condition).
search-state
(reader method).
search-state
(class).
tasks
(reader method).
(setf tasks)
(writer method).
top-tasks
(reader method).
(setf top-tasks)
(writer method).
tree
(reader method).
unifier
(reader method).
(setf unifier)
(writer method).
verbose-format
(macro).
world-state
(reader method).
world-state
(reader method).
(setf world-state)
(writer method).
shop3/explicit-stack-search/prepare-return-values.lisp
decls.lisp
(file).
explicit-stack-search
(module).
prepare-return-values
(function).
phase-one
(function).
translate-child-links
(function).
translate-dependency-links
(function).
translate-lookup-table
(function).
shop3/explicit-stack-search/backtrack-stack.lisp
prepare-return-values.lisp
(file).
explicit-stack-search
(module).
print-object
(method).
add-child-to-tree
(class).
add-dependencies
(class).
alternatives
(reader method).
bottom-of-stack
(class).
child
(reader method).
choice-entry
(class).
current-task
(reader method).
dependencies
(reader method).
do-backtrack
(generic function).
make-add-child-to-tree
(function).
make-add-dependencies
(function).
make-cs-state
(function).
make-method-instantiation
(function).
make-prim-state-expand
(function).
make-record-expansion
(function).
make-record-expansion-for-replay
(function).
make-world-state-tag
(function).
method-id
(reader method).
method-instantiation
(class).
mode
(reader method).
parent
(reader method).
partial-plan
(reader method).
partial-plan-cost
(reader method).
prim-state-expand
(class).
protections
(reader method).
record-expansion
(class).
record-expansion-for-replay
(class).
stack-constructor
(macro).
stack-entry
(class).
state-tag
(class).
tag
(reader method).
task
(reader method).
tasks
(reader method).
tasks
(reader method).
top-tasks
(reader method).
top-tasks
(reader method).
tree-node
(reader method).
unifier
(reader method).
unifier
(reader method).
shop3/explicit-stack-search/analogical-replay.lisp
backtrack-stack.lisp
(file).
explicit-stack-search
(module).
%delete-a-decomposition
(generic function).
%record-a-decomposition
(generic function).
%update-singleton
(generic function).
*analogical-replay-table*
(special variable).
clear-replay-table
(generic function).
copy-replay-table-entry
(function).
find-decompositions
(generic function).
guidance
(generic function).
make-replay-table-entry
(function).
record-decomposition
(generic function).
replay-table-entry
(structure).
replay-table-entry-alist
(reader).
(setf replay-table-entry-alist)
(writer).
replay-table-entry-p
(function).
replay-table-entry-singleton
(reader).
(setf replay-table-entry-singleton)
(writer).
shop3/explicit-stack-search/explicit-search.lisp
analogical-replay.lisp
(file).
explicit-stack-search
(module).
find-plans-stack
(function).
sort-methods
(method).
*enhanced-plan-tree*
(special variable).
*include-rationale*
(special variable).
*no-dependencies*
(special variable).
apply-substitution-to-tree
(function).
choose-immediate-task-state
(function).
choose-method-bindings-state
(function).
choose-method-state
(function).
choose-toplevel-task
(function).
empty-p
(function).
expand-primitive-state
(generic function).
immediate-tasks
(function).
make-dependencies
(function).
make-plan-copy
(function).
make-plan-return
(generic function).
make-plan-tree-for-task-net
(function).
plan-returns
(function).
populate-plan-return
(function).
prepare-choose-immediate-task-state
(function).
record-node-expansion
(function).
remove-subtree-from-table
(function).
seek-plans-stack
(function).
stack-backjump
(function).
stack-backtrack
(function).
strip-task-sexp
(function).
test-plan-found
(function).
unfold-loop-task
(generic function).
shop3/looping-tasks/loop-extensions.lisp
looping-tasks
(module).
do-backtrack
(method).
expand-loop
(method).
expand-loop
(method).
expand-loop-body
(method).
expand-loop-body
(method).
expand-loop-body
(method).
generate-reductions
(function).
loop-body-item
(function).
loop-body-item-inner
(function).
loop-item
(function).
loop-state-expand
(class).
looping-domain
(class).
looping-p
(function).
make-loop-state-expand
(function).
new-symbol
(function).
rename-sym
(function).
resymbol-task
(function).
seek-plans-loop
(method).
seek-plans-task
(method).
tasks
(reader method).
top-tasks
(reader method).
unfold-loop-task
(method).
unifier
(reader method).
shop3/tree/tree-accessors.lisp
tree
(module).
all-primitive-nodes
(function).
complex-node-children
(function).
(setf complex-node-children)
(function).
complex-node-p
(function).
complex-node-task
(function).
(setf complex-node-task)
(function).
copy-plan-tree
(function).
find-all-complex-node-for-task
(function).
find-all-complex-node-if
(function).
find-all-primitive-nodes-if
(function).
find-complex-node-for-task
(function).
find-complex-node-if
(function).
find-primitive-node-for-task
(function).
find-primitive-node-if
(function).
make-complex-node
(function).
node-parent
(function).
primitive-node-cost
(function).
(setf primitive-node-cost)
(function).
primitive-node-p
(function).
primitive-node-position
(function).
(setf primitive-node-position)
(function).
primitive-node-task
(function).
(setf primitive-node-task)
(function).
remove-internal-operators
(function).
task-name
(function).
(setf tree-node-task)
(setf expander).
tree-node-task
(function).
tree-node-task-name
(function).
canonically-order
(function).
complex-node
(type).
make-primitive-node
(function).
min-start
(function).
primitive-node
(type).
task-args
(function).
tree-compare
(function).
tree-node
(type).
shop3/tree/tree-reductions.lisp
tree-accessors.lisp
(file).
tree
(module).
*node-children-table*
(special variable).
all-roots
(function).
create-node-children-table
(function).
decode-task
(function).
extend-plan-tree-nodes
(function).
extract-subtasks
(function).
extract-subtree
(function).
extract-tree
(function).
make-operator-task-table
(function).
make-subtask-parents-table
(function).
node-children
(function).
operator-task
(function).
plan-operator-nodes
(function).
plan-tree-nodes
(function).
record-operator
(function).
record-reduction
(function).
strip-tree-tags
(function).
shop3/minimal-subtree/package.lisp
minimal-subtree
(module).
shop3/minimal-subtree/decls.lisp
package.lisp
(file).
minimal-subtree
(module).
find-failed-task
(generic function).
shop3/minimal-subtree/minimal-subtree.lisp
decls.lisp
(file).
minimal-subtree
(module).
find-failed-task
(method).
find-failed-task
(method).
find-failed-task
(method).
clobbered-p
(function).
find-adder
(function).
find-checking-path
(function).
find-deleter
(function).
find-plan-suffix
(function).
leftmost-p
(function).
shop3/plan-repair.lisp
tree
(module).
explicit-stack-search
(module).
minimal-subtree
(module).
shop3
(system).
repair-plan
(function).
divergence-list
(type).
divergence-list-p
(function).
divergence-op-p
(function).
extract-suffix
(function).
find-failed-choice-entry
(generic function).
find-failed-stack-entry
(generic function).
freeze-state
(function).
no-failed-task
(condition).
replan-from-failure
(function).
shop3/shop3.lisp
plan-repair.lisp
(file).
shop3
(system).
find-plans
(function).
+shopyright+
(constant).
extract-trees
(function).
find-plans-1
(function).
id-search
(function).
shop3/plan-printer.lisp
package.lisp
(file).
decls.lisp
(file).
shop3.lisp
(file).
shop3
(system).
pprint-plan
(function).
pprint-step
(function).
shop3/common/common.lisp
package-common.lisp
(file).
shop3/common
(system).
*attribution-list*
(special variable).
*current-state*
(special variable).
*external-access*
(special variable).
*inferences*
(special variable).
*state-encoding*
(special variable).
shop-fail
(macro).
shop3/common/state-decls.lisp
common.lisp
(file).
shop3/common
(system).
add-atom-to-state
(generic function).
copy-state
(generic function).
delete-atom-from-state
(generic function).
last-establisher
(generic function).
make-initial-state
(generic function).
replay-state-changes
(generic function).
retract-state-changes
(generic function).
state
(structure).
state->state-type
(generic function).
state-all-atoms-for-predicate
(generic function).
state-atoms
(generic function).
state-candidate-atoms-for-goal
(generic function).
state-trajectory
(generic function).
tag-state
(generic function).
tagged-state
(structure).
%make-bit-state
(function).
*action-to-tag-map*
(special variable).
*state-tag-map*
(special variable).
action-type
(type).
atom-in-state-p
(generic function).
bit-state
(structure).
bit-state-block-at
(function).
(setf bit-state-block-at)
(function).
bit-state-body
(function).
(setf bit-state-body)
(function).
bit-state-p
(function).
bit-state-tags-info
(function).
(setf bit-state-tags-info)
(function).
copy-state-update
(function).
domain-core
(class).
doubly-hashed-state
(structure).
doubly-hashed-state-block-at
(function).
(setf doubly-hashed-state-block-at)
(function).
doubly-hashed-state-body
(function).
(setf doubly-hashed-state-body)
(function).
doubly-hashed-state-p
(function).
doubly-hashed-state-tags-info
(function).
(setf doubly-hashed-state-tags-info)
(function).
hash-state
(structure).
hash-state-block-at
(function).
(setf hash-state-block-at)
(function).
hash-state-body
(function).
(setf hash-state-body)
(function).
hash-state-p
(function).
hash-state-tags-info
(function).
(setf hash-state-tags-info)
(function).
include-in-tag
(generic function).
insert-atom
(generic function).
list-state
(structure).
list-state-block-at
(function).
(setf list-state-block-at)
(function).
list-state-body
(function).
(setf list-state-body)
(function).
list-state-p
(function).
list-state-tags-info
(function).
(setf list-state-tags-info)
(function).
make-state-update
(function).
makedoubly-hashedstate
(function).
makehashstate
(function).
makeliststate
(function).
makemixedstate
(function).
mixed-state
(structure).
mixed-state-block-at
(function).
(setf mixed-state-block-at)
(function).
mixed-state-body
(function).
(setf mixed-state-body)
(function).
mixed-state-p
(function).
mixed-state-tags-info
(function).
(setf mixed-state-tags-info)
(function).
redo-state-update
(generic function).
remove-atom
(generic function).
state-body
(reader).
(setf state-body)
(writer).
state-p
(function).
state-update
(structure).
state-update-action
(reader).
(setf state-update-action)
(writer).
state-update-literal
(reader).
(setf state-update-literal)
(writer).
state-update-p
(function).
tagged-state-block-at
(reader).
(setf tagged-state-block-at)
(writer).
tagged-state-body
(function).
(setf tagged-state-body)
(function).
tagged-state-p
(function).
tagged-state-tags-info
(reader).
(setf tagged-state-tags-info)
(writer).
undo-state-update
(generic function).
shop3/common/state-utils.lisp
state-decls.lisp
(file).
shop3/common
(system).
copy-state
(method).
copy-state
(method).
copy-state
(method).
copy-state
(method).
copy-state
(method).
make-initial-state
(method).
make-initial-state
(method).
make-initial-state
(method).
make-initial-state
(method).
make-initial-state
(method).
print-object
(method).
prop-sorter
(function).
state->state-type
(method).
state->state-type
(method).
state->state-type
(method).
state->state-type
(method).
state->state-type
(method).
state-all-atoms-for-predicate
(method).
state-all-atoms-for-predicate
(method).
state-all-atoms-for-predicate
(method).
state-all-atoms-for-predicate
(method).
state-all-atoms-for-predicate
(method).
state-atoms
(method).
state-atoms
(method).
state-atoms
(method).
state-atoms
(method).
state-atoms
(method).
state-candidate-atoms-for-goal
(method).
state-candidate-atoms-for-goal
(method).
state-candidate-atoms-for-goal
(method).
state-candidate-atoms-for-goal
(method).
state-candidate-atoms-for-goal
(method).
state-trajectory
(method).
+singleton-term+
(constant).
+variable-term+
(constant).
atom-in-state-p
(method).
atom-in-state-p
(method).
atom-in-state-p
(method).
atom-in-state-p
(method).
atom-in-state-p
(method).
bit-statebody-increment-position
(function).
bit-statebody-search-array
(function).
copy-hash-table
(function).
insert-atom
(method).
insert-atom
(method).
insert-atom
(method).
insert-atom
(method).
insert-atom
(method).
list-insert-atom-into-statebody
(function).
list-remove-atom-from-statebody
(function).
make-bit-state
(function).
make-doubly-hashed-state
(function).
make-hash-state
(function).
make-list-state
(function).
make-mixed-state
(function).
remove-atom
(method).
remove-atom
(method).
remove-atom
(method).
remove-atom
(method).
remove-atom
(method).
shop3/common/tagged-state.lisp
state-utils.lisp
(file).
shop3/common
(system).
add-atom-to-state
(method).
decode-tag
(function).
delete-atom-from-state
(method).
delete-state-tag-decoder
(function).
delete-tag-map
(function).
last-establisher
(method).
make-tag-map
(function).
prepare-state-tag-decoder
(function).
replay-state-changes
(method).
retract-state-changes
(method).
tag-for-action
(function).
tag-state
(method).
include-in-tag
(method).
pull-tag-info
(function).
redo-state-update
(method).
redo-state-update
(method).
redo-state-update
(method).
redo-state-update
(method).
tagged-state-tags-info-tag
(function).
undo-state-update
(method).
undo-state-update
(method).
undo-state-update
(method).
undo-state-update
(method).
shop3/unifier/tracer.lisp
package-unifier.lisp
(file).
shop3/unifier
(system).
*shop-trace*
(special variable).
*shop-trace-stream*
(special variable).
*trace-query*
(special variable).
trace-print
(macro).
trigger-trace
(generic function).
shop3/unifier/unify.lisp
tracer.lisp
(file).
shop3/unifier
(system).
anonymous-var-p
(function).
apply-substitution
(macro).
binding-list
(type).
binding-list-value
(function).
binding-val
(reader).
(setf binding-val)
(writer).
binding-var
(reader).
(setf binding-var)
(writer).
compose-substitutions
(function).
fix-uninterned-bindings
(function).
get-alist
(function).
groundp
(function).
make-binding
(function).
make-binding-list
(function).
make-load-form
(method).
set-variable-property
(generic function).
shop-union
(function).
shop-variable
(type).
standardize
(function).
unify
(function).
unify-fail
(macro).
unify-fail-p
(macro).
unify-p
(macro).
uniquify-anonymous-variables
(function).
variable-gensym
(function).
variable-p
(macro).
variablep
(function).
+anonymous-property-name+
(constant).
+primitive-property-name+
(constant).
+variable-property-name+
(constant).
all-elements-bindings
(function).
anonymous-var-symbol-p
(function).
binding
(structure).
binding-p
(function).
check-constraints
(function).
copy-binding
(function).
find-binding
(function).
occurs
(function).
primitive-symbol-p
(function).
real-apply-substitution
(function).
unify1
(function).
variable-name
(function).
variable-symbol-p
(function).
shop3/theorem-prover/package-thpr.lisp
shop3/theorem-prover
(system).
shop3/theorem-prover/decls.lisp
package-thpr.lisp
(file).
shop3/theorem-prover
(system).
*domain*
(special variable).
*establishers*
(special variable).
*literals*
(special variable).
*record-dependencies-p*
(special variable).
*state*
(special variable).
axioms
(generic function).
bad-argument
(condition).
default-state-type
(reader method).
domain-axioms
(reader method).
domain-name
(reader method).
has-static-preds-p
(generic function).
incomplete-dependency-error
(condition).
instantiation-error
(condition).
non-ground-error
(condition).
static-predicates-mixin
(class).
static-preds
(generic reader).
theorem-prover-condition
(condition).
thpr-domain
(class).
*optimize-first-retrieval*
(special variable).
all-raw-depends-lists-p
(function).
all-raw-depends-p
(function).
argno
(reader method).
argno
(reader method).
comment
(reader method).
copy-raw-depend
(function).
correct-arity
(reader method).
cut-commit
(condition).
expression
(reader method).
expression
(reader method).
expression
(reader method).
has-axioms-mixin
(class).
incorrect-arity-error
(condition).
list-raw-depend-lists
(type).
logical-keywordp
(generic function).
logical-op
(reader method).
make-raw-depend
(function).
op
(reader method).
predicate
(reader method).
predicate
(reader method).
raw-depend
(structure).
raw-depend-list
(type).
raw-depend-p
(function).
rd-est
(reader).
(setf rd-est)
(writer).
rd-prop
(reader).
(setf rd-prop)
(writer).
real-seek-satisfiers-for
(generic function).
var
(reader method).
shop3/theorem-prover/theorem-prover.lisp
decls.lisp
(file).
shop3/theorem-prover
(system).
def-logical-keyword
(macro).
explain-satisfier
(function).
extract-variables
(function).
find-satisfiers
(function).
print-axioms
(function).
print-belief-state-readably
(function).
query
(generic function).
*negation-deps-ok*
(special variable).
add-source
(function).
answer-set-union
(function).
dependency-for-negation
(function).
do-conjunct
(function).
do-conjunct-from-atoms
(function).
do-conjunct-from-axiom
(function).
do-conjunct-from-axioms
(function).
dummy-external-access-hook
(function).
external-find-satisfiers
(function).
external-query
(function).
find-variable
(function).
first-word-equal
(function).
fully-instantiated-goal
(function).
get-attribution
(function).
goal-equalp
(function).
incorporate-unifiers
(function).
invoke-external-query
(function).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
logical-keywordp
(method).
merge-binding-set-lists
(function).
merge-binding-sets
(function).
rd-union
(function).
real-seek-satisfiers
(function).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
real-seek-satisfiers-for
(method).
seek-satisfiers
(macro).
setof-bagof-helper
(function).
standard-satisfiers-for-and
(function).
standard-satisfiers-for-assign
(function).
standard-satisfiers-for-assign*
(function).
standard-satisfiers-for-bagof
(function).
standard-satisfiers-for-call
(function).
standard-satisfiers-for-enforce
(function).
standard-satisfiers-for-eval
(function).
standard-satisfiers-for-exists
(function).
standard-satisfiers-for-external
(function).
standard-satisfiers-for-forall
(function).
standard-satisfiers-for-imply
(function).
standard-satisfiers-for-not
(function).
standard-satisfiers-for-or
(function).
standard-satisfiers-for-setof
(function).
static-bounds-p
(function).
Packages are listed by definition order.
%shop3-common-private%
shop3-user
shop3.common
shop3.theorem-prover
shop-asd
shop3-pprint
plan-tree
shop3-minimal-subtree
prepare-return-values
shop3
shop3.unifier
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.
shop2-user
shop-user
common-lisp
.
shop3
.
shop3.common
shop2.common
shop.common
shop3cmn
common-lisp
.
iterate
.
shop3.unifier
.
*attribution-list*
(special variable).
*current-state*
(special variable).
*external-access*
(special variable).
*inferences*
(special variable).
*state-encoding*
(special variable).
add-atom-to-state
(generic function).
call
(macro).
copy-state
(generic function).
decode-tag
(function).
delete-atom-from-state
(generic function).
delete-state-tag-decoder
(function).
delete-tag-map
(function).
domain-name
(generic function).
domain-name
(slot).
domain-name
(slot).
last-establisher
(generic function).
make-initial-state
(generic function).
make-tag-map
(function).
name
(generic reader).
name
(slot).
prepare-state-tag-decoder
(function).
prop-sorter
(function).
replay-state-changes
(generic function).
retract-state-changes
(generic function).
shop-fail
(macro).
state
(generic reader).
(setf state)
(generic writer).
state
(structure).
state->state-type
(generic function).
state-all-atoms-for-predicate
(generic function).
state-atoms
(generic function).
state-atoms
(slot).
state-candidate-atoms-for-goal
(generic function).
state-trajectory
(generic function).
tag-for-action
(function).
tag-state
(generic function).
tagged-state
(structure).
%make-bit-state
(function).
*action-to-tag-map*
(special variable).
*state-tag-map*
(special variable).
+singleton-term+
(constant).
+variable-term+
(constant).
action-type
(type).
atom-in-state-p
(generic function).
bit-state
(structure).
bit-state-block-at
(function).
(setf bit-state-block-at)
(function).
bit-state-body
(function).
(setf bit-state-body)
(function).
bit-state-p
(function).
bit-state-tags-info
(function).
(setf bit-state-tags-info)
(function).
bit-statebody-increment-position
(function).
bit-statebody-search-array
(function).
copy-hash-table
(function).
copy-state-update
(function).
domain-core
(class).
doubly-hashed-state
(structure).
doubly-hashed-state-block-at
(function).
(setf doubly-hashed-state-block-at)
(function).
doubly-hashed-state-body
(function).
(setf doubly-hashed-state-body)
(function).
doubly-hashed-state-p
(function).
doubly-hashed-state-tags-info
(function).
(setf doubly-hashed-state-tags-info)
(function).
hash-state
(structure).
hash-state-block-at
(function).
(setf hash-state-block-at)
(function).
hash-state-body
(function).
(setf hash-state-body)
(function).
hash-state-p
(function).
hash-state-tags-info
(function).
(setf hash-state-tags-info)
(function).
include-in-tag
(generic function).
insert-atom
(generic function).
list-insert-atom-into-statebody
(function).
list-remove-atom-from-statebody
(function).
list-state
(structure).
list-state-block-at
(function).
(setf list-state-block-at)
(function).
list-state-body
(function).
(setf list-state-body)
(function).
list-state-p
(function).
list-state-tags-info
(function).
(setf list-state-tags-info)
(function).
make-bit-state
(function).
make-doubly-hashed-state
(function).
make-hash-state
(function).
make-list-state
(function).
make-mixed-state
(function).
make-state-update
(function).
makedoubly-hashedstate
(function).
makehashstate
(function).
makeliststate
(function).
makemixedstate
(function).
mixed-state
(structure).
mixed-state-block-at
(function).
(setf mixed-state-block-at)
(function).
mixed-state-body
(function).
(setf mixed-state-body)
(function).
mixed-state-p
(function).
mixed-state-tags-info
(function).
(setf mixed-state-tags-info)
(function).
pull-tag-info
(function).
redo-state-update
(generic function).
remove-atom
(generic function).
state-body
(reader).
(setf state-body)
(writer).
state-p
(function).
state-update
(structure).
state-update-action
(reader).
(setf state-update-action)
(writer).
state-update-literal
(reader).
(setf state-update-literal)
(writer).
state-update-p
(function).
tagged-state-block-at
(reader).
(setf tagged-state-block-at)
(writer).
tagged-state-body
(function).
(setf tagged-state-body)
(function).
tagged-state-p
(function).
tagged-state-tags-info
(reader).
(setf tagged-state-tags-info)
(writer).
tagged-state-tags-info-tag
(function).
undo-state-update
(generic function).
shop3.theorem-prover
shop.theorem-prover
shopthpr
common-lisp
.
iterate
.
shop3.common
.
shop3.unifier
.
*domain*
(special variable).
*establishers*
(special variable).
*literals*
(special variable).
*record-dependencies-p*
(special variable).
*state*
(special variable).
axioms
(generic function).
bad-argument
(condition).
def-logical-keyword
(macro).
default-state-type
(generic reader).
domain-axioms
(generic reader).
explain-satisfier
(function).
extract-variables
(function).
find-satisfiers
(function).
has-static-preds-p
(generic function).
incomplete-dependency-error
(condition).
instantiation-error
(condition).
non-ground-error
(condition).
print-axioms
(function).
print-belief-state-readably
(function).
query
(generic function).
static-predicates-mixin
(class).
static-preds
(generic reader).
theorem-prover-condition
(condition).
thpr-domain
(class).
*negation-deps-ok*
(special variable).
*optimize-first-retrieval*
(special variable).
+binary-numerical-operators+
(special variable).
+numerical-comparisons+
(special variable).
add-source
(function).
all-raw-depends-lists-p
(function).
all-raw-depends-p
(function).
answer-set-union
(function).
argno
(generic reader).
comment
(generic reader).
copy-raw-depend
(function).
correct-arity
(generic reader).
cut-commit
(condition).
dependency-for-negation
(function).
do-conjunct
(function).
do-conjunct-from-atoms
(function).
do-conjunct-from-axiom
(function).
do-conjunct-from-axioms
(function).
dummy-external-access-hook
(function).
expression
(generic reader).
external-find-satisfiers
(function).
external-query
(function).
find-variable
(function).
first-word-equal
(function).
fluent-comparison-p
(generic function).
fluent-expr-p
(generic function).
fluent-function-p
(generic function).
fluent-functions
(generic reader).
fluents-mixin
(class).
fully-instantiated-goal
(function).
get-attribution
(function).
goal-equalp
(function).
has-axioms-mixin
(class).
incorporate-unifiers
(function).
incorrect-arity-error
(condition).
invoke-external-query
(function).
list-raw-depend-lists
(type).
logical-keywordp
(generic function).
logical-op
(generic reader).
make-raw-depend
(function).
merge-binding-set-lists
(function).
merge-binding-sets
(function).
op
(generic reader).
pddl-satisfiers-for-exists
(function).
pddl-satisfiers-for-f-exp
(function).
pddl-satisfiers-for-forall
(function).
pddl-satisfiers-for-imply
(function).
pddl-satisfiers-for-not
(function).
predicate
(generic reader).
raw-depend
(structure).
raw-depend-list
(type).
raw-depend-p
(function).
rd-est
(reader).
(setf rd-est)
(writer).
rd-prop
(reader).
(setf rd-prop)
(writer).
rd-union
(function).
real-seek-satisfiers
(function).
real-seek-satisfiers-for
(generic function).
seek-satisfiers
(macro).
setof-bagof-helper
(function).
standard-satisfiers-for-and
(function).
standard-satisfiers-for-assign
(function).
standard-satisfiers-for-assign*
(function).
standard-satisfiers-for-bagof
(function).
standard-satisfiers-for-call
(function).
standard-satisfiers-for-enforce
(function).
standard-satisfiers-for-eval
(function).
standard-satisfiers-for-exists
(function).
standard-satisfiers-for-external
(function).
standard-satisfiers-for-forall
(function).
standard-satisfiers-for-imply
(function).
standard-satisfiers-for-not
(function).
standard-satisfiers-for-or
(function).
standard-satisfiers-for-setof
(function).
static-bounds-p
(function).
var
(generic reader).
vars-boundp
(function).
shop-asd
shop3-asd
shop2-asd
asdf/interface
.
common-lisp
.
cl-file
(class).
shop-fiveam-tester
(class).
shop-tester-mixin
(class).
tester-cl-source-file
(class).
shop3-pprint
shop2-pprint
common-lisp
.
iterate
.
shop3
.
axiom-sexp-p
(function).
method-printer
(function).
method-sexp-p
(function).
op-sexp-p
(function).
operator-printer
(function).
operator-sexp-p
(function).
pprint-preconds
(function).
pprint-task-net
(function).
print-list-on-lines
(function).
print-list-suffix-lines
(function).
plan-tree
shop-extended-plan-tree
common-lisp
.
iterate
.
complex-tree-node
(structure).
complex-tree-node-children
(reader).
(setf complex-tree-node-children)
(writer).
complex-tree-node-method-name
(reader).
(setf complex-tree-node-method-name)
(writer).
consumer
(reader).
(setf consumer)
(writer).
copy-plan-tree
(function).
dependency
(structure).
establisher
(reader).
(setf establisher)
(writer).
find-plan-step
(function).
find-task-in-tree
(function).
find-tree-node-if
(function).
make-complex-tree-node
(function).
make-dependency
(function).
make-ordered-tree-node
(function).
make-primitive-tree-node
(function).
make-top-node
(function).
make-unordered-tree-node
(function).
ordered-tree-node
(structure).
plan-tree->sexp
(generic function).
primitive-tree-node
(structure).
prop
(reader).
(setf prop)
(writer).
pseudo-node
(structure).
top-node
(structure).
tree-node
(structure).
tree-node-dependencies
(reader).
(setf tree-node-dependencies)
(writer).
tree-node-expanded-task
(reader).
(setf tree-node-expanded-task)
(writer).
tree-node-parent
(reader).
(setf tree-node-parent)
(writer).
tree-node-task
(reader).
(setf tree-node-task)
(writer).
unordered-tree-node
(structure).
*node-list*
(special variable).
*table-for-load-form*
(special variable).
complex-tree-node-dependencies
(function).
(setf complex-tree-node-dependencies)
(function).
complex-tree-node-expanded-task
(function).
(setf complex-tree-node-expanded-task)
(function).
complex-tree-node-p
(function).
complex-tree-node-parent
(function).
(setf complex-tree-node-parent)
(function).
complex-tree-node-task
(function).
(setf complex-tree-node-task)
(function).
copy-complex-tree-node
(function).
copy-dependency
(function).
copy-ordered-tree-node
(function).
copy-plan-tree-node
(generic function).
copy-primitive-tree-node
(function).
copy-pseudo-node
(function).
copy-top-node
(function).
copy-tree-node
(function).
copy-unordered-tree-node
(function).
cross-links-for
(generic function).
dependency-p
(function).
insert-if-necessary
(function).
make-cross-links
(function).
make-instantiator
(generic function).
make-pseudo-node
(function).
make-table-entries
(generic function).
make-tree-node
(function).
obj-bindings
(function).
ordered-tree-node-children
(function).
(setf ordered-tree-node-children)
(function).
ordered-tree-node-dependencies
(function).
(setf ordered-tree-node-dependencies)
(function).
ordered-tree-node-expanded-task
(function).
(setf ordered-tree-node-expanded-task)
(function).
ordered-tree-node-method-name
(function).
(setf ordered-tree-node-method-name)
(function).
ordered-tree-node-p
(function).
ordered-tree-node-parent
(function).
(setf ordered-tree-node-parent)
(function).
ordered-tree-node-task
(function).
(setf ordered-tree-node-task)
(function).
primitive-tree-node-dependencies
(function).
(setf primitive-tree-node-dependencies)
(function).
primitive-tree-node-expanded-task
(function).
(setf primitive-tree-node-expanded-task)
(function).
primitive-tree-node-p
(function).
primitive-tree-node-parent
(function).
(setf primitive-tree-node-parent)
(function).
primitive-tree-node-task
(function).
(setf primitive-tree-node-task)
(function).
print-unreadably
(macro).
pseudo-node-children
(function).
(setf pseudo-node-children)
(function).
pseudo-node-dependencies
(function).
(setf pseudo-node-dependencies)
(function).
pseudo-node-expanded-task
(function).
(setf pseudo-node-expanded-task)
(function).
pseudo-node-method-name
(function).
(setf pseudo-node-method-name)
(function).
pseudo-node-p
(function).
pseudo-node-parent
(function).
(setf pseudo-node-parent)
(function).
pseudo-node-task
(function).
(setf pseudo-node-task)
(function).
slot-fillers
(generic function).
slot-value-translator
(function).
top-node-children
(function).
(setf top-node-children)
(function).
top-node-dependencies
(function).
(setf top-node-dependencies)
(function).
top-node-expanded-task
(function).
(setf top-node-expanded-task)
(function).
top-node-lookup-table
(reader).
(setf top-node-lookup-table)
(writer).
top-node-method-name
(function).
(setf top-node-method-name)
(function).
top-node-p
(function).
top-node-parent
(function).
(setf top-node-parent)
(function).
top-node-task
(function).
(setf top-node-task)
(function).
tree-node-p
(function).
unordered-tree-node-children
(function).
(setf unordered-tree-node-children)
(function).
unordered-tree-node-dependencies
(function).
(setf unordered-tree-node-dependencies)
(function).
unordered-tree-node-expanded-task
(function).
(setf unordered-tree-node-expanded-task)
(function).
unordered-tree-node-method-name
(function).
(setf unordered-tree-node-method-name)
(function).
unordered-tree-node-p
(function).
unordered-tree-node-parent
(function).
(setf unordered-tree-node-parent)
(function).
unordered-tree-node-task
(function).
(setf unordered-tree-node-task)
(function).
shop3-minimal-subtree
shop2-minimal-subtree
subtree
shop-minimal-subtree
find-failed-task
(generic function).
clobbered-p
(function).
find-adder
(function).
find-checking-path
(function).
find-deleter
(function).
find-plan-suffix
(function).
leftmost-p
(function).
prepare-return-values
prv
common-lisp
.
iterate
.
prepare-return-values
(function).
phase-one
(function).
translate-child-links
(function).
translate-dependency-links
(function).
translate-lookup-table
(function).
shop3
The SHOP3 package is the package that exposes SHOP3’s API.
shop2
shop
common-lisp
.
iterate
.
shop3.common
.
shop3.theorem-prover
.
shop3.unifier
.
*defdomain-verbose*
(special variable).
*define-silently*
(special variable).
*which*
(special variable).
adl-domain
(class).
adl-mixin
(class).
all-primitive-nodes
(function).
apply-operator
(generic function).
complex-node-children
(function).
(setf complex-node-children)
(function).
complex-node-p
(function).
complex-node-task
(function).
(setf complex-node-task)
(function).
conditional-effects-mixin
(class).
copy-plan-tree
(function).
copy-shop-problem
(generic function).
costs-mixin
(class).
def-problem-set
(macro).
defdomain
(macro).
defproblem
(macro).
delete-domain
(generic function).
delete-problem
(generic function).
disjunctive-preconditions-mixin
(class).
do-problems
(function).
domain
(class).
domain-methods
(generic function).
domain-operators
(generic function).
equality-mixin
(class).
existential-preconditions-mixin
(class).
find-all-complex-node-for-task
(function).
find-all-complex-node-if
(function).
find-all-primitive-nodes-if
(function).
find-complex-node-for-task
(function).
find-complex-node-if
(function).
find-domain
(function).
find-plans
(function).
find-plans-stack
(function).
find-primitive-node-for-task
(function).
find-primitive-node-if
(function).
find-problem
(function).
get-problems
(function).
get-state
(generic function).
get-tasks
(generic function).
handle-domain-options
(generic function).
internal-operator-p
(function).
make-complex-node
(function).
make-problem
(function).
make-problem-set
(function).
methods
(generic function).
negative-preconditions-mixin
(class).
no-method-for-task
(condition).
node-parent
(function).
parse-domain-items
(generic function).
pddl-domain
(class).
pddl-typing-mixin
(class).
plan-final-state
(function).
plan-states
(function).
pprint-plan
(function).
primitive-node-cost
(function).
(setf primitive-node-cost)
(function).
primitive-node-p
(function).
primitive-node-position
(function).
(setf primitive-node-position)
(function).
primitive-node-task
(function).
(setf primitive-node-task)
(function).
print-current-state
(function).
print-methods
(function).
print-operators
(function).
problem
(class).
problem-name
(generic reader).
process-axiom
(function).
process-method
(generic function).
process-op
(generic function).
process-operator
(generic function).
pure-logic-domain-mixin
(class).
quantified-preconditions-mixin
(class).
remove-costs
(function).
remove-internal-operators
(function).
repair-plan
(function).
seek-plans-null
(generic function).
seek-plans-primitive
(generic function).
set-domain
(function).
shop-trace
(macro).
shop-trace-info
(function).
shop-untrace
(macro).
shorter-plan
(function).
simple-pddl-domain
(class).
singleton-variable
(condition).
sort-methods
(generic function).
sort-results
(generic function).
sort-tasks
(generic function).
source-pddl-domain
(generic reader).
task-arity-mismatch
(condition).
task-name
(function).
task-sorter
(generic function).
(setf tree-node-task)
(setf expander).
tree-node-task
(function).
tree-node-task-name
(function).
universal-preconditions-mixin
(class).
validate-plan
(function).
validator-export
(generic function).
write-pddl-plan
(function).
%delete-a-decomposition
(generic function).
%new-method-id
(function).
%record-a-decomposition
(generic function).
%update-singleton
(generic function).
*all-method-names*
(special variable).
*all-problems*
(special variable).
*analogical-replay*
(special variable).
*analogical-replay-table*
(special variable).
*back-quote-name*
(special variable).
*before-extract-trees-hook*
(special variable).
*break-on-backtrack*
(special variable).
*collect-state*
(special variable).
*current-plan*
(special variable).
*current-tasks*
(special variable).
*defdomain-pathname*
(special variable).
*depth-cutoff*
(special variable).
*enhanced-plan-tree*
(special variable).
*expansions*
(special variable).
*explanation*
(special variable).
*gc*
(special variable).
*hand-steer*
(special variable).
*ignore-singleton-variables*
(special variable).
*include-rationale*
(special variable).
*internal-time-limit*
(special variable).
*internal-time-tag*
(special variable).
*leashed*
(special variable).
*make-analogy-table*
(special variable).
*more-tasks-p*
(special variable).
*no-dependencies*
(special variable).
*node-children-table*
(special variable).
*old-depth*
(special variable).
*operator-tasks*
(special variable).
*optimal-cost*
(special variable).
*optimal-plan*
(special variable).
*optimize-cost*
(special variable).
*plan-num-limit*
(special variable).
*plan-tree*
(special variable).
*plans-found*
(special variable).
*pp*
(special variable).
*print-plans*
(special variable).
*print-stats*
(special variable).
*problem*
(special variable).
*protections*
(special variable).
*pshort*
(special variable).
*shop-pprint-table*
(special variable).
*shop-version*
(special variable).
*start-real-time*
(special variable).
*start-run-time*
(special variable).
*states-found*
(special variable).
*subtask-parents*
(special variable).
*task-operator*
(special variable).
*tasklist*
(special variable).
*time-limit*
(special variable).
*traced-axioms*
(special variable).
*traced-goals*
(special variable).
*traced-methods*
(special variable).
*traced-tasks*
(special variable).
*unifiers-found*
(special variable).
*unique-method-names*
(special variable).
*validator-progname*
(special variable).
*verbose*
(special variable).
+fluent-updates+
(special variable).
+method-definition-keywords+
(special variable).
+pddl-requirements-keywords+
(special variable).
+shop-trace-items+
(constant).
+shopyright+
(constant).
acceptable-cost-p
(function).
actions-domain-mixin
(class).
add-child-to-tree
(class).
add-dependencies
(class).
add-protection
(function).
all-roots
(function).
already-immediate-p
(function).
alternatives
(generic reader).
(setf alternatives)
(generic writer).
appendf
(macro).
apply-action
(function).
apply-method
(generic function).
apply-method-bindings
(function).
apply-substitution-to-tree
(function).
assign-domain-method-id
(generic function).
backtrack
(function).
backtrack-stack
(generic reader).
(setf backtrack-stack)
(generic writer).
bottom-of-stack
(class).
branch-number
(generic reader).
canonically-order
(function).
catch-internal-time
(macro).
check-for-singletons
(function).
child
(generic reader).
choice-entry
(class).
choose-immediate-task
(function).
choose-immediate-task-state
(function).
choose-method-bindings-state
(function).
choose-method-state
(function).
choose-toplevel-task
(function).
clear-replay-table
(generic function).
complex-node
(type).
compute-fluent-updates
(function).
construct
(generic reader).
construct-name
(generic reader).
construct-type
(generic reader).
copy-complex-node
(function).
copy-operator
(function).
copy-pddl-action
(function).
copy-primitive-node
(function).
copy-replay-table-entry
(function).
copy-task-tree
(function).
cost
(generic reader).
(setf cost)
(generic writer).
count-method-branches
(function).
create-node-children-table
(function).
current-task
(generic reader).
(setf current-task)
(generic writer).
decode-task
(function).
defconstant
(macro).
delete-protection
(function).
delete-protections
(function).
delete-task-main-list
(function).
delete-task-top-list
(function).
dependencies
(generic reader).
depth
(generic reader).
(setf depth)
(generic writer).
determine-verbosity
(function).
divergence-list
(type).
divergence-list-p
(function).
divergence-op-p
(function).
do-backtrack
(generic function).
domain-id-for-method-lookup
(generic function).
domain-include-parse
(generic function).
domain-include-search
(function).
domain-item-parse-warning
(condition).
domain-items
(generic function).
domain-method-id-lookup
(generic function).
domain-method-to-name-table
(generic reader).
domain-name-to-method-table
(generic reader).
domain-parse-error
(condition).
domain-parse-warning
(condition).
domain-style-warning
(condition).
dump-higher-cost-plans!
(function).
dump-previous-plans!
(function).
empty-p
(function).
expand-include
(function).
expand-includes
(function).
expand-loop
(generic function).
expand-loop-body
(generic function).
expand-primitive-state
(generic function).
extend-plan-tree-nodes
(function).
extract-adds-and-deletes
(function).
extract-method-id
(function).
extract-subtasks
(function).
extract-subtree
(function).
extract-suffix
(function).
extract-tree
(function).
extract-trees
(function).
filter-singletons
(function).
find-decompositions
(generic function).
find-failed-choice-entry
(generic function).
find-failed-stack-entry
(generic function).
find-next-main-list
(function).
find-plans-1
(function).
force-immediate
(function).
force-immediate-reduction
(function).
force-immediate-unordered
(function).
freeze-state
(function).
generate-reductions
(function).
get-immediate-list
(function).
get-method-name
(function).
get-task-body
(function).
get-task-name
(function).
get-top-tasks
(function).
guidance
(generic function).
harvest-variables
(function).
id-search
(function).
immediate-tasks
(function).
implicit-conjunction-warning
(condition).
indented-format
(function).
index-method-on-domain
(function).
initialize-problem
(generic function).
install-domain
(generic function).
lookup-table
(generic reader).
loop-body-item
(function).
loop-body-item-inner
(function).
loop-item
(function).
loop-state-expand
(class).
looping-domain
(class).
looping-p
(function).
make-add-child-to-tree
(function).
make-add-dependencies
(function).
make-cs-state
(function).
make-dependencies
(function).
make-domain
(function).
make-loop-state-expand
(function).
make-method-instantiation
(function).
make-operator
(function).
make-operator-task-table
(function).
make-pddl-action
(function).
make-plan-copy
(function).
make-plan-return
(generic function).
make-plan-tree-for-task-net
(function).
make-prim-state-expand
(function).
make-primitive-node
(function).
make-record-expansion
(function).
make-record-expansion-for-replay
(function).
make-replay-table-entry
(function).
make-subtask-parents-table
(function).
make-world-state-tag
(function).
method-definition-keywords
(generic function).
method-expression-body
(generic function).
method-expression-task
(generic function).
method-head
(generic function).
method-id
(generic reader).
method-instantiation
(class).
method-name
(generic function).
method-p
(generic function).
method-preconditions
(generic function).
method-task
(generic function).
method-task-net
(generic function).
min-start
(function).
mode
(generic reader).
(setf mode)
(generic writer).
new-symbol
(function).
no-failed-task
(condition).
node-children
(function).
non-unique-method-name-error
(condition).
non-unique-method-name-mixin
(condition).
non-unique-method-name-warning
(condition).
nshuffle-array
(function).
nshuffle-list
(function).
of-type-exprs
(function).
old-name
(generic reader).
operator
(generic function).
operator
(type).
operator-additions
(function).
(setf operator-additions)
(function).
operator-cost-fun
(function).
(setf operator-cost-fun)
(function).
operator-deletions
(function).
(setf operator-deletions)
(function).
operator-head
(function).
(setf operator-head)
(function).
operator-name
(function).
operator-p
(function).
operator-preconditions
(function).
(setf operator-preconditions)
(function).
operator-task
(function).
operators-dont-fail
(generic reader).
optimize-continue-p
(function).
parent
(generic reader).
parse-domain-item
(generic function).
parse-pddl-method
(function).
parse-typed-list
(function).
partial-plan
(generic reader).
(setf partial-plan)
(generic writer).
partial-plan-cost
(generic reader).
pddl-action
(type).
pddl-action-cost-fun
(function).
(setf pddl-action-cost-fun)
(function).
pddl-action-effect
(function).
(setf pddl-action-effect)
(function).
pddl-action-head
(function).
(setf pddl-action-head)
(function).
pddl-action-name
(function).
pddl-action-p
(function).
pddl-action-precondition
(function).
(setf pddl-action-precondition)
(function).
pddl-method-p
(generic function).
pddl-plan
(generic function).
pddl-types
(generic reader).
(setf pddl-types)
(generic writer).
plan
(generic reader).
plan-cost
(generic function).
plan-operator-nodes
(function).
plan-return
(class).
plan-returns
(function).
plan-tree
(generic reader).
plan-tree-lookup
(generic reader).
plan-tree-nodes
(function).
plans-found
(generic reader).
(setf plans-found)
(generic writer).
populate-plan-return
(function).
pprint-step
(function).
prepare-choose-immediate-task-state
(function).
prim-state-expand
(class).
primitive-node
(type).
primitivep
(function).
print-current-plan
(function).
print-current-tasks
(function).
print-operator
(function).
print-output-file
(function).
print-stats
(function).
print-stats-header
(function).
print1
(function).
problem->state
(generic function).
problem-state
(generic function).
problem-tasks
(generic function).
process-action
(generic function).
process-add-list
(function).
process-add-or-delete
(generic function).
process-delete-list
(function).
process-method-pre
(generic function).
process-pddl-method-pre
(function).
process-pre
(generic function).
process-task-list
(function).
protection-ok
(function).
protections
(generic reader).
(setf protections)
(generic writer).
push-last
(macro).
query-current-state
(function).
quotify
(function).
randomize-list
(function).
record-decomposition
(generic function).
record-expansion
(class).
record-expansion-for-replay
(class).
record-node-expansion
(function).
record-operator
(function).
record-reduction
(function).
regularize-axiom
(generic function).
remove-subtree-from-table
(function).
rename-sym
(function).
replace-task-main-list
(function).
replace-task-top-list
(function).
replan-from-failure
(function).
replay-table
(generic reader).
replay-table-entry
(structure).
replay-table-entry-alist
(reader).
(setf replay-table-entry-alist)
(writer).
replay-table-entry-p
(function).
replay-table-entry-singleton
(reader).
(setf replay-table-entry-singleton)
(writer).
report-no-method
(function).
report-task-arity-mismatch
(function).
rest-shop2-axiom-p
(function).
resymbol-task
(function).
search-failed
(condition).
search-state
(generic reader).
search-state
(class).
search-tree
(function).
seek-plans
(generic function).
seek-plans-loop
(generic function).
seek-plans-nonprimitive
(generic function).
seek-plans-primitive-1
(function).
seek-plans-stack
(function).
seek-plans-task
(generic function).
shop-condition
(condition).
shop-error
(condition).
shop-trace-1
(function).
shop-untrace-1
(function).
shop-untrace-all
(function).
shop2-axiom-p
(function).
simple-backquote
(macro).
stack-backjump
(function).
stack-backtrack
(function).
stack-constructor
(macro).
stack-entry
(class).
state-tag
(class).
store-plan!
(generic function).
strip-nops
(function).
strip-task-sexp
(function).
strip-tree-tags
(function).
tag
(generic reader).
task
(generic reader).
task-args
(function).
task-arity-mismatch-library-entry
(generic reader).
task-arity-mismatch-library-task
(generic reader).
task-arity-mismatch-task
(generic reader).
tasks
(generic reader).
(setf tasks)
(generic writer).
test-plan-found
(function).
time-expired-p
(function).
to-string
(function).
top-tasks
(generic reader).
(setf top-tasks)
(generic writer).
translate-effect
(generic function).
translate-fluent-precond
(function).
translate-include
(function).
translate-metric-updates
(function).
translate-pddl-quantifier
(function).
translate-precondition
(generic function).
tree
(generic reader).
tree-compare
(function).
tree-node
(generic reader).
tree-node
(type).
typed-list-vars
(function).
unfold-loop-task
(generic function).
unifier
(generic reader).
(setf unifier)
(generic writer).
user-choose-task
(function).
values!
(type).
variable-names
(generic reader).
verbose-format
(macro).
well-formed-listp
(function).
when-done
(macro).
with-method-name-table
(macro).
world-state
(generic reader).
(setf world-state)
(generic writer).
shop3.unifier
shop.unifier
shop2.unifier
shopunif
common-lisp
.
*shop-trace*
(special variable).
*shop-trace-stream*
(special variable).
*trace-query*
(special variable).
anonymous-var-p
(function).
apply-substitution
(macro).
binding-list
(type).
binding-list-value
(function).
binding-val
(reader).
(setf binding-val)
(writer).
binding-var
(reader).
(setf binding-var)
(writer).
compose-substitutions
(function).
fix-uninterned-bindings
(function).
get-alist
(function).
groundp
(function).
make-binding
(function).
make-binding-list
(function).
set-variable-property
(generic function).
shop-union
(function).
shop-variable
(type).
standardize
(function).
trace-print
(macro).
trigger-trace
(generic function).
unify
(function).
unify-fail
(macro).
unify-fail-p
(macro).
unify-p
(macro).
uniquify-anonymous-variables
(function).
variable-gensym
(function).
variable-p
(macro).
variablep
(function).
+anonymous-property-name+
(constant).
+primitive-property-name+
(constant).
+variable-property-name+
(constant).
all-elements-bindings
(function).
anonymous-var-symbol-p
(function).
binding
(structure).
binding-p
(function).
check-constraints
(function).
copy-binding
(function).
find-binding
(function).
occurs
(function).
primitive-symbol-p
(function).
real-apply-substitution
(function).
unify1
(function).
variable-name
(function).
variable-symbol-p
(function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
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.
Default domain to use when planning.
Do we record dependencies when we find literals in the theorem prover. If so, see *LITERALS* and *ESTABLISHERS*.
This special variable should be bound to the current
state inside FIND-SATISFIERS, qv., giving axioms access to the
state data structure.
APPLY-SUBSTITUTION searches through TARGET, replacing each variable symbol with the corresponding value (if any) in SUBSTITUTION
(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.
(DEFPROBLEM {<name>|<name-and-options>} <state> <tasks>) For backward compatibility, will support also (DEFPROBLEM <name> <domain-name> <state> <tasks>).
- (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
(SHOP-UNTRACE ...) is the inverse of (SHOP-TRACE ...)
It’s painful (and bug-inducing) to have to remember to compare the result of unify with ’fail.
Better-named alias for UNIFY-FAIL.
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.
An alias for VARIABLEP, for more consistent naming.
Does X name an anonymous variable?
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.
Is TREE-NODE a representation of a complex node (i.e., not an operator) in the SHOP2 tree format as described in SHOP2?
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.
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.
Erase association of TAG with its operator/action instance.
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.
Find all complex-nodes in the TREE whose task name is TASK.
Return a complex node whose TASK satisfies FUN.
Return a list of all primitive nodes whose TASK satisfies FUN.
Find a complex-node in the TREE whose task name is TASK.
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.
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.
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.
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.
Return a primitive node whose task matches TASK. When
the node is found, returns two values: the node itself, and its
parent.
Return A primitive node whose TASK satisfies FUN. When
the node is found, returns two values: the node itself, and its
parent.
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).
Return the PLAN-TREE:TREE-NODE in TREE corresponding to TASK.
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.
Get the list of problems for the problem set named NAME
Is LITERAL a ground literal? Traverse the tree looking for a variable.
Takes a list of VARIABLES and VALUES and returns a BINDING-LIST.
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*.
Record association of TAG with operator/action instance OPERATOR.
Find ‘NODE‘’s parent in ‘TREE‘. Returns ‘NIL‘ if nothing found.
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.
Take the PLAN and PLAN-TREE and create new PLAN and PLAN-TREE objects, copies of the originals, with the BINDINGS applied.
Is TREE-NODE a representation of a primitive node (i.e., an operator) in the SHOP2 tree format as described in SHOP2?
Function that can be used inside CL:SORT to sort SHOP literals alphabetically for easier human inspection.
The SHOP2 plans come with the operators interspersed with their costs. This function just throws away the costs.
Returns a new complex-node like the original, but with any children that are internal operators (primitive nodes) removed.
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.
NAME argument is a symbol. Will set the global variable *DOMAIN* to the domain with domain-name NAME.
Information about the traced aspects of shop3.
Removes the internal operators and costs from a plan sequence, and returns the resulting new sequence. Non-destructive.
Replace all variables in EXPR with newly-generated variables, with new names.
task
.
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.
Replace all anonymous variables in SEXP by standardization, so that all anonymous variables are distinct.
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).
Return a new variable, made from BASE-NAME
Is X a symbol representing a logical variable for SHOP’s theorem-prover?
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.
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.
tagged-state
) depth operator) ¶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.
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.
Return a list of all the SHOP axioms for PREDICATE in THPR-DOMAIN.
has-axioms-mixin
) (name symbol
)) ¶Return a list of axioms for for NAME as defined in DOMAIN.
Return a copy of the state
doubly-hashed-state
)) ¶mixed-state
)) ¶hash-state
)) ¶list-state
)) ¶thpr-domain
)) ¶automatically generated reader method
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.
tagged-state
) depth operator) ¶symbol
)) ¶symbol
)) ¶has-axioms-mixin
)) ¶automatically generated reader method
Returns a hash-table mapping complex task names to methods for expanding such tasks.
actions-domain-mixin
)) ¶automatically generated reader method
symbol
)) ¶symbol
)) ¶problem
)) ¶The programmer MAY (but is not obligated to) specify that a problem is intended for use with a particular domain definition.
thpr-domain
)) ¶automatically generated reader method
Returns a hash-table mapping primitive task names to operator definitions.
actions-domain-mixin
)) ¶automatically generated reader method
symbol
)) ¶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.
domain
) plan (plan-tree tree-node
) executed divergence &key plan-tree-hash) ¶Default method for FIND-FAILED-TASK.
symbol
) plan plan-tree executed divergence &key plan-tree-hash) ¶symbol
) plan plan-tree executed divergence &key plan-tree-hash) ¶symbol
)) ¶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.
static-predicates-mixin
)) ¶Return the action that last established LITERAL before STATE.
tagged-state
) literal) ¶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.
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).
(eql :bit)
) atoms &key) ¶(eql :doubly-hashed)
) atoms &key) ¶(eql :mixed)
) atoms &key) ¶(eql :hash)
) atoms &key) ¶(eql :list)
) atoms &key) ¶Return a list of all the SHOP methods for TASK-NAME in DOMAIN.
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.
pddl-typing-mixin
) items) ¶equality-mixin
) items) ¶Add the axiom that treats equality as a built-in predicate. This should later be compiled into find-satisfiers or something.
fluents-mixin
) items) ¶Translate PLAN-TREE into an s-expression for export to other systems.
complex-tree-node
)) ¶ordered-tree-node
)) ¶unordered-tree-node
)) ¶primitive-tree-node
)) ¶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.
pure-logic-domain-mixin
) method) ¶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.
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.
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.
tagged-state
) tags-info-list &optional stop-at) ¶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.
tagged-state
) tag) ¶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...
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.
Record facts about X being a variable, operator, or
other special symbol. Done for side-effects. Returns nothing
of interest.
Sort a list of METHODS in DOMAIN according to WHICH-PLANS.
Sort lists of RESULTS and UNIFIERS in DOMAIN according to WHICH-PLANS and return the new RESULTS and UNIFIERS.
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.
simple-pddl-domain
)) ¶automatically generated reader method
search-state
)) ¶search-state
)) ¶SHOP2 world state object.
Return the state-type keyword for STATE.
doubly-hashed-state
)) ¶mixed-state
)) ¶hash-state
)) ¶list-state
)) ¶Return all atoms in STATE that concern PRED. Used internally
by the theorem-prover. Must be implemented when adding a new state structure type.
doubly-hashed-state
) pred) ¶mixed-state
) pred) ¶hash-state
) pred) ¶list-state
) pred) ¶Return the atoms of the state in a plain list
problem
)) ¶automatically generated reader method
doubly-hashed-state
)) ¶mixed-state
)) ¶hash-state
)) ¶list-state
)) ¶Return all atoms in STATE relevant to GOAL. Used internally
by the theorem-prover. Must be implemented when adding a new state structure type.
doubly-hashed-state
) goal) ¶mixed-state
) goal) ¶hash-state
) goal) ¶list-state
) goal) ¶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.
tagged-state
) &key sorted) ¶Return a list of predicate names for static predicates.
static-predicates-mixin
)) ¶automatically generated reader method
Add a tag to a state; used to make tagged-states, which provide information about how to backtrack over state updates.
tagged-state
) &optional increment) ¶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.
Allow extensible methods of matching to trigger printing.
(eql :tasks)
) (item symbol
)) ¶(eql :goals)
) (item symbol
)) ¶(eql :axioms)
) (item symbol
)) ¶(eql :methods)
) (item symbol
)) ¶Print a plan in a way that it can be consumed by the VAL validator.
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.
asdf/action
.
primitive-tree-node
) str) ¶complex-tree-node
) str) ¶unordered-tree-node
) str) ¶dependency
) str) ¶ordered-tree-node
) str) ¶choice-entry
) str) ¶error
.
theorem-prover-condition
.
error
.
theorem-prover-condition
.
:logical-op
This slot is read-only.
:expression
This slot is read-only.
error
.
theorem-prover-condition
.
:task-name
error
.
theorem-prover-condition
.
:expression
This slot is read-only.
:variable-names
This slot is read-only.
:construct-type
This slot is read-only.
:construct-name
This slot is read-only.
(quote nil)
:construct
This slot is read-only.
(quote nil)
:branch-number
This slot is read-only.
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.
:task
This slot is read-only.
:library-task
This slot is read-only.
:library-entry
This slot is read-only.
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.
condition
.
structure-object
.
The ‘tagged-state‘ type encapsulates the behaviors needed to support backtracking and backjumping.
(or hash-table null)
An object representing a SHOP domain.
%delete-a-decomposition
.
%record-a-decomposition
.
apply-method
.
apply-operator
.
clear-replay-table
.
clear-replay-table
.
delete-domain
.
domain-include-parse
.
domain-items
.
expand-primitive-state
.
find-decompositions
.
find-failed-task
.
guidance
.
handle-domain-options
.
install-domain
.
make-plan-return
.
make-plan-return
.
method-definition-keywords
.
method-expression-body
.
method-expression-task
.
method-head
.
method-name
.
method-p
.
method-p
.
method-preconditions
.
method-task
.
method-task-net
.
methods
.
operator
.
parse-domain-item
.
parse-domain-item
.
parse-domain-item
.
parse-domain-item
.
parse-domain-item
.
parse-domain-items
.
pddl-method-p
.
pddl-plan
.
print-object
.
problem->state
.
process-add-or-delete
.
process-method
.
process-method-pre
.
process-method-pre
.
process-op
.
process-operator
.
record-decomposition
.
regularize-axiom
.
seek-plans
.
seek-plans-nonprimitive
.
seek-plans-null
.
seek-plans-primitive
.
seek-plans-task
.
sort-methods
.
store-plan!
.
task-sorter
.
validator-export
.
Cached copy of the ITEMS source.
This slot is read-only.
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.
:%pddl-types
An object representing a SHOP problem.
:state-atoms
This slot is read-only.
:name
This slot is read-only.
The programmer MAY (but is not obligated to) specify that a problem is intended for use with a particular domain definition.
:domain-name
This slot is read-only.
A MIXIN indicating that a domain should not use IF-THEN-ELSE semantics in methods.
A new class of SHOP3 domain that permits inclusion of PDDL operator definitions.
:source-pddl-domain
This slot is read-only.
Add this to domain classes that should have static predicates defined.
:static-preds
This slot is read-only.
An object representing a SHOP3 theorem prover domain.
Acceptable arguments for SHOP-TRACE (and SHOP-UNTRACE).
Will be bound to a hash table to look up a numerical tag from an operator/action instance.
Will hold a hash table used to insure that all methods have unique names.
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.
Hash table from task names to method choices.
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.
If this variable is bound to T, SHOP will enter a break loop upon backtracking.
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.
Do we build a dependency-enhanced plan tree?
This variable will be DYNAMICALLY bound and used to indicate whether the user wishes to choose tasks for planning by hand.
When T – which should only be for legacy SHOP3 domains – do NOT emit singleton variable warnings.
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.
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.
When NIL, it is safe to tail-call any plan-seeking function.
When building an ENHANCED-PLAN-TREE, do not record causal links. Defaults to NIL.
For iterative-deepening search, what was the maximum depth of the last iteration, so we can avoid duplicate plans.
In some cases we can optimize solutions to :FIRST to find only the first match.
Will be bound to a hash table to look up an operator/action instance from a tag.
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.
Binary numerical operations permitted by the :fluents requirement.
This constant holds a list of method definition keywords that are valid for default SHOP domains.
Numerical comparisons permitted by the :fluents requirement.
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.
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.
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.
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).
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.
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.
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.
Which of the set of IMMEDIATE-TASKS should SHOP2 work on first? Defaults to the first element, unless the user intervenes.
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.
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.
Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
copy-seq
.
Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
copy-seq
.
Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
copy-seq
.
Return a copy of SEQUENCE which is EQUAL to SEQUENCE but not EQ.
copy-seq
.
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.
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.
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.
Search for PATH relative to *COMPILE-FILE-TRUENAME*, *LOAD-TRUENAME*, the cached location of the domain definition file, and *DEFAULT-PATHNAME-DEFAULTS*.
Clear out the data structures (special variables) we use to return plans.
Handle :INCLUDE directives, return a new items list if any are found, otherwise the original list.
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.
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.
Find and return the value of TARGET that’s recorded in BINDING-LIST.
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).
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.
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.
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.
Record the METHOD-ID/METHOD-OBJ association in DOMAIN.
Make an entry in TABLE for OBJ if it’s not already there.
Constructor for ADD-CHILD-TO-TREE objects.
Constructor for ADD-DEPENDENCIES objects.
Constructor for CHOICE-ENTRY objects.
Constructor for METHOD-INSTANTIATION objects.
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.
Constructor for PRIM-STATE-EXPAND objects.
Constructor for RECORD-EXPANSION objects.
Constructor for RECORD-EXPANSION-FOR-REPLAY objects.
Constructor for STATE-TAG objects.
Find all the nodes in NODES whose parent is NODE.
Shuffle the list using an intermediate vector.
Return an ordered list of variable-name instantiator pairs for use in a LET form.
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.
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.
This function translates operator expressions into operator nodes, assembling together the operator, its the position in the plan and cost.
Unpack the return values from PR-LIST, which should be a list of PLAN-RETURN objects.
PRIMITIVEP returns T if X is a symbol whose name begins with #!
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.
Return a copy of LIST with all its members in a random order.