# 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