Index of AIMA Code

There are 734 definitions (580 functions, 10 macros, 46 global variables and 19 types) defined in 79 files in the AIMA code. They are listed below in the left column, with links to the overview of each definition (documentation string, and parameter list for functions). From the overview you can link to the source code. The letters F, M, V, and T in the links stand for function, macro, variable and type, respectively; also given is the page number in the book where some of these definitions occur.

In the right column are the 224 built-in Common Lisp symbols used in the code (along with the number of times each is used). You can follow a link to the definition of each one in the Common Lisp Hyperspec (based on the ANSI standard document). You can also go directly to the overview or the code directory.

* A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
AIMA Symbols                                 Common Lisp Symbols
============                                 ===================
                                         *
*4x3-m-data* (1) V                           &aux (55) 
*4x3-mdp* (8) V                              &body (5) 
*4x3-passive-m-data* (1) V                   &environment (1) 
*4x3-passive-mdp* (4) V                      &key (28) 
*4x3-passive-r-data* (1) V                   &optional (71) 
*4x3-r-data* (1) V                           &rest (30) 
*8-puzzle-goal* (4) V                        * (123) 
*8-puzzle-goal-locations* (2) V              *debug-io* (3) 
*alpha* (1) V                                *print-pretty* (1) 
*and-boolean-problem* (0) V                  *random-state* (2) 
*arithmetic-grammar* (4) V                   *standard-output* (2) 
*correct-m* (1) V                            + (80) 
*correct-r* (2) V                            - (129) 
*correct-u* (1) V                            / (26) 
*debugging* (2) V                            /= (5) 
*e0* (4) V                                   1+ (10) 
*e1* (3) V                                   < (32) 
*e2* (2) V                                   <= (14) 
*ex-19-4-boolean-problem* (0) V              = (72) 
*figure23.4* (0) V                           > (23) 
*grammar* (19) V                             >= (17) 
*infix-ops* (1) V                            
*majority-boolean* (0) V                     
*majority-boolean-problem* (1) V             
*ne* (1) V                                   
*new-variable-counter* (2) V                 
*page250-supermarket* (1) V                  
*policy-fn* (1) V                            
*r+* (1) V                                   
*restaurant-boolean* (0) V                   
*restaurant-boolean-problem* (1) V           
*restaurant-multivalued* (0) V               
*restaurant-multivalued-problem* (1) V       
*restaurant-real* (0) V                      
*restaurant-real100-problem* (0) V           
*restaurant-real12-problem* (1) V            
*romania-map* (1) V                          
*scene-4.17* (1) V                           
*vacuum-home* (2) V                          
*xor-boolean-problem* (0) V                  
+fail+ (14) V                                
+logical-connectives+ (1) V                  
+logical-quantifiers+ (1) V                  
+no-bindings+ (9) V                          
->cnf (5) F                                  
->horn (3) F                                 
->inf (3) F                                  
->minimal-cnf (3) F                          
->prefix (2) F                               
8-puzzle-display-fn (0) F                    
8-puzzle-goal-location (1) F                 
8-puzzle-legal-moves (1) F                   
8-puzzle-location (2) F                      
8-puzzle-print (1) F                         
8-puzzle-ref (7) F                           
8-puzzle-state (0) F                         
9-power (3) F                                
@ (40) F                                     
                                             
                                         A
a*-search (11) [p. 97] F                     abs (14) 
absolute-loc (1) F                           alphanumericp (2) 
accuracy (6) F                               and (90) 
action-model (17) F                          append (13) 
actions (29) F                               apply (19) 
active-adp-agent (0) [p. 608]                aref (23) 
add-edge (4) [p. 702] F                      array (10) 
add-locs (3) F                               array-dimension (5) 
add-test (1) F                               array-dimensions (2) 
agent-body (71) T                            array-total-size (1) 
agent-trial (1) F                            assert (10) 
agent-trials (1) F                           assoc (20) 
agent-with-name (2) F                        atom (15) 
aimless-wumpus-agent (1) T                   
align (0) [p. 754]                           
all-q-entries (1) F                          
all-related-to? (0) [p. 322]                 
all-truth-interpretations (1) F              
alpha-beta-decision (1) F                    
alpha-value (2) F                            
appearance (2) F                             
arg1 (28) F                                  
arg2 (18) F                                  
args (75) F                                  
array->vector (1) F                          
ask (7) F                                    
ask-each (4) F F F F                         
ask-game-user (1) F                          
ask-pattern (2) F                            
ask-patterns (3) F                           
ask-user (1) F                               
assign-agent-scores (2) F                    
atomic-clause? (4) F                         
attribute-name (3) F                         
attribute-value (17) F                       
attribute-values (1) F                       
average (1) F                                
average-successor-q (1) F                    
                                             
                                         B
back-chain (0) [p. 275]                      bignum (2) 
back-chain-each (1) F                        bit-vector (2) 
back-chain-list (0) [p. 275]                 boundp (1) 
back-prop-update (0) [p. 581]                butlast (2) 
backprop-learning (0) F                      
backprop-update (2) F                        
backprop-update-layer (2) F                  
backpropagate (1) F                          
belief-net-ask (0) [p. 452]                  
best-first-search (3) [p. 93] F              
beta-value (1) F                             
between (2) F                                
binding-val (1) F                            
binding-var (0) F                            
bits-required (2) F                          
blank-square (2) F                           
boolean-error (3) F                          
bottom-up-parse (0) [p. 666]                 
breadth-first-search (1) [p. 74] F           
build-road (1) F                             
build-truth-table (2) F                      
                                             
                                         C
call-method-for (6) F                        caar (4) 
cannibal-state (0) T                         cadr (5) 
cannibals-can-eat? (1) F                     call-next-method (7) 
categories-for (2) F                         car (42) 
chart-parse (2) [p. 702] F                   case (14) 
chart-parses (9) F                           cdar (4) 
check-k-in-a-row (4) F                       cdr (54) 
check-tsp-map? (1) F                         ceiling (1) 
choose-operator (0) [p. 385]                 char (4) 
city (15) T                                  class (4) 
classify (0) F                               complex (2) 
climb (3) F                                  cond (69) 
cnf1->inf1 (1) F                             condition (2) 
code-example (1) F                           cons (83) 
code-examples (1) F                          consp (9) 
code-unclassified-example (1) F              constantp (1) 
compare-search-algorithms (8) F              copy-list (2) 
complete? (5) F                              count (1) 
completer (1) [p. 702] F                     count-if (1) 
complex-sentences-in (1) F                   count-if-not (1) 
compose (4) F                                
compute-deltas (1) F                         
compute-truth-entries (1) F                  
concat-symbol (4) F                          
conditional-planning-agent (0) [p. 395]      
conjunction (12) F                           
conjuncts (12) F                             
consistent (0) F                             
consistent-det? (0) [p. 635]                 
copy-array (1) F                             
copy-hash-table (9) F                        
copy-subarray (1) F                          
count-pieces-in-direction (2) F              
cpop (0) [p. 395]                            
create-polygon (1) F                         
create-scene (1) F                           
create-sorted-tree (0) F                     
create-start-node (6) F                      
csp-backtracking-search (2) F                
csp-conflicts (1) F                          
csp-empty-domainp (1) F                      
csp-explicit-check (1) F                     
csp-forward-checking-search (1) F            
csp-legal-assignmentp (1) F                  
csp-legal-statep (3) F                       
csp-legal-values (1) F                       
csp-modifications (0) F                      
csp-random-completion (1) F                  
csp-termination (0) F                        
csp-var (0) T                                
current-agent (2) F                          
current-alpha (2) F                          
current-best-learning (0) [p. 547]           
current-player (5) F                         
                                             
                                         D
deadly? (1) F                                decf (15) 
decision-list-learning (1) [p. 556] F        declare (34) 
decision-theoretic-agent (0) [p. 511]        defconstant (6) 
decision-tree-learning (1) [p. 537] F        defmacro (11) 
declare-ignore (15) F                        defmethod (106) 
deepest-least-leaf (1) F                     defparameter (12) 
define-if-undefined (1) M                    defsetf (2) 
defmethod (0) M                              defstruct (20) 
defstructure (69) M                          defun (484) 
deftest (7) M                                defvar (28) 
delete-element (3) F                         delete (4) 
deletef (8) M                                delete-duplicates (3) 
depth-first-search (0) [p. 78] F             destructuring-bind (10) 
depth-limited-search (1) F                   do (99) 
destructuring-bind (0) M                     dolist (46) 
dfs-contour (1) [p. 107] F                   dotimes (29) 
disjunction (3) F                            
disjuncts (11) F                             
display-environment (2) F F                  
display-environment-snapshot (1) F F         
display-expand (1) F                         
distribution (2) F                           
dll (1) F                                    
dlpredict (1) F                              
dmax-choice (1) F                            
dot-product (2) F                            
dprint (5) F                                 
dt-agent (0) [p. 419]                        
dtl (1) F                                    
dtpredict (1) F                              
                                             
                                         E
edge (54) F                                  elt (17) 
edge->tree (1) F                             ensure-generic-function (3) 
edge-cost (1) F F F F                        eq (105) 
edge-equal (1) F                             eql (13) 
edge-expects (3) F                           equal (89) 
eliminate-all-duplicates (1) F               equalp (2) 
eliminate-cycles (1) F                       error (23) 
eliminate-implications (1) F                 eval (2) 
eliminate-returns (1) F                      every (16) 
empty-queue? (3) F                           exp (70) 
empty-tree (1) F                             expt (1) 
enqueue-at-end (3) F                         
enqueue-at-front (4) F                       
enqueue-by-priority (2) F                    
ensure-generic-function (0) F                
eval-truth (1) F                             
evidence-except (0) [p. 452]                 
execute-agent-actions (2) F                  
expand (9) F                                 
exploration-choice (1) F                     
exploration-function (3) F                   
exploration-q-choice (1) F                   
exploratory-value-iteration (1) F            
extend-bindings (2) F                        
extend-example (0) [p. 643]                  
                                             
                                         F
false (9) F                                  fboundp (2) 
feel (4) F                                   fill-pointer (1) 
filter-domains (1) F                         find (13) 
find-and-infer (0) [p. 273]                  find-if (2) 
find-anywhere-if (0) F                       find-package (2) 
find-city (7) F                              first (79) 
find-element (0) F                           fixnum (8) 
find-leaf (0) F                              float (11) 
find-neighbor-if (1) F                       floor (5) 
find-object-if (15) F                        format (61) 
find-object-or-neighbor-if (2) F             fourth (1) 
find-transform (0) [p. 753]                  funcall (70) 
foil (0) [p. 643]                            function (417) 
fol-kb (3) T                                 
for (79) M                                   
for-each (1) M                               
forward (14) F                               
forward-chain (0) [p. 273]                   
free-loc? (3) F                              
function-symbol? (1) F                       
fuzz (2) F                                   
                                             
                                         G
game->environment (1) F                      gensym (5) 
game-over? (5) F F                           get (13) 
game-players (0) F                           getf (4) 
game-successors (7) F                        gethash (114) 
general-search (7) [p. 73] F                 go (3) 
generate-terms (1) F                         
genetic-algorithm (0) [p. 620]               
get-binding (7) F                            
get-percept (1) F F F F F F F                
get-unit-inputs (1) F                        
goal-test (9) F F F F                        
grab (9) F                                   
grabable? (1) F                              
grammar (12) F                               
greedy-search (1) [p. 93] F                  
grid-contents (4) F                          
gsat (0) [p. 183]                            
                                             
                                         H
h-cost (3) F F F F F                         
handle-augmentation (1) F                    
handle-quantifiers (1) F                     
hash-table->list (0) F                       
hd-pop (0) [p. 374]                          
heading->string (1) F                        
heap-extract-min (2) F                       
heap-insert (2) F                            
heap-left (1) F                              
heap-parent (3) F                            
heap-right (1) F                             
heap-sort (2) F                              
heap-val (5) F                               
heapify (1) F                                
hear (1) F                                   
hill-climbing (0) [p. 112]                   
hill-climbing-search (3) F                   
hill-climbing-until-flat-n-times-search (0) F
horn-clause? (1) F                           
hprint (0) F                                 
                                             
                                         I
ida* (0) [p. 107]                            identity (17) 
incremental-learning-curve (0) F             if (120) 
infinity (14) V                              ignore (29) 
information-value (1) F                      incf (57) 
initialize (1) F F F F F                     integer (6) 
initialize-agent-names (1) F                 intern (5) 
inorder-successor (1) F                      
insert (1) F                                 
insert-between (1) F                         
insert-element (4) F                         
inside (2) F                                 
integer (0) [p. 856]                         
intersects (1) F                             
iota (7) F                                   
iterative-deepening-search (0) [p. 79] F     
                                             
                                         K
kb-agent (0) [p. 202]                        keyword (2) 
kill (5) F                                   
                                             
                                         L
largest-key (0) F                            labels (2) 
last1 (7) F                                  lambda (165) 
leafp (1) F                                  last (6) 
learning-curve (0) F                         length (54) 
learning-problem (0) T                       let (180) 
least-key (0) F                              let* (39) 
left-rotate (1) F                            list (147) 
leftmost (4) F                               list* (2) 
legal-actions (1) F F F F                    listp (3) 
legal-move? (1) F                            log (1) 
legal-moves (7) F F F                        loop (15) 
length=1 (3) F                               lower-case-p (1) 
length>1 (5) F                               
lhs-op (3) F                                 
line-intersects-poly? (1) F                  
list-elements (0) F                          
literal-clause? (2) F                        
lms-update (1) [p. 602] F                    
local-minimum (0) F                          
logic (10) F                                 
lookup (6) F                                 
looping-node? (2) F                          
loss (0) F                                   
                                             
                                         M
majority (3) F                               macro-function (2) 
majority-perceptron (1) F                    make-array (9) 
make (2) F                                   make-broadcast-stream (1) 
make-active-adp-learner (2) F                make-hash-table (37) 
make-active-qi-learner (2) F                 make-list (4) 
make-binding (2) F                           make-random-state (4) 
make-cognac-game (1) F                       map (29) 
make-connected-nn (2) F                      mapc (8) 
make-eliminating-queuing-fn (1) F            mapcan (3) 
make-empty-queue (1) F                       mapcar (74) 
make-exp (5) F                               maphash (14) 
make-exp-schedule (1) F                      mapl (2) 
make-exploring-adp-learner (1) F             max (11) 
make-exploring-tdq-learner (1) F             member (30) 
make-heap (2) F                              merge (1) 
make-initial-queue (3) F                     min (5) 
make-logic-symbol (1) F                      mod (3) 
make-maximizing-adp-learner (1) F            most-negative-single-float (1) 
make-maximizing-qi-learner (1) F             most-positive-single-float (1) 
make-mdp-agent (7) F                         multiple-value-bind (5) 
make-move (2) F F                            multiple-value-setq (1) 
make-nqueens-problem (2) F                   
make-passive-adp-learner (0) F               
make-passive-lms-learner (1) F               
make-passive-td-learner (1) F                
make-path-planning-problem (1) F             
make-perceptron (2) F                        
make-random-adp-learner (0) F                
make-random-qi-learner (0) F                 
make-search-tree (2) F                       
make-tsp-problem (2) F                       
make-ttt-game (3) F                          
mappend (4) F                                
max-choice (2) F                             
max-value (0) [p. 132]                       
mdp (55) T                                   
mdp-action-model (0) T                       
mdp-next-state (1) F                         
mdp-percept (0) T                            
mdp-transitions (1) F                        
meanings (3) F                               
member? (0) [p. 322]                         
merge-disjuncts (1) F                        
min-conflicts-value (0) F                    
min-value (0) [p. 132]                       
minimal-consistent-det (0) [p. 635]          
minimax-cutoff-decision (0) F                
minimax-cutoff-value (1) F                   
minimax-decision (1) [p. 126] F              
minimax-value (1) [p. 126] F                 
minimum-or-flat (1) F                        
minimum-or-flat-n-times (1) F                
minus-infinity (0) V                         
misplaced-tile? (1) F                        
misplaced-tiles (0) F                        
modify-assignment (1) F                      
most-constrained-variable (0) F              
move-blank (2) F                             
move-not-inwards (1) F                       
move-object-to (1) F                         
ms-error (1) F                               
                                             
                                         N
near? (1) F                                  nconc (9) 
nearest-neighbor-distance (3) F              not (63) 
negative-clause? (3) F                       nreverse (5) 
neighbors (2) F                              nth (5) 
network-output (3) F                         nthcdr (2) 
neural-network-learning (0) [p. 577]         null (67) 
new-clause (3) [p. 643]                      number (20) 
new-variable (2) F                           numberp (1) 
nn-error (1) F                               
nn-learning (4) F                            
nn-output (2) F                              
no-cycles-depth-first-search (1) F           
no-duplicates-breadth-first-search (3) F     
no-returns-breadth-first-search (1) F        
node (107) [p. 72]                           
nondeterministic-chart-parse (0) [p. 699]    
normal (0) F                                 
nothing (6) F                                
nqueens-constraint-fn (1) F                  
nqueens-constraints (1) F                    
nqueens-initial-state (1) F                  
number->name (1) F                           
                                             
                                         O
object-words (1) F                           oddp (1) 
obstacle (1) T                               or (66) 
occurs-in? (1) F                             otherwise (2) 
offset-loc (0) F                             
op (66) F                                    
op-match (1) F                               
op-name (4) F                                
op-token (0) F                               
op-type (2) F                                
openp (1) F                                  
operator-char? (2) F                         
optimal-policy (2) F                         
                                             
                                         P
parse-infix-token (1) F                      parse-integer (1) 
parse-n (2) F                                pi (1) 
parse-span (2) F                             plusp (3) 
parse-spec (1) F                             pop (11) 
parse-specs (4) F                            position (5) 
parse-what (2) F                             position-if (1) 
parse-whats (9) F                            position-if-not (2) 
parse-where (1) F                            princ (2) 
passes (2) F                                 print (4) 
passive-policy (1) F                         progn (8) 
passive-rl-agent (0) [p. 602]                push (52) 
path-lower-bound (1) F                       pushnew (5) 
perceptron-learning (0) F                    
perceptron-update (2) F                      
performance-measure (1) F F F F F F          
pick-random-move (1) F                       
place-in-container (2) F                     
place-object (3) F                           
plot-alist (0) F                             
policy-choice (1) F                          
policy-iteration (0) [p. 506] F              
pop (0) [p. 356]                             
pop-largest-element (0) F                    
pop-least-element (0) F                      
possible-resolvers (1) F                     
predictor (1) [p. 702] F                     
prefix->infix (1) F                          
previous-player (2) F                        
print-centered (4) F                         
print-dashes (5) F                           
print-grid (2) F                             
print-learning-problem (1) F                 
print-nn (0) F                               
print-repeated (6) F                         
print-solution (1) F                         
print-structure (1) F F F F F F F F F F F    
print-truth-table (1) F                      
problem (171) [p. 60]                        
problem->environment (1) F                   
problem-solving-program (1) F                
prop-symbols-in (1) F                        
propagate-arrow (1) F                        
propositional-kb-agent (0) [p. 177]          
prove-by-refutation (1) F                    
                                             
                                         Q
q (130) T                                    quote (416) 
q-actions (2) F                              
q-dmax-choice (1) F                          
q-entry (4) F                                
q-iteration (1) F                            
q-learning-agent (0) [p. 614]                
q-max-choice (1) F                           
q-optimal-policy (0) F                       
q-random-choice (1) F                        
q-value (8) F                                
queue-front (0) F                            
                                             
                                         R
random-8-puzzle-state (1) F                  random (19) 
random-choice (1) F                          random-state (2) 
random-conflicted-variable (1) F             ratio (2) 
random-element (18) F                        rational (6) 
random-examples (0) F                        read (2) 
random-integer (2) F                         real (6) 
random-loc (2) F                             reduce (1) 
random-move-blank (1) F                      remove (10) 
random-restart-search (0) F                  remove-if (5) 
random-route-map (2) F                       remove-if-not (9) 
random-transition (1) F                      rest (46) 
random-tsp-map (1) F                         restart (4) 
random-weights (2) F                         return (47) 
randomized-insert-element (0) F              return-from (3) 
randomized-push (1) F                        reverse (5) 
rbdtl (0) [p. 635]                           rotatef (4) 
reduce-infix (1) F                           round (4) 
reduce-matching-op (1) F                     
reflex-learning-element (0) [p. 530]         
reflex-performance-element (0) [p. 530]      
related-to? (0) [p. 322]                     
release (3) F                                
remove-commas (1) F                          
remove-front (3) F                           
remove-object (2) F                          
rename-variables (2) F                       
renaming? (7) F                              
replace-subseq (5) F                         
replanning-agent (0) [p. 402]                
required (7) F                               
resolve (0) F                                
resolve-threats (0) [p. 385]                 
retract (0) F F F F                          
retract-minimal-cnf-clauses (2) F            
return-node? (1) F                           
reuse-cons (1) F                             
rewrites-for (2) F                           
right-rotate (9) F                           
rightmost (3) F                              
rms-error (1) F                              
road-distance (6) F                          
rotate (2) F                                 
round-off (4) F                              
rule-lhs (3) F                               
rule-rhs (2) F                               
run-environment (16) [p. 49] F               
run-eval-environment (0) [p. 49] F           
run-game (4) F                               
running-average (2) F                        
                                             
                                         S
sample-with-replacement (0) F                second (18) 
sample-without-replacement (2) F             sequence (5) 
scanner (1) [p. 702] F                       set-difference (1) 
search-tree-node (0) T                       setf (197) 
see (6) F                                    setq (138) 
see-loc (1) F                                some (16) 
select-attribute (1) F                       sort (2) 
select-k-test (1) F                          special (1) 
select-sub-goal (0) [p. 385]                 sqrt (5) 
select-subgoal (0) [p. 356]                  step (1) 
select-test (1) F                            stream (76) 
sem-net-node (0) [p. 321]                    string (27) 
sentence-output-form (1) F                   string-equal (1) 
shallowest-largest-leaf (1) F                string-upcase (2) 
shoot (7) F                                  stringp (4) 
shut-off (4) F                               structure (3) 
sigmoid (1) F                                sublis (5) 
sign-function (0) F                          subseq (4) 
simple-communicating-agent (0) [p. 663]      subst (1) 
simple-planning-agent (0) [p. 338]           svref (6) 
simple-policy-agent (0) [p. 501]             symbol (5) 
simple-problem-solving-agent (0) [p. 57]     symbol-function (4) 
simple-reflex-agent (0) [p. 41]              symbol-name (2) 
simulated-annealing (0) [p. 113]             symbolp (9) 
simulated-annealing-search (1) F             
sink? (4) F                                  
situated-planning-agent (0) [p. 408]         
skolem-constant (2) F                        
skolemize (1) F                              
sma* (0) [p. 110]                            
solution-actions (3) F                       
solution-nodes (2) F                         
solve (10) F                                 
spanning-edges (2) F                         
speak (1) F                                  
square (27) F                                
starts-with (1) F                            
step-function (2) F                          
straight-distance (3) F                      
string->infix (1) F                          
stringify (2) F                              
subset? (0) [p. 322]                         
subst-bindings (5) F                         
subtract-locs (0) F                          
successors (11) F F F F F F F                
suck (4) F                                   
sum (34) F                                   
summation (0) [p. 851]                       
supertype (7) F                              
support-except (0) [p. 452]                  
symbol-char? (2) F                           
                                             
                                         T
table-driven-agent (0) [p. 38]               t (166) 
take-the-boat (1) F                          terpri (2) 
tautology? (1) F                             the (25) 
td-update (1) [p. 605] F                     third (1) 
tell (32) F F F F                            time (5) 
tell-minimal-cnf-clause (2) F                type (158) 
terminal-values (4) F                        type-of (11) 
termination? (2) F F F F F F                 typecase (1) 
test (22) F                                  
test-example (1) F                           
the-biggest (14) F                           
the-biggest-random-tie (5) F                 
the-biggest-that (2) F                       
the-smallest (1) F                           
the-smallest-random-tie (2) F                
the-smallest-that (1) F                      
transition (19) T                            
transitions (10) F                           
transpose (1) F                              
tree-a*-search (1) F                         
tree-backup-f-cost (1) F                     
tree-get-next-successor (1) F                
tree-ida*-search (1) F                       
tree-prune-open (1) F                        
tree-sma (0) F                               
tree-unexpand-successor (1) F                
true (10) F                                  
truth-table (1) F                            
tsp (0) T                                    
tsp-city-name (6) F                          
tsp-start (3) F                              
ttt-eval (1) F                               
turn (23) F                                  
                                             
                                         U
u-rms-error (0) F                            unless (42) 
undo-temp-changes (1) F                      
unifier (0) F                                
uniform-classification (1) F                 
uniform-cost-search (1) F                    
unify (8) [p. 303] F                         
unify-internal (0) [p. 303]                  
unify-var (2) F                              
unique-find-anywhere-if (1) F                
unit (21) T                                  
unit-output (1) F                            
update-active-model (3) F                    
update-exploratory-q (1) F                   
update-fn (1) F F F F F F                    
update-passive-model (1) F                   
use-8-puzzle-goal (1) F                      
                                             
                                         V
vacuum-goalp (1) F                           values (26) 
vacuum-initial-state (1) F                   vector (6) 
vacuum-problem (0) F                         vector-push-extend (1) 
vacuum-state (0) T                           
vacuum-successors (1) F                      
validity (8) F                               
value-determination (3) F                    
value-iteration (2) [p. 504] F               
value-iteration-policy (2) F                 
variable? (9) F                              
variables-in (1) F                           
version-space-learning (0) [p. 549]          
vertices-in-view (1) F                       
vertices-visible-from (1) F                  
visible-p (1) F                              
                                             
                                         W
wall (3) T                                   warn (3) 
while (3) M                                  when (130) 
whitespace? (1) F                            with-open-file (1) 
with-simple-restart (0) M                    with-simple-restart (1) 
                                             
                                         X
x+y-distance (1) F                           
xy (9) T                                     
xy-add (4) F                                 
xy-between (0) F                             
xy-distance (4) F                            
xy-equal (3) F                               
xy-p (1) F                                   
                                             
                                         Z
zoom (0) F