Common Lisp Package: KM

README:

FUNCTION

Private

ADD-QUOTE-IF-NEEDED (X)

Quote X if necessary.

COMPILE-HANDLERS (HANDLERS &KEY CODE-ONLY)

Compile the handler-alist Handlers. If code-only is T, then just return the code without invoking the compiler on it.

COMPILE-RULES (RULES VAR)

A rules is of the form (pat code) where code may reference vars in pat.

DELAY-FUNCTION (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

DELAY-VALUE (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

INVERT-PREDICATE (PREDICATE &OPTIONAL (ARGNUM 2))

return the inverse variant of PREDICATE such that the first and ARGNUMth args have been swapped.

Undocumented

&&-EXPRP (EXPR)

&&-EXPRS-TO-VALSETS (EXPRS)

&-EXPR-TO-VALS (EXPR)

&-EXPRP (EXPR)

A-SPACE (WORD1 WORD2)

ACONSP (OBJ)

ADD-BINDING (X Y BINDINGS)

ADD-DOUBLEQUOTES (STRING)

ADD-ESCAPES (STRING SPECIALS)

ADD-IMMEDIATE-CLASS (INSTANCE0 NEW-IMMEDIATE-PARENT EXPLANATION)

ADD-LISP&KM-FUNCTION (NAME)

ADD-QUOTES (OBJ)

ADD-SLOTSVALS (INSTANCE ADD-SLOTSVALS &KEY (FACET 'OWN-PROPERTIES) (INSTALL-INVERSESP T) (SITUATION (CURR-SITUATION)) COMBINE-VALUES-BY (BIND-SELFP T))

ADD-SUPPORT (TRIPLE SUPPORT &KEY (SITUATION (CURR-SITUATION)))

ADD-TO-ACTIVE-SITUATIONS (SITUATION)

ADD-TO-PROTOTYPE-DEFINITION (PROTOTYPE EXPR)

ADD-TO-SOURCE (SOURCE ITEM)

ADD-TRIPLE (TRIPLE)

ADD-TRIPLE-ASIF-CLONED (TRIPLE N SOURCE-TRIPLE SOURCE-ROOT)

ADD-VAL (INSTANCE SLOT VAL &OPTIONAL (INSTALL-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

ADD-VAL-TO-GROUP (VAL GROUPS NON-UNIFIABLE-PAIRS)

ADD-VALS (INSTANCE SLOT VALS &OPTIONAL (INSTALL-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

AGGREGATE-VALS (FUNCTION VALS)

ALL-ACTIVE-SITUATIONS

ALL-ADJACENT-PAIRS (LIST)

ALL-APPLICABLE-PROTOTYPES (INSTANCE &OPTIONAL SLOT)

ALL-CLASSES (INSTANCE)

ALL-INSTANCES (CLASS)

ALL-NEXT-SITUATIONS

ALL-PAIRS (LIST)

ALL-PROTOINSTANCES (CLASS)

ALL-PROTOTYPES (CLASS)

ALL-SITUATIONS

ALL-SITUATIONS-AND-THEORIES

ALL-SUBCLASSES (CLASS)

ALL-SUBCLASSES0 (CLASS &KEY PATH-SO-FAR)

ALL-SUBSLOTS (SLOT)

ALL-SUPERCLASSES (CLASS)

ALL-SUPERCLASSES0 (CLASS &KEY PATH-SO-FAR)

ALL-SUPERSITUATIONS (SITUATION)

ALL-SUPERSITUATIONS0 (SITUATION)

ALL-SUPERSLOTS (SLOT)

ALL-THEORIES

ALLOF-MUST (VAR SET TEST)

ALLOF-WHERE-MUST (VAR SET TEST2 TEST)

ALREADY-DONE (FRAME SLOT &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

AM-IN-GLOBAL-SITUATION

AM-IN-LOCAL-SITUATION

AM-IN-LOCAL-SITUATION-OR-THEORY

AM-IN-LOCAL-THEORY

AM-IN-PROTOTYPE-MODE

AM-IN-SITUATIONS-MODE

AND-APPEND (XS0 AND-SYMBOL YS0)

AND-APPEND2 (X AND-SYMBOL Y)

AND-LISTP (LIST AND-SYMBOL)

AND-MEMBER (EL LIST AND-SYMBOL)

ANDIFY (VALS)

ANNOTATE-EMBEDDED-STRUCTURES (EXPR SOURCE)

ANNOTATE-EVERY-EXPR (EVERY-EXPR &OPTIONAL SOURCE (SEARCH-FOR 'EVERY))

ANNOTATE-EVERY-EXPR0 (EVERY-EXPR &OPTIONAL SOURCE (SEARCH-FOR 'EVERY))

ANNOTATE-SLOTSVALS (SLOTSVALS SOURCE)

ANNOTATE-VAL (VAL SOURCE &KEY EMBEDDED-STRUCTUREP)

ANNOTATE-VALS (VALS SOURCE &KEY EMBEDDED-STRUCTUREP)

ANONYMOUS-INSTANCE-NAME (CONCEPT &KEY HTMLIFY)

ANONYMOUS-INSTANCEP (INSTANCE0)

ANONYMOUS-MINIMATCH-VARP (VAR)

APAIRP (LIST)

APPEND-BAGS (BAG-OF-BAGS)

APPEND-LIST (LIST)

APPEND-SEQS (SEQ-OF-SEQS)

APPLY-HANDLER (HANDLER)

APPLY-RECURSIVE (FUNCTION STRUCTURE)

APPLY-TO-FILE-EXPRS (FUNCTION FILE)

APPLY-TO-FILE-LINES (FUNCTION FILE)

ARE-CONSISTENT-WITH-CONSTRAINTS (VALS0 CONSTRAINTS0 SLOT)

ARE-SLOTSVALS (SLOTSVALS)

AREVERSE (A-DOT-B)

ARG1OF

ARG2OF (ARG-STRUCTURE)

ARG3OF (ARG-STRUCTURE)

ARG4OF (ARG-STRUCTURE)

ARGS-TO-SYMBOL (&REST ARGS)

ASSOC-EQUAL (ITEM ALIST)

ASSOC-SORT (LIST)

ATOMIC-ACONSP (X)

ATRANSPOSE (LIST)

ATTACH-SOURCE-TO-EXPR (EXPR SOURCE)

BAG-EQUAL (BAG1 BAG2)

BAG-EQUAL0 (BAG1 BAG2)

BAG-TO-LIST (BAG)

BEFORE-SITUATION (EVENT)

BIND (X Y)

BIND-SELF (EXPR SELF)

BINDINGS-FOR (PATTERN)

BLOCK-LIST (ADD-LIST)

BOUND (FRAME1)

BREAK-LIST (LIST &KEY TEST)

BREAK-STRING-AT (STRING BREAK-CHAR)

BREAK-UP (STRING &OPTIONAL (DELIM-CHARS '( )))

BREAK-UP-AT (STRING &KEY DELIMETER-CHARS)

BREAK-UP-AT0 (DELIMETER-CHARS STRING M N NMAX POLARITY)

BREAK-UP2 (STRING M N NMAX QUOTEP &OPTIONAL (DELIM-CHARS '( )))

BREAKUP-EXISTENTIAL-EXPR (EXPR0 &KEY (FAIL-MODE 'FAIL))

BUILD-CLONE (PROTOTYPE MAPPING-ALIST &KEY INCLUDING-EXTRA-SLOTS)

BUILD-CLONES (PROTOTYPE &KEY INCLUDING-EXTRA-SLOTS)

BUILD-EMBEDDED-VAL (PATH EXPR &KEY (EVERY-A 'a) (HAS-WITH 'with))

BUILD-RULE (EXPR0 &KEY IGNORE-CONSTRAINTSP)

BUILT-IN-AGGREGATION-SLOT (SLOT)

BUILT-IN-BAG-AGGREGATION-SLOT (SLOT)

BUILT-IN-CONCEPT (CONCEPT)

BUILT-IN-CONCEPT-TYPE (CONCEPT)

BUILT-IN-SEQ-AGGREGATION-SLOT (SLOT)

BUILT-IN-SET-AGGREGATION-SLOT (SLOT)

BUILT-IN-SLOT (SLOT)

BUTFIRST-CHAR (STRING)

BUTLAST-CHAR (STRING)

BUTLAST-WORD (STRING)

CACHE-EXPLANATION-FOR (VAL EXPR0)

CACHED-EXPLANATIONS-FOR (INSTANCE &OPTIONAL (SITUATION (CURR-SITUATION)))

CANONICALIZE (EXPR)

CAPITALIZE (STRING)

CARDINALITY-OF (SLOT)

CARDINALITY-OF2 (SLOT)

CASE-SENSITIVE-READ (&OPTIONAL STREAM (EOF-ERR-P T) EOF-VAL REC-P)

CASE-SENSITIVE-READ-FILE-EXPRS (FILE)

CASE-SENSITIVE-READ-FROM-STRING (&OPTIONAL (EOF-ERR-P T) EOF-VAL)

CASE-SENSITIVE-READ-KM (&OPTIONAL STREAM (EOF-ERR-P T) EOF-VAL REC-P)

CATCH-EXPLANATION (KMEXPR-WITH-COMMENTS MODE)

CATCH-EXPLANATIONS

CHANGE-TO-SITUATION (SITUATION)

CHECK-CLASSIFICATION-WITH-USER (INSTANCE POSSIBLE-NEW-PARENT)

CHECK-DOMAIN-AND-RANGE (INSTANCE SLOT VALS)

CHECK-FOR-CYCLES

CHECK-FOR-CYCLES0 (CLASS &KEY DONE)

CHECK-ISA-SLOT-OBJECT (SLOT)

CHECK-SITUATIONS-MODE (INSTANCE SLOT)

CHECK-SLOT (FRAME SLOT VALUES)

CHECK-SLOTVALS-CONSTRAINTS (SLOT I1 I2 EXPRS1 EXPRS2 &KEY CS1 CS2 CLASSES-SUBSUMEP EAGERLYP (FAIL-MODE 'FAIL))

CHECK-SLOTVALS-CONSTRAINTS0 (SLOT I1 I2 EXPRS1 EXPRS2 &KEY CS1 CS2 CLASSES-SUBSUMEP EAGERLYP (FAIL-MODE 'FAIL))

CHECKKBOFF

CHECKKBON

CHECKKBP

CHECKPOINT-ID (X)

CHECKPOINT-P (X)

CLASS-DESCRIPTION-TO-CLASS+SLOTSVALS (EXPR &KEY (FAIL-MODE 'FAIL))

CLASS-DESCRIPTIONP (EXPR &KEY (FAIL-MODE 'FAIL))

CLASS-HAS-SOMETHING-TO-SAY-ABOUT (INSTANCE SLOT &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

CLASS-IN-EXISTENTIAL-EXPR (EXISTENTIAL-EXPR)

CLASSES-IN-DESCRIPTION (EXPR)

CLASSES-SUBSUME-CLASSES (CLASSES1 CLASSES2)

CLASSIFICATION-ENABLED

CLASSIFY (INSTANCE &KEY (SLOTS-THAT-CHANGED 'UNSPECIFIED) SLOT-OF-INTEREST)

CLASSIFY-AS-COREFERENTIAL (INSTANCE0 PARENT &KEY SLOTS-THAT-CHANGED SLOT-OF-INTEREST)

CLASSIFY-AS-MEMBER (INSTANCE PARENT &KEY SLOTS-THAT-CHANGED SLOT-OF-INTEREST)

CLASSIFY-AS-PROTOTYPE (INSTANCE PARENT &KEY SLOTS-THAT-CHANGED SLOT-OF-INTEREST)

CLASSIFY-AS-PROTOTYPE0 (INSTANCE PROTOROOT)

CLASSIFY0 (INSTANCE &KEY SLOTS-THAT-CHANGED SLOT-OF-INTEREST)

CLASSP (CLASS)

CLEAN-TAXONOMY (&KEY SILENTP)

CLEAR-ALL-EXPLANATIONS

CLEAR-EVALUATION-CACHE

CLEAR-EXPLANATIONS (&KEY CLEAR-GLOBALP)

CLEAR-GOAL-STACK

CLEAR-NODES-CLONED-TO-CACHE

CLEAR-OBJ-STACK

CLEAR-SCREEN

CLEAR-SILENT-SPY-LOG

CLEAR-SILENT-SPYPOINTS-STACK

CLEAR-SITUATIONS

CLONE (PROTOTYPE0 &KEY INCLUDING-EXTRA-SLOTS WITHOUT-BOOKKEEPING)

CLONE-BUILT-FROM* (F &KEY DONE)

CLONE-CYCLE (EXPLANATION)

CLONE-WITHOUT-BOOKKEEPING (PROTOTYPE &KEY INCLUDING-EXTRA-SLOTS)

CLONED-FROM* (F &KEY DONE)

CLOSE-STREAM (STREAM)

COLLECT-CLONESETS (NODES ISV-EXPLANATIONS CLONE-OPERATION-ID)

COLLECT-CONSTRAINTS+SOURCES-ON-INSTANCE (INSTANCE SLOT &KEY (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)) RETAIN-COMMENTSP IGNORE-PROTOTYPES)

COLLECT-CONSTRAINTS-ON-INSTANCE (INSTANCE SLOT &KEY RETAIN-COMMENTSP IGNORE-PROTOTYPES (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

COLLECT-PROTOTYPES-FOR-CLASSES (ORDERED-CLASSES CLASS+PROTOROOTS-LIST &KEY COLLECTED-SO-FAR)

COMBINE-ATTVALS (LIST DICT &KEY (N-ENTRIES (1- (LENGTH (FIRST DICT)))) (NULL-ENTRY '0))

COMBINE-BINDINGS (BINDINGS1 BINDINGS2)

COMBINE-EXPLANATIONS (EXPLANATIONS)

COMBINE-VALUES-BY-APPENDING-SLOTP (SLOT)

COMMAED-LIST (LIST &OPTIONAL (DELIMETER , ))

COMMAIFY (VALS)

COMMENT (COMMENT-TAG DATA)

COMMENT-OR-SOURCEP (TAG)

COMMENT-TAGP (TAG)

COMMENTS

COMMON-STARTSTRING (STRINGS)

COMPARISON-OPERATOR (SLOT)

COMPATIBLE-CLASSES (&KEY INSTANCE1 INSTANCE2 CLASSES1 CLASSES2 CLASSES-SUBSUMEP)

COMPILE-EXPR (VAR PATTERN CONSEQUENT)

COMPILE-LIST (VAR PATTERN CONSEQUENT)

COMPILE-RULE (PATTERN CONSEQUENT VAR)

COMPILED-KM-HANDLER-FUNCTION (F-MODE TARGET X)

COMPUTE-BUILT-IN-NON-FLUENT-SLOTS

COMPUTE-NEW-VALS (SLOT OLD-VALS0 ADD-VALS &KEY COMBINE-VALUES-BY)

COMPUTE-TRIPLES (&OPTIONAL TRIPLE0)

CONCAT (&REST LIST)

CONCAT-LIST (LIST)

CONS-BINDING (BINDING BINDINGS)

CONSISTENT-TO-DO-ACTION (ACTION PCS-LIST NCS-LIST)

CONSTRAINT-EXPRP (EXPR)

CONTAINS (STRING SUBSTRING)

CONTAINS-SELF-KEYWORD (EXPR)

CONTAINS-SOME (EXPR SYMBOLS)

CONTAINS-SOME-EXISTENTIAL-EXPRS (EXPRS)

CONTAINS-WHITESPACE (STRING)

CONVERT-COMMENT-TO-INTERNAL-FORM (USER-COMMENT &OPTIONAL (SELF 'Self))

CONVERT-COMMENTS-TO-INTERNAL-FORM (EXPR &OPTIONAL (SELF 'Self))

COPY-DELAY (INSTANCE)

COPY-EXPLANATIONS-FOR (TRIPLE &KEY (FROM-SITUATION (CURR-SITUATION)) (TO-SITUATION *GLOBAL-SITUATION*) RENAMING-ALIST)

COPY-SITUATION-CONTENTS (SOURCE-SITN TARGET-SITN)

COUNT-ELEMENTS (LIST)

COUNTS-TO (NMAX &KEY (START-AT 1))

COUNTS-TO0 (N NMAX)

COVERS (XS Y)

CREATE-INSTANCE (PARENT0 SLOTSVALS0 &KEY (PREFIX-STRING (COND ((AM-IN-PROTOTYPE-MODE) *PROTO-MARKER-STRING*) (T *VAR-MARKER-STRING*))) (BIND-SELFP T) TARGET)

CREATE-INSTANCE-NAME (PARENT &OPTIONAL (PREFIX-STRING (COND ((AM-IN-PROTOTYPE-MODE) *PROTO-MARKER-STRING*) (T *VAR-MARKER-STRING*))))

CREATE-NAMED-INSTANCE (NEWFRAME PARENT SLOTSVALS0 &KEY (BIND-SELFP T) TARGET)

CRYPT (STRING &KEY (SHIFT 50))

CURR-ITERATION

CURR-PROTOTYPE

CURR-SITUATION

CURR-SITUATION-FACET

DATE

DECOMMENT (EXPR &KEY (NO-DELISTIFICATION T))

DECREMENT-TRACE-DEPTH

DEFAULT-FLUENT-STATUS (&OPTIONAL STATUS)

SETFDELAY-FUNCTION (NEW-VALUE INSTANCE)

DELAY-P (OBJECT)

SETFDELAY-VALUE (NEW-VALUE INSTANCE)

DELETE-ALL-SUPPORTS-FROM-CLASS (CLASS)

DELETE-EXPLANATION (INSTANCE0 SLOT VAL0 &KEY EXPLANATION-TO-DELETE (SITUATION (CURR-SITUATION)))

DELETE-EXPLANATIONS (I S V STRUCTS)

DELETE-FRAME (FRAME0 &KEY (DELETE-INVERSESP T))

DELETE-FRAME-STRUCTURE (FNAME &KEY (REMOVE-FROM-KB-OBJECT-LIST T))

DELETE-ISV-EXPLANATION (ISV-EXPLANATION &KEY (SITUATION (CURR-SITUATION)))

DELETE-ISV-EXPLANATIONS (ISV-EXPLANATIONS &KEY (SITUATION (CURR-SITUATION)))

DELETE-NONESSENTIAL-EXPLANATION (ISV-EXPLANATION &KEY ESSENTIALS)

DELETE-NONESSENTIAL-EXPLANATIONS (CONCEPT &KEY ESSENTIALS)

DELETE-PROTOTYPE-TRIPLE (TRIPLE)

DELETE-SLOT (FRAME0 SLOT &KEY (DELETE-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME0 SLOT)))

DELETE-SUPPORT-BY-PROTOTYPES (TRIPLE PROTOTYPE-ROOTS &KEY (SITUATION (CURR-SITUATION)) (EXPLANATION-TYPES-TO-DELETE '(cloned-from)))

DELETE-SUPPORT-BY-PROTOTYPES-IN-CLASS (TRIPLE CLASS &KEY (SITUATION (CURR-SITUATION)) (EXPLANATION-TYPES-TO-DELETE '(cloned-from)))

DELETE-SUPPORTS-FROM-CLASS (INSTANCE0 CLASS &KEY (SITUATION 'ALL-SITUATIONS))

DELETE-SUPPORTS-FROM-CLASS0 (INSTANCE0 CLASS &KEY (SITUATION (CURR-SITUATION)))

DELETE-TRIPLE (TRIPLE)

DELETE-VAL (INSTANCE SLOT VAL &OPTIONAL (UNINSTALL-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

DELISTIFIABLE-COMMENTED-OR-SOURCED-PAIRP (EXPR)

DELISTIFIABLE-COMMENTED-PAIRP (EXPR)

DELISTIFIABLE-SOURCED-PAIRP (EXPR)

DELISTIFY (LIST)

DEPTH-TO-THING (CLASS)

DEPTH-TO-THING1 (CLASSES DEPTH-SO-FAR)

DEREFERENCE (FRAME)

DEREFERENCE-CHAIN (I)

DEREFERENCE-KB

DEREFERENCE0 (FRAME)

DESCRIPTION-SUBSUMES-DESCRIPTION (X-DESC Y-DESC)

DESCRIPTIONP (EXPR)

DESOURCE (EXPR)

DESOURCE+DECOMMENT (EXPR &KEY RETAIN-COMMENTSP (DELISTIFYP T))

DESOURCE+DECOMMENT-TOP-LEVEL (EXPR)

DESOURCE+DECOMMENT1 (EXPR)

DESOURCE-ALL-BUT-TOP-LEVEL (EXPR)

DESOURCE-FOR-PRINTING (EXPR)

DESOURCE-TOP-LEVEL (EXPR)

DESOURCE1 (EXPR)

DISABLE-CLASSIFICATION

DISABLE-INSTALLING-INVERSES

DISABLE-SLOT-CHECKING

DISJOINT-CLASS-SETS (IMMEDIATE-CLASSES1 IMMEDIATE-CLASSES2 &KEY INSTANCE1 INSTANCE2)

DISJOINT-CLASS-SETS0 (CLASSES1 CLASSES2 &KEY INSTANCE1 INSTANCE2)

DISJOINT-CLASSES (CLASSES)

DO-ACTION (ACTION-EXPR &KEY NEXT-SITUATION CHANGE-TO-NEXT-SITUATION (TEST-OR-ASSERT-PCS 'ASSERT))

DO-FORCED-UNIFICATIONS (SET1 EXPRS2 &KEY EAGERLYP TARGET)

DO-PLAN (EVENT-INSTANCE)

DO-POSTPONED-CLASSIFICATIONS (INSTANCE SLOT)

DO-SETIFY (SET AND-SYMBOL)

DOMAINS-OF (SLOT)

DONT-CACHE-VALUES-SLOTP (SLOT)

DOT-SOURCE (SOURCE)

DOTTED-SLOT (SLOT)

DOUBLE-QUOTIFY (WORD &OPTIONAL (DELIM-CHARS '( )))

DOUBLE-QUOTIFY-LIST (WORDS &OPTIONAL (DELIM-CHARS '( )))

DUPLICATE (ITEM LENGTH)

EAGERLY-EVALUATE-EXPRS (INSTANCE &OPTIONAL (SITUATION (CURR-SITUATION)))

ENABLE-CLASSIFICATION

ENABLE-INSTALLING-INVERSES

ENABLE-SLOT-CHECKING

ENDS-WITH (STRING SUBSTR)

ENFORCE-CONSTRAINTS (VALS CONSTRAINTS &KEY TARGET)

ENFORCE-CONSTRAINTS0 (VALS CONSTRAINTS &KEY TARGET)

ENFORCE-SET-CONSTRAINT (VALS CONSTRAINT0 &KEY TARGET)

ENFORCE-SET-CONSTRAINT2 (VALS CONSTRAINT &KEY TARGET)

ENFORCE-SET-CONSTRAINTS (VALS CONSTRAINTS &KEY TARGET)

ENFORCE-SET-CONSTRAINTS0 (VALS CONSTRAINTS &KEY TARGET)

ENFORCE-VAL-CONSTRAINT (VAL CONSTRAINT0 INSTANCE SLOT SPECIAL-SLOT-TYPE)

ENFORCE-VAL-CONSTRAINTS (VAL CONSTRAINTS SPECIAL-SLOT-TYPE &KEY TARGET)

EQUALITY-ASSERTION-OPERATOR (X)

EVAL-CONSTRAINTS (INSTANCE)

EVAL-INSTANCE (INSTANCE)

EVAL-INSTANCES (&OPTIONAL (INSTANCES (OBJ-STACK)) &KEY (N 0))

EVALUATE-ALL (KM-EXPR &OPTIONAL (SITUATIONS (ALL-SITUATIONS)))

EVALUATE-ALL-FRAME (INSTANCE &OPTIONAL (SITUATIONS (ALL-SITUATIONS)))

EVALUATE-ALL-FRAME-IN-SITUATION (INSTANCE SITUATION)

EVALUATE-AND-FILTER-DEFAULTS (EXPR-SET CONSTRAINTS CURR-VALS SLOT &KEY SINGLE-VALUEDP)

EVALUATE-TRIPLE (TRIPLE)

EVEN-ELEMENTS (LIST)

EVERY-TO-A (EXPR)

EXISTENTIAL-EXPRP (EXPR)

EXPAND-TEXT (ITEM &KEY HTMLIFY (DEPTH 0))

EXPAND-TEXT0 (ITEM &KEY HTMLIFY (DEPTH 0))

EXPLAIN-ALL (&KEY (INCLUDE-GLOBALP T))

EXPLAINED-BY (INSTANCE EXPR &OPTIONAL TARGET)

EXPLANATION-IN (ISV-EXPLANATION)

EXPLANATION-TYPE (EXPLANATION)

EXPLANATIONS (&OPTIONAL SLOTS)

EXPLANATIONS-IN (ISV-MULTI-EXPLANATION)

EXPLODE (STRING)

EXPR2STRING (EXPR &OPTIONAL HTMLIFY)

EXTRACT-CONSTRAINTS (VALS)

EXTRACT-EXPRS-IN-CLASS (EXPRS CLASS)

FAIL-NOISILY

FAIL-QUIETLY

FASLSAVE-KB (FILE &KEY (RESET-KB T) (COMPILE T))

FAST-DELETE-VAL (INSTANCE SLOT VAL0 &OPTIONAL (UNINSTALL-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

FASTLOAD-KB (FKM-FILE &KEY (FORCE-FKM T))

FASTSAVE-KB (FILE &KEY (RESET-KB T) (COMPILE NIL))

FILE-EXISTS (FILE)

FILTER-USING-CONSTRAINTS (VALS CONSTRAINTS &OPTIONAL SLOT)

FILTER-USING-CONSTRAINTS0 (VALS CONSTRAINTS SLOT)

FIND-AND-APPLY-HANDLER (EXPR HANDLER-ALIST &KEY (FAIL-MODE 'FAIL))

FIND-CANDIDATES (EXISTENTIAL-EXPR)

FIND-CANDIDATES2 (CLASS SLOTVALS)

FIND-CLONE-OF-NODE (NODE ISV-EXPLANATION CLONE-OPERATION-ID)

FIND-CONSTRAINTS-IN-EXPRS (EXPRS)

FIND-ESSENTIALS (ESSENTIALS &KEY PROTOROOT (PARTICIPANTS (GET-VALS PROTOROOT 'prototype-participants)) (N 1))

FIND-ESSENTIALS0 (ESSENTIALS-TO-CHECK &KEY PROTOROOT PARTICIPANTS (ESSENTIALS ESSENTIALS-TO-CHECK))

FIND-EXPRS (EXPR &KEY EXPR-TYPE (PLURALITY 'SINGULAR))

FIND-HANDLER (EXPR HANDLER-ALIST &KEY (FAIL-MODE 'FAIL))

FIND-IGNORED

FIND-PATTERN (LIST PATTERN)

FIND-PATTERN1 (LIST PATTERN)

FIND-PROPOSITIONS (ACTION SLOT)

FIND-SUBSUMEES+BINDINGS (EXISTENTIAL-EXPR CANDIDATES &KEY BINDINGS)

FIND-SUBSUMEES-ON-OBJECT-STACK (EXISTENTIAL-EXPR)

FIRST-CHAR

FIRST-N (LIST N)

FIRST-N-UNIFIABLE-VALUES (POSSIBLE-VALUES VAL N)

FIRST-N-UNIFIABLE-VALUES2 (POSSIBLE-VALUES INSTANCE N)

FIRST-WORD (STRING)

FLATTEN (L)

FLATTEN-AUX (L &OPTIONAL (ACC NIL))

FLATTEN-SET (SET)

FLATTEN-SETS (VALS)

FLATTEN-TO-KB-OBJS (EXPR)

FLUENT-INSTANCE-EXPRP (EXPR)

FLUENT-INSTANCEP (INSTANCE)

FLUENT-STATUS (SLOT)

FLUENTP (SLOT)

FOLD (STRING0 N)

FOLD0 (STRING N)

FOLLOW-EVENT-CHAIN (EVENT)

FOLLOW-MULTIDEPTH-PATH (VALUES STRUCTURED-SLOT TARGET-CLASS &KEY (FAIL-MODE 'FAIL))

FOLLOW-MULTIDEPTH-PATH0 (VALUES SLOT DEPTH-LIMIT &KEY (START-VALUES VALUES) VALUES-SO-FAR)

FORCE (X)

FRAME-HAS-SOMETHING-TO-SAY-ABOUT (FRAME SLOT FACET &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

FULL-ALL-INSTANCES (CLASS)

FULL-IMMEDIATE-INSTANCES (CLASS)

FULL-MATCH (ITEM PATTERN &KEY (BINDINGS *NULL-BINDINGS*))

FULLY-EVALUATEDP (CONCEPT &KEY IN-STRUCTURED-EXPRP)

GATHER-BY-AKEY (PAIRS &OPTIONAL DICT)

GATHER-BY-KEY (PAIRS &OPTIONAL DICT)

GATHER-BY-KEY-INC-NILS (PAIRS &OPTIONAL DICT)

GATHERS-BY-KEY (TUPLES &KEY DICT (TEST #'EQUALP))

GET-ALL-CONCEPTS

GET-ALL-EXPLANATIONS (INSTANCE0 SLOT &KEY (SITUATION (CURR-SITUATION)) IGNORE-CLONE-CYCLES)

GET-ALL-OBJECTS

GET-BINDING

GET-COMMENT (COMMENT-TAG)

GET-COMMENT-JUSTIFICATION (COMMENT-TAG TRIPLE &KEY (SITUATION (CURR-SITUATION)) (TAB 0) DONE-TRIPLES (DEPTH 0) (FORMAT 'XML))

GET-COMMENT-TAGS (EXPR)

GET-COMMENT-TAGS-RECURSIVE (EXPR)

GET-COMMENT2 (COMMENT-TAG MODE)

GET-COMMENTS (EXPR)

GET-EXPLANATION-DATA (INSTANCE &KEY (SITUATION (CURR-SITUATION)) DEREFERENCE)

GET-EXPLANATIONS (INSTANCE SLOT VAL &OPTIONAL (SITUATION (CURR-SITUATION)))

GET-EXPLANATIONS0 (INSTANCE SLOT VAL &OPTIONAL (SITUATION (CURR-SITUATION)))

GET-EXPLANATIONS1 (INSTANCE0 SLOT VAL0 &OPTIONAL (SITUATION (CURR-SITUATION)))

GET-JUSTIFICATION (&KEY TRIPLE (SITUATION (CURR-SITUATION)) (DEPTH 0) (FORMAT 'XML) (TAB 0))

GET-JUSTIFICATION0 (&KEY TRIPLE (SITUATION (CURR-SITUATION)) (TAB 0) DONE-TRIPLES (DEPTH 0) (FORMAT 'XML))

GET-JUSTIFICATION1 (TRIPLE &KEY (SITUATION (CURR-SITUATION)) (TAB 0) DONE-TRIPLES (DEPTH 0) (FORMAT 'XML))

GET-JUSTIFICATION2 (INSTANCE SLOT VALUE &KEY (SITUATION (CURR-SITUATION)) (TAB 0) DONE-TRIPLES (DEPTH 0) (FORMAT 'XML))

GET-KB

GET-RULE-SETS-IN-SITUATION (CLASS SLOT SITUATION)

GET-SLOTSVALS (FRAME &KEY (FACET 'OWN-PROPERTIES) (SITUATION (CURR-SITUATION)) (DEREFERENCEP T))

GET-SUPPORT-DETAILS (TRIPLE &KEY IGNORE-CONSTRAINTSP)

GET-SUPPORTS (TRIPLE &KEY IGNORE-CONSTRAINTSP)

GET-UNIQUE-VAL (FRAME SLOT &KEY (FACET 'OWN-PROPERTIES) (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)) (FAIL-MODE 'FAIL))

GET-VALS (FRAME SLOT &KEY (FACET 'OWN-PROPERTIES) (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)) (DEREFERENCEP T))

GETOBJ (NAME0 FACET)

GETS-VALS (FRAMES SLOT &KEY (FACET 'OWN-PROPERTIES) (SITUATION (TARGET-SITUATION (CURR-SITUATION) (FIRST FRAMES) SLOT)) (DEREFERENCEP T))

GLOBAL-SITUATION

GOAL-STACK

GRAB-EXPLANATIONS (&KEY (EXPLANATIONS *EXPLANATIONS*) (FORMAT 'ASCII))

GRAB-EXPLANATIONS-HTML

GRAB-EXPLANATIONS-XML

GROUP-VALS-UNIFIABLY (VALS NON-UNIFIABLE-PAIRS)

GROUP-VALS-UNIFIABLY0 (VALS GROUPS-SO-FAR NON-UNIFIABLE-PAIRS)

HANDLE-CTRL-C-ERROR (ERROR)

HANDLE-LOOPING (KMEXPR &KEY (REASON 'LOOP-DETECTED))

HAS-SITUATION-SPECIFIC-INFO (FRAME SITUATION)

HASH-COMMA-READER (STREAM SUBCHAR ARG)

HASH-DOLLAR

HASH-DOLLAR-READER (STREAM SUBCHAR ARG)

HASH-T-READER (STREAM SUBCHAR ARG)

HIDE-THEORY (THEORY)

HTEXTIFY (CONCEPT &OPTIONAL CONCEPT-PHRASE &KEY ACTION WINDOW)

IGNORE-SLOT-DUE-TO-SITUATIONS-MODE (SLOT)

IMMEDIATE-CLASSES (INSTANCE &KEY (SITUATION (CURR-SITUATION)) ENFORCE-CONSTRAINTS)

IMMEDIATE-CLASSES-SUBSUME-IMMEDIATE-CLASSES (INSTANCE1 INSTANCE2 &KEY PROPERP)

IMMEDIATE-CLASSES0 (INSTANCE &KEY (SITUATION (CURR-SITUATION)))

IMMEDIATE-INSTANCES (CLASS)

IMMEDIATE-PROTOINSTANCES (CLASS)

IMMEDIATE-PROTOTYPES (CLASS)

IMMEDIATE-SUBCLASSES (CLASS)

IMMEDIATE-SUBSLOTS (SLOT)

IMMEDIATE-SUPERCLASSES (CLASS)

IMMEDIATE-SUPERSITUATIONS (SITUATION)

IMMEDIATE-SUPERSLOTS (SLOT)

IMPLODE (CHARLIST)

IN-PROTOTYPE (TRIPLE)

IN-SITUATION (SITUATION-EXPR &OPTIONAL KM-EXPR THEORYP)

IN-SITUATION0 (SITUATION-EXPR &OPTIONAL KM-EXPR THEORYP)

IN-THEORY (THEORY-EXPR &OPTIONAL KM-EXPR)

INCOMPATIBLE-INSTANCES (INSTANCE1 INSTANCE2)

INCONSISTENT-PROPOSITIONS (PROPOSITIONS &KEY IN-LIST)

INCREMENT-INFERENCE-STATISTICS

INCREMENT-TRACE-DEPTH

INERTIAL-FLUENTP (SLOT)

INFERENCE-NUMBER

INHERIT-WITH-OVERRIDES-SLOTP (SLOT)

INHERITED-RULE-SETS (INSTANCE SLOT &KEY (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)) RETAIN-COMMENTSP (CLIMB-SITUATION-HIERARCHYP T) IGNORE-INHERIT-WITH-OVERRIDES-RESTRICTION)

INHERITED-RULE-SETS+CLASSES-WITH-OVERRIDES (SLOT CLASSES ALL-SITUATIONS)

INHERITED-RULE-SETS+CLASSES-WITH-OVERRIDES2 (SLOT CLASS ALL-SITUATIONS)

INHERITED-RULE-SETS+CLASSES2 (SLOT CLASSES SITUATIONS)

INHERITED-RULE-SETS-ON-CLASSES (CLASSES SLOT &KEY (SITUATION (CURR-SITUATION)) RETAIN-COMMENTSP IGNORE-INHERIT-WITH-OVERRIDES-RESTRICTION)

INHERITED-RULE-SETS-WITH-OVERRIDES (SLOT CLASSES ALL-SITUATIONS)

INHERITED-RULE-SETS2 (SLOT CLASSES SITUATIONS)

INHERITED-RULESETS+CLASSES (INSTANCE0 SLOT &KEY (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE0 SLOT)) RETAIN-COMMENTSP (CLIMB-SITUATION-HIERARCHYP T) IGNORE-INHERIT-WITH-OVERRIDES-RESTRICTION)

INHERITED-TO-INSTANCE (SOURCE)

INSERT-DELIMETER (LIST DELIMETER)

INSERT-SPACES (WORDS)

INSPECT-SILENT-SPY-LOG

INSTALL-ALL-SUBCLASSES

INSTALL-INVERSES (FRAME SLOT VALS &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

INSTALL-INVERSES0 (INVFRAME0 INVSLOT INVVAL SLOT &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) INVFRAME0 INVSLOT)))

INSTANCE-DESCRIPTIONP (EXPR &KEY (FAIL-MODE 'FAIL))

INSTANCE-HAS-SOMETHING-TO-SAY-ABOUT (INSTANCE SLOT &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

INSTANCE-OF (INSTANCE TARGET-CLASS &OPTIONAL (SITUATION (CURR-SITUATION)))

INSTANCE-OF-IS-FLUENT

INSTANCE-OF-IS-NONFLUENT

INTERNAL-COMMENTP

INTERSECTS (SET1 SET2)

INV-ASSOC (KEY ASSOC-LIST &KEY (TEST #'EQ))

INVERT-CARDINALITY (CARDINALITY)

INVERT-INEQUALITY-RELATION (INEQUALITY)

INVERT-SLOT (SLOT)

INVERT-TYPE (TYPE)

IS (X Y)

IS-AN-INSTANCE (INSTANCE)

IS-CONSISTENT (VALS+CONSTRAINTS)

IS-CONSISTENT-TO-ASSERT (PROPOSITION &KEY IN-LIST)

IS-KM-TERM (CONCEPT)

IS-SIMPLE-KM-TERM (CONCEPT)

IS-SUBCLASS-OF (CLASS TARGET-CLASS &KEY PATH-SO-FAR)

IS-SUBSET-OF (LIST1 LIST2 &KEY (TEST #'EQ))

IS-SUBSLOT-OF (SLOT TARGET-SLOT &KEY PATH-SO-FAR)

IS-TYPE (CHAR TYPE)

IS-USER-INTERRUPT (ERROR)

IS0 (INSTANCE EXPR &KEY (BINDINGS *NULL-BINDINGS*))

IS0S (PAIRS &KEY (BINDINGS *NULL-BINDINGS*))

ISA (INSTANCE CLASS &OPTIONAL (SITUATION (CURR-SITUATION)))

ISA-CLONE (INSTANCE)

ISA-SITUATION-FACET (SITUATION)

ISA-THEORY (THEORY)

ITEM-EXPANDED-FROM (EXPLN-STRUCTS &KEY IGNORE-PROTOTYPES)

ITEM-TO-STACK (EXPR &KEY TARGET)

JOIN-BINDS (BINDS1 BINDS2)

JUSTIFY (&OPTIONAL TRIPLE-EXPR &KEY (SITUATION (CURR-SITUATION)) (DEPTH 0) (STREAM T))

JUSTIFY-LEAF (TRIPLE &KEY (SITUATION (CURR-SITUATION)) (TAB 0) DONE-TRIPLES (DEPTH 0) (FORMAT 'XML))

KB-OBJECTP

KB-SIZE

KM (&OPTIONAL (KMEXPR 'ASK-USER) &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))) (RESET-STATISTICS T))

KM-ADD-TO-KB-OBJECT-LIST (FNAME)

KM-ARGSP

KM-ASSERT (PROPOSITION ACTION &KEY IN-LIST)

KM-ASSERTION-EXPR (EXPR)

KM-BAG-EQUAL (BAG1 BAG2)

KM-BAG-EQUAL0 (BAG1 BAG2)

KM-BAGP (BAG)

KM-BIND (FRAME1 FRAME2)

KM-BOOLEAN-EXPRP (EXPR)

KM-DEFAULTP (EXPR)

KM-EQUAL (I1 I2)

KM-EVAL-PRINT (QUERY &KEY (FAIL-MODE *TOP-LEVEL-FAIL-MODE*))

KM-FLATTEN (VALS)

KM-FORMAT (STREAM STRING &REST ARGS)

KM-FUNCTIONP (VAL)

KM-INT (KMEXPR-WITH-COMMENTS &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))) (CHECK-FOR-LOOPING T) TARGET REWRITEP)

KM-INT-WITH-TRACE (TRACE-EXPR KMEXPR &KEY (FAIL-MODE *DEFAULT-FAIL-MODE*) (CHECK-FOR-LOOPING T) TARGET)

KM-MULTI-SLOTVALS (FRAMES0 SLOT &KEY (FAIL-MODE 'FAIL))

KM-MULTI-SLOTVALS0 (FRAMES SLOT)

KM-NAME (CONCEPT &KEY HTMLIFY)

KM-NULL (KM-NIL)

KM-PAIRP (SEQ)

KM-POP (VARIABLE)

KM-PROPERTYP (PROPERTY)

KM-PUSH (VALUE VARIABLE)

KM-PUT-LIST

KM-READ-EVAL-PRINT

KM-REMOVE-FROM-KB-OBJECT-LIST (FNAME)

KM-REMPROP (SYMBOL PROPERTY)

KM-REMPROPS (SYMBOL)

KM-SEQ-EQUAL (SEQ1 SEQ2)

KM-SEQ-EQUAL0 (SEQ1 SEQ2)

KM-SEQP (SEQ)

KM-SET-EQUAL (SET1 SET2)

KM-SETF (SYMBOL PROPERTY VALUE)

KM-SETP (SET)

KM-SETQ (VARIABLE VALUE)

KM-SLOTVALS (FRAME SLOT &KEY (FAIL-MODE 'FAIL))

KM-SLOTVALS-FROM-KB (INSTANCE0 SLOT &KEY FAIL-MODE &AUX (N 0))

KM-SLOTVALS-VIA-PROJECTION (INSTANCE SLOT)

KM-SLOTVALS2 (FRAME SLOT &KEY (FAIL-MODE 'FAIL))

KM-STRUCTURED-LIST-VALP (VAL)

KM-SYMBOL-PLIST (SYMBOL)

KM-TAGP (TAG)

KM-TRACE (MODE STRING &REST ARGS)

KM-TRACE2 (MODE STRING ARGS &KEY (STREAM T))

KM-TRIPLEP (TRIPLE)

KM-UNINTERN (CONCEPT)

KM-UNIQUE (KMEXPR &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))))

KM-UNIQUE-INT (KMEXPR &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))) TARGET REWRITEP)

KM-UNIQUE0 (KMEXPR &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))))

KM-VARP (VAR)

KM-VERSION-BITS-GREATER-THAN (V1-BITS V2-BITS)

KM-VERSION-GREATER-THAN (V1 V2)

KM0 (&OPTIONAL (KMEXPR 'ASK-USER) &KEY (FAIL-MODE (COND (*AM-REASONING* *DEFAULT-FAIL-MODE*) (T *TOP-LEVEL-FAIL-MODE*))))

KM1 (KMEXPR KMEXPR-WITH-COMMENTS &KEY (FAIL-MODE *DEFAULT-FAIL-MODE*) TARGET REWRITEP)

KNOWN-FRAME (FNAME)

LAST-BUT-N-CHAR (STRING N)

LAST-BUT-ONE-EL (LIST)

LAST-CHAR (STRING)

LAST-EL (LIST)

LAST-MEMBER (ITEM LIST &KEY (TEST #'EQ))

LAST-WORD (STRING)

LAZY-UNIFY (INSTANCENAME1 INSTANCENAME2 &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

LAZY-UNIFY-&-EXPR (EXPR &KEY (JOINER '&) (FAIL-MODE 'FAIL) TARGET)

LAZY-UNIFY-&-EXPR0 (EXPR &KEY (JOINER '&) (FAIL-MODE 'FAIL) TARGET)

LAZY-UNIFY-&-EXPR1 (EXPR &KEY (JOINER '&) (FAIL-MODE 'FAIL) TARGET)

LAZY-UNIFY-EXPR-SETS (EXPRS1 EXPRS2 &KEY EAGERLYP (FAIL-MODE 'FAIL) TARGET)

LAZY-UNIFY-EXPRS (X Y &KEY EAGERLYP CLASSES-SUBSUMEP (FAIL-MODE 'FAIL) TARGET)

LAZY-UNIFY-SETS (SET1 SET2 &KEY EAGERLYP TARGET)

LAZY-UNIFY-SETS2 (ORDERED-SCORED-PAIRS SET1 SET2 &KEY EAGERLYP TARGET)

LAZY-UNIFY-SLOTSVALS (I1 I2 SVS1 SVS2 &KEY CS1 CS2 CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

LAZY-UNIFY-VALS (SLOT I1 I2 VS1 VS2 &KEY CS1 CS2 CLASSES-SUBSUMEP EAGERLYP)

LAZY-UNIFY0 (INSTANCENAME1 INSTANCENAME2 &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

LAZY-UNIFY2 (INSTANCE1 INSTANCE2 &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

LEFT-OF (STRING SUBSTRING &KEY FROM-END)

LICENCE

LICENSE

LIST-DEFINED-SUBCLASSES (CLASS)

LIST-DEFINITIONS (&OPTIONAL (TOP-CLASS 'Thing))

LIST-DEFINITIONS-FOR-CLASS (CLASS SUPERCLASS)

LIST-DEFINITIONS-FOR-PROTOTYPE (PROTOTYPE SUPERCLASS)

LIST-INTERSECTION (LIST)

LIST-NEEDS-DEREFERENCING (LIST)

LIST-TO-LINES (STRINGS &OPTIONAL REVERSE-LINE-BITS-SO-FAR)

LIST-TO-LINES-WITH-SIZE-LIMIT (STRINGS &KEY (MAX-DOCUMENT-SIZE 1000))

LIST-TO-LINES-WITH-SIZE-LIMIT0 (STRINGS &KEY (MAX-DOCUMENT-SIZE 1000) (LENGTH-SO-FAR 0) REVERSE-LINE-BITS-SO-FAR)

LISTIFY (ATOM)

LISTIFY-IF-THERE (X)

LOAD-B (FILE)

LOAD-EXPR (EXPR STREAM &OPTIONAL VERBOSE RENAMING-ALIST EVAL-INSTANCES LOAD-PATTERNS)

LOAD-EXPRS (EXPR STREAM &OPTIONAL VERBOSE RENAMING-ALIST EVAL-INSTANCES LOAD-PATTERNS)

LOAD-KB (FILE &KEY VERBOSE WITH-MORPHISM EVAL-INSTANCES LOAD-PATTERNS PRINT-STATISTICS SILENTP)

LOAD-NEWEST-KB (FILE &KEY (RESET-KB NIL) VERBOSE WITH-MORPHISM EVAL-INSTANCES LOAD-PATTERNS)

LOAD-TRIPLES (FILE)

LOAD-TRIPLES0 (TRIPLES)

LOCAL-CONSTRAINTS (INSTANCE SLOT &KEY (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

LOG-UNDO-COMMAND (COMMAND)

LOOPING-ON (EXPR)

MAKE-ASSERTIONS (INSTANCE &OPTIONAL SLOTSVALS)

MAKE-COMMENT (STRING &REST ARGS)

MAKE-DELAY (&KEY ((VALUE DUM77) NIL) ((FUNCTION DUM78) NIL))

MAKE-NEW-SITUATION

MAKE-PHRASE (TEXT &KEY HTMLIFY)

MAKE-SENTENCE (TEXT &KEY (CAPITALIZE T) (TERMINATOR .) HTMLIFY)

MAKE-SLOTVALS (SLOT VALS)

MAKE-SOURCE (CLASS)

MAKE-TAX (&OPTIONAL (CURRENT-NODE 'Thing) (RELATION-TO-DESCEND 'subclasses) HTMLIFY)

MAKE-TAX0 (CURRENT-NODE RELATION-TO-DESCEND &OPTIONAL HTMLIFY NODES-DONE (TAB 0))

MAKE-TAXES (CURRENT-NODES RELATION-TO-DESCEND &OPTIONAL HTMLIFY NODES-DONE (TAB 0))

MAP-RECURSIVE (FUNCTION TREE)

MAPCHAR (FUNCTION STRING)

MAYBE-PROJECT-VALUE (PROJECTED-VALUES LOCAL-VALUES SLOT INSTANCE N-SOURCES)

MEMBER-EQUAL (ITEM LIST)

MERGE-CACHED-EXPLANATIONS (I1 I2)

MERGE-CODE (A B)

MERGE-EXPLANATIONS (I1 I2)

MERGE-PROTOTYPE-VALS (SLOT I1 I2 VS1 VS2)

MERGE-SLOTSVALS (INSTANCE SOURCE-SITN TARGET-SITN &KEY CLASSES-SUBSUMEP (FACET 'OWN-PROPERTIES))

MERGEABLE (A B)

MIGHT-BE-MEMBER (INSTANCE PARENT)

MIGHT-HAVE-SLOTSVALS (INSTANCE DEFN-SLOTSVALS)

MINIMATCH (ITEM PATTERN)

MINIMATCH1 (ITEM PATTERN)

MODIFY-SET-EXPLANATION (EXPR)

MOST-GENERAL-FIRST (CLASSES &KEY LOOPING-AT)

MOST-SPECIFIC-FIRST (CLASSES)

MOST-SPECIFIC-PROTOTYPE-SCOPES-FIRST (PROTOROOTS)

MULTIPLE-VALUE-MAPCAR (FUNCTION LIST)

MULTIPLE-VALUE-SOME (FN ARG-LIST)

MULTIVALUED-SLOTP (SLOT)

MV-MINIMATCH (ITEM PATTERN)

MV-STRING-MATCH (STRING PATTERN &KEY CASE-SENSITIVEP)

MY-CONCAT (STRINGS)

MY-MAPCAN (FUNCTION ARGS)

MY-PARSE-INTEGER (STRING)

NAMED-INSTANCEP (INSTANCE)

NEEDS-DEREFERENCING (FRAME)

NEQ (A B)

NEW-CONTEXT

NEW-SCAN-TO (STRING &KEY DELIMETER-CHARS)

NEW-SCAN-TO0 (DELIMETER-CHARS STRING M N NMAX POLARITY)

NEW-SITUATION

NEXT-CHECKPOINT

NEXT-EVENT (EVENT)

NEXT-SITUATION (ACTION &KEY NEXT-SITUATION)

NEXT-SITUATIONS (SITUATION)

NLIST (NMAX &OPTIONAL (N 1))

NO-EXPLANATIONS

NO-FOLLOWING-SPACES (CHAR)

NO-PRECEEDING-SPACES (CHAR)

NO-RESERVED-KEYWORDS (VALS)

NO-SANITY-CHECKS

NOCOMMENTS

NODE-CLONED-FROM (F)

NODE-CLONED-FROM* (F &KEY DONE)

NODE-CLONED-FROM-ORIGINALLY (F)

NODE-CLONED-TO (F)

NODE-EXPANDED-FROM (NODE0 &KEY IGNORE-PROTOTYPES)

NODES-CLONED-TO (NODES0 &KEY CLONES-OF-INTEREST)

NODES-CLONED-TO0 (NODES0 &KEY CLONES-OF-INTEREST)

NON-CONSTRAINT-EXPRP (EXPR)

NON-INVERSE-RECORDING-CONCEPT (CONCEPT)

NON-INVERSE-RECORDING-SLOT (SLOT)

NON-UNIFIABLE-PAIRS (VALS)

NONESSENTIALS-IN (ISV-EXPLANATION &KEY ESSENTIALS)

NONESSENTIALS-IN-EXPR (EXPR &KEY ESSENTIALS)

NOR (A B)

NOTE-ARE-CONSTRAINTS

NOTE-DONE (FRAME SLOT &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

NOW

NOWEXISTS (FRAME)

NOWEXISTS-VAL (FRAME &KEY (SITUATION (CURR-SITUATION)))

NREPLACE (LIST N NEW)

NUMBER-EQ (N1 N2)

NUMBER-STRINGP (STRING)

NUMERIC-CHAR-P (CHAR)

OBJ-STACK

OBJWRITE (EXPR &OPTIONAL HTMLIFY)

OBJWRITE2 (EXPR HTMLIFY &KEY (ACTION *HTML-ACTION*) (WINDOW *HTML-WINDOW*))

ODD-ELEMENTS (LIST)

ON-ERROR

ON-GOAL-STACKP (EXPR)

ONEOF-WHERE (VAR SET TEST)

ORDERED-COUNT (LIST)

ORDERED-GATHER-BY-KEY (PAIRS &KEY REMOVE-DUPLICATES)

ORDERED-INTERSECTION (LIST SET &KEY (TEST #'EQ))

ORDERED-SET-DIFFERENCE (LIST SET &KEY (TEST #'EQ))

ORIFY (VALS)

ORIGINATED-FROM-CLASS (SOURCE)

ORIGINATED-FROM-CLASSES (EXPR)

ORPHANP (CONCEPT)

ORPHANS

OWN-RULE-SETS (INSTANCE SLOT &KEY RETAIN-COMMENTSP (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

PAIR-FILTER (VALS &OPTIONAL SELECTED-SO-FAR)

PAIR-LESS-THAN (PAIR1 PAIR2)

PAIR-TO-LIST (PAIR)

PAIRP (THING)

PARTITION (SEQUENCE FUNCTION)

PATH-TO-EXISTENTIAL-EXPR (PATH &OPTIONAL (PREP 'a))

PATH-TO-EXISTENTIAL-EXPR2 (PATH EMBEDDED-UNIT PREP)

PATHP (PATH)

PAUSE

PENDING-EQUALITY (X0 Y0)

PERMUTATIONS (LIST)

PERMUTATIONS0 (LIST)

PERMUTE (LIST-OF-LISTS)

PERMUTE-CLONESETS (SETS)

POINT-PARENTS-TO-DEFINED-CONCEPT (FRAME PARENTS FACET &KEY SIMPLE-CLASSP)

POP-FROM-GOAL-STACK

PORT-TO-PACKAGE (TREE &KEY PACKAGE)

PREV-SITUATION (SITUATION &OPTIONAL INSTANCE)

PREV-SITUATION-WITH-VALS (SITUATION INSTANCE SLOT)

PROCESS-KM1-RESULT (ANSWER KMEXPR KMEXPR-WITH-COMMENTS &KEY (FAIL-MODE *DEFAULT-FAIL-MODE*) TARGET HANDLER-PATTERN REWRITEP)

PROCESS-LOAD-EXPRESSION (LOAD-EXPR0)

PROCESS-UNQUOTES (EXPR &KEY (FAIL-MODE 'FAIL))

PROFILE-CALL (KMEXPR)

PROFILE-EXIT (KMEXPR)

PROFILE-REPORT (&OPTIONAL (N 100))

PROFILE-RESET

PROJECTABLE (SLOT INSTANCE)

PROJECTED-CLASSES (INSTANCE SITUATION LOCAL-CLASSES-AND-CONSTRAINTS)

PROPER-LISTP (LIST)

PROTOINSTANCEP (CONCEPT)

PROTOROOTP (CONCEPT)

PROTOTYPE-CLASSES (NODE-OR-TRIPLE0)

PROTOTYPE-CONSTRAINTS+SOURCES (INSTANCE SLOT &KEY IGNORE-PROTOTYPES)

PROTOTYPE-MERGE-EXPR1 (SLOT I1 I2 VS1 VS2 &KEY SOURCE-PROTOROOTS)

PROTOTYPE-MERGE-EXPR2 (ORDERED-SCORED-PAIRS VS1 VS2 I1 I2 SLOT)

PROTOTYPEP (CONCEPT)

PUSH-TO-GOAL-STACK (EXPR &KEY TARGET)

PUSH-TO-OBJ-STACK (INSTANCE)

PUT-EXPLANATION-DATA (INSTANCE ISV-EXPLANATIONS &KEY (SITUATION (CURR-SITUATION)))

PUT-EXPLANATIONS (INSTANCE SLOT ISV-EXPLANATIONS &KEY (SITUATION (CURR-SITUATION)))

PUT-KB (KB &KEY UNINTERN-SYMBOLS)

PUT-LIST

PUT-SLOTSVALS (FRAME SLOTSVALS &KEY (FACET 'OWN-PROPERTIES) (INSTALL-INVERSESP T) (SITUATION (CURR-SITUATION)))

PUT-VALS (INSTANCE SLOT VALS0 &KEY (FACET 'OWN-PROPERTIES) (INSTALL-INVERSESP T) (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

PUTOBJ (FNAME SLOTSVALS FACET)

QUADRUPLEP (LIST)

QUOTED-DESCRIPTIONP (EXPR)

QUOTED-EXPRESSIONP (EXPR)

QUOTEP (EXPR)

QUOTIFY (ITEM)

RAISE-PARTICIPANT (PARTICIPANT)

RAISE-PROTOTYPE (PROTOTYPE)

RANGES-OF (SLOT)

RANK-SORT (LIST FUNCTION)

RANK-UNIFICATION (I1 I2 &KEY CLONED-FROM-SOURCES)

READ-AND-PRINT (FILE)

READ-AND-PRINT2 (STREAM)

READ-FILE (FILE &OPTIONAL (TYPE 'STRING))

READ-FILE-ARRAY (FILE &KEY ELEMENT-TYPE)

READ-FILE-BYTES (FILE &KEY ELEMENT-TYPE)

READ-FILE-CHARS (FILE)

READ-FILE-EXPRS (FILE)

READ-FILE-LINES (FILE)

READ-FILE-STRING (FILE)

READ-TO (STRING CHARS)

READ-TO2 (STRING CHARS)

RECORD-EXPLANATION-FOR (TARGET VAL EXPR0 &KEY (SITUATION (CURR-SITUATION)) IGNORE-CLONE-CYCLES)

RECORD-EXPLANATION-LATER (EXPR)

RECURSIVE-FIND (ITEM TREE)

RECURSIVE-RULESET (INSTANCE SLOT RULESET)

REIFY-EXISTENTIALS-IN-EXPR (EXPR)

REIFY-EXISTENTIALS-IN-RULE-SET (RULE-SET)

REIFY-EXISTENTIALS-IN-RULE-SETS (RULE-SETS)

RELOAD-KB (FILE &KEY VERBOSE WITH-MORPHISM EVAL-INSTANCES LOAD-PATTERNS)

REMOVE-ASSOC-ENTRY (KEY ASSOC-LIST)

REMOVE-CLONE-CYCLES (EXPLANATION-STRUCTS)

REMOVE-CLONED-FROM-EXPLANATIONS (ISV-EXPLANATIONS PROTOROOT)

REMOVE-CLONED-FROM-EXPLNS (EXPLANATIONS)

REMOVE-CONSTRAINTS (VALS)

REMOVE-DELIMETERS (LIST)

REMOVE-DOUBLEQUOTES (STRING &KEY NIL-IF-MISSING)

REMOVE-DUP-ATOMIC-INSTANCES (INSTANCES)

REMOVE-DUP-INSTANCES (INSTANCES)

REMOVE-ELEMENT-N (LIST N)

REMOVE-EQUAL-ITEMS (VS1 VS2)

REMOVE-EQUAL-ITEMS0 (VS1 VS2 &KEY REV-NEW-VS1 EQUAL-VS2-SO-FAR)

REMOVE-EXPLAINED-VALS (VALS EXPRS &KEY TARGET)

REMOVE-FROM-END (STRING CHARS)

REMOVE-FROM-STACK (INSTANCE)

REMOVE-LEADING-WHITESPACE (STRING)

REMOVE-PENDING-EQUALITIES (VALS)

REMOVE-REDUNDANT-SUBCLASSES (CLASS)

REMOVE-REDUNDANT-SUPERCLASSES (CLASS)

REMOVE-SHARED-ELEMENTS (LIST1 LIST2 &KEY (TEST #'EQ))

REMOVE-SINGLETONS (LIST)

REMOVE-SOURCES-FROM-VALS (INSTANCE SLOT VALS)

REMOVE-STRING (BIT STRING)

REMOVE-SUBSUMEES (CLASSES)

REMOVE-SUBSUMEES-SLOTP (SLOT)

REMOVE-SUBSUMERS (CLASSES)

REMOVE-SUBSUMERS-SLOTP (SLOT)

REMOVE-SUBSUMING-EXPRS (EXPRS INSTANCES &KEY ALLOW-COERCION TARGET EAGERLYP)

REMOVE-SUBSUMING-EXPRS0 (EXPRS INSTANCES &KEY ALLOW-COERCION TARGET EAGERLYP)

REMOVE-SUPPORT (TRIPLE SUPPORT &KEY (SITUATION (CURR-SITUATION)))

REMOVE-SUPPORTS (TRIPLE &KEY (SITUATION (CURR-SITUATION)))

REMOVE-TRAILING-WHITESPACE (STRING)

REMOVE-WRAPPER (STRING START0 END &KEY NIL-IF-MISSING)

REMPROPS (SYMBOL)

RENAME-CLASS (OLD-CLASS NEW-CLASS)

RENAME-SYMBOLS (EXPR RENAMING-ALIST)

REORDER-SLOTSVALS (SLOTSVALS)

REPLACE-ELEMENT (N LIST EL)

REPLACE-STRING (OLD NEW STRING)

REPORT-ERROR (ERROR-TYPE STRING0 &REST ARGS0)

REPORT-STATISTICS

REPORT-STATISTICS-LONG

REQUIRES-KM-VERSION (VERSION-NUMBER-STR)

RESET-CREATIONS

RESET-DONE

RESET-FOR-TOP-LEVEL-CALL (KM-EXPR &KEY (RESET-STATISTICS T))

RESET-HANDLER-FUNCTIONS

RESET-HISTORY

RESET-INFERENCE-ENGINE

RESET-KB

RESET-STATISTICS

RESET-TRACE

RESET-TRACE-AT-ITERATION

RESET-TRACE-DEPTH

RESTORE-KB (&KEY UNINTERN-SYMBOLS)

RESTVAR-P (X)

RETAIN-EXPRP (EXPR)

REUSE-CONS (A B AB)

RIGHT-OF (STRING SUBSTRING &KEY FROM-END)

RIGHTMOST-WORD (STRING)

RULES-FOR (SLOT FRAMEADD &KEY RETAIN-COMMENTSP)

SANITY-CHECKS

SATISFIES-CLASS-DEFINITION (INSTANCE CLASS-DEFINITION CONCLUSION-CLASSES)

SATISFIES-CONSTRAINTS (VALS0 CONSTRAINTS0 SLOT &KEY INCOMPLETEP)

SATISFIES-DEFINITION (INSTANCE CLASS &KEY SLOTS-THAT-CHANGED)

SATISFIES-DEFINITION2 (INSTANCE POSS-COREF-INSTANCE &KEY SLOTS-THAT-CHANGED)

SATISFIES-PROTOTYPE-DEFINITION (INSTANCE PROTOTYPE)

SAVE-EXPLANATION (ISV-EXPLANATION &KEY (STREAM T) ESSENTIALS)

SAVE-EXPLANATIONS (CONCEPT &KEY (STREAM T) ESSENTIALS EXPLANATION-TYPES)

SAVE-FRAME (CONCEPT &KEY (STREAM T) (SITUATIONS (ALL-SITUATIONS)) SAVE-PROTOTYPEP ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW (THEORIES (ALL-THEORIES)) NULLS-OKAYP INCLUDE-EXPLANATIONSP)

SAVE-KB (FILE &KEY (RESET-KB T) (INCLUDE-EXPLANATIONSP T))

SAVE-PROTOTYPE (PROTOTYPE0 &KEY STREAM (FILE T) EXTRA-ASSERTIONS ESSENTIAL-PARTICIPANTS)

SCAN-KB

SCAN-TO (DELIMETER STRING M N NMAX &KEY ALLOW-QUOTED-PHRASES)

SCORE-PAIR (V1 V2 &KEY SOURCE-PROTOROOTS)

SEARCH-STACK (CLASS)

SEE (FILE)

SEE-THEORY (THEORY)

SEEN

SELECT-REAL-TRIPLES (FS S VS)

SEQ-TO-LIST (SEQ)

SET-CHECKPOINT (&OPTIONAL (CHECKPOINT-ID 'T))

SET-CONSTRAINT-EXPRP (EXPR)

SET-CONSTRAINT-SATISFIED (VALS0 CONSTRAINT &KEY INCOMPLETEP)

SET-CREATIONS-CHECKPOINT (&KEY (CHECKPOINT-ID *CHECKPOINT*) (WITH-COMMENT T) MULTIPLE-CHECKPOINTS)

SET-EQUAL (SET1 SET2)

SET-SITUATIONS-MODE

SET-TO-LIST (SET)

SET-UNIFICATION-OPERATOR (X)

SHIFT-CHAR (C &KEY (SHIFT 50))

SHOW-BINDING (FRAME)

SHOW-BINDING0 (FRAME)

SHOW-BINDINGS

SHOW-COMMENT (COMMENT-TAG)

SHOW-CONTEXT

SHOW-DONE

SHOW-EXPLANATION (EXPLANATION DEPTH MODE COMMENT-TAGS &KEY FORMAT (STREAM T))

SHOW-EXPLANATIONS (&KEY (EXPLANATIONS *EXPLANATIONS*) (FORMAT 'ASCII) (STREAM T))

SHOW-EXPLANATIONS-HTML (&KEY (STREAM T))

SHOW-EXPLANATIONS-XML (&KEY (STREAM T))

SHOW-GOAL-STACK (&OPTIONAL (STREAM T))

SHOW-GOAL-STACK2 (STACK DEPTH SHOW-SITUATIONSP &OPTIONAL (STREAM T))

SHOW-OBJ-STACK

SHOW-SUPPORT (SUPPORT)

SHOWME (KM-EXPR &OPTIONAL (SITUATIONS (ALL-SITUATIONS)) (THEORIES (ALL-THEORIES)) (STREAM NIL) RETURN-STRINGS-P)

SHOWME-ALL (KM-EXPR &OPTIONAL (SITUATIONS (ALL-SITUATIONS)))

SHOWME-ALL-FRAME (INSTANCE &OPTIONAL (SITUATIONS (ALL-SITUATIONS)))

SHOWME-FRAME (FRAME &OPTIONAL (SITUATIONS (ALL-SITUATIONS)) (THEORIES (ALL-THEORIES)) (STREAM NIL))

SHOWME-MEMBER-SLOTS-IN-SITUATION (CLASS SITUATION)

SHOWME-OWN-SLOTS-IN-SITUATION (INSTANCE SITUATION)

SHOWME-STRINGS (KM-EXPR &OPTIONAL (SITUATIONS (ALL-SITUATIONS)) (THEORIES (ALL-THEORIES)) (STREAM NIL))

SILENT-SPY (&OPTIONAL EXPR0)

SILENT-SPYPOINTS-STACK

SILENT-UNSPY

SIMPLE-ADD-INVERSES (INSTANCE SLOT EXTRA-VALS)

SIMPLE-ADD-SLOTSVALS (INSTANCE ADD-SLOTSVALS &KEY (INSTALL-INVERSESP T))

SIMPLE-COMPUTE-NEW-SLOTSVALS (INSTANCE OLD-SLOTSVALS ADD-SLOTSVALS &KEY (INSTALL-INVERSESP T))

SIMPLE-EVAL-INSTANCE (INSTANCE)

SIMPLE-INHERIT-WITH-OVERRIDES-SLOTP (SLOT)

SIMPLE-SLOTP (SLOT)

SIMPLE-UNIFIABLE (X Y)

SIMPLELOAD-EXPR (ITEM &KEY (INSTALL-INVERSESP T))

SIMPLELOAD-KB (KM-FILE &KEY (INSTALL-INVERSESP T))

SIMPLIFY-CLONED-FROM (EXPLANATION)

SINGLE-VALUED-SLOTP (SLOT)

SINGLETONP (LIST)

SITUATION-INVARIANT-EXPRP (EXPR)

SKIP-CHECKPOINT (QUERY)

SKOLEM-ROOT (STRING)

SLOT-IN (SLOTVALS)

SLOT-OBJECTP (SLOT)

SLOTP (SLOT)

SLOTS-TO-OPPORTUNISTICALLY-EVALUATE (INSTANCE)

SLOTSVALS-SUBSUME (SLOTSVALS INSTANCE &KEY (BINDINGS *NULL-BINDINGS*))

SLOTVALS-SUBSUME (SLOTVALS INSTANCE &KEY (BINDINGS *NULL-BINDINGS*))

SOMETIMES-EXPRP (EXPR)

SORT-OBJECTS-FOR-WRITING (OBJECTS0)

SOURCE-CLASSES-FOR-TRIPLE (INSTANCE SLOT VALUE &OPTIONAL (SITUATION (CURR-SITUATION)))

SOURCE-PATH (SOURCE)

SOURCEP (TAG)

SOURCES (EXPR)

SPACED-LIST (LIST)

SPACED-STRING (LIST)

SPACES (N)

SPACIFY (WORDS)

SPECIAL-SLOT-TYPE (SLOT)

SPLIT-AT (STRING SUBSTRING &KEY FROM-END)

SPLIT-AT1 (STRING SUBSTRING &KEY FROM-END)

SPLITS-AT (STRING SUBSTRING)

SPY (&OPTIONAL EXPR0)

STACK-EQUAL (ITEM1 ITEM2)

STACKABLE (INSTANCE)

STACKED-CANONICAL-EXPR (STACKED-ITEM)

STACKED-EXPR (STACKED-ITEM)

STACKED-INFERENCE-NUMBER (STACKED-ITEM)

STACKED-SITUATION (STACKED-ITEM)

STACKED-TARGET (STACKED-ITEM)

START-CREATIONS-LOGGING (&KEY (WITH-COMMENT T))

START-LOGGING (&KEY (WITH-COMMENT T))

STARTS-WITH (STRING SUBSTR)

STOP-CREATIONS-LOGGING (&KEY (WITH-COMMENT T))

STOP-LOGGING (&KEY (WITH-COMMENT T))

STORE-KB

STRING-MATCH (STRING PATTERN &KEY CASE-SENSITIVEP)

STRING-MATCH1 (ITEM PATTERN &KEY CASE-SENSITIVEP)

STRING-TO-FRAME (STRING)

STRING-TO-LIST (STRING &KEY (WORDCHARS 'ALPHANUM) ALLOW-QUOTED-PHRASES)

STRING-TO-NUMBER (STRING &KEY (FAIL-MODE 'FAIL))

STRING-TO-WORDS (STRING &KEY (WORDCHARS 'ALPHANUM) ALLOW-QUOTED-PHRASES)

STRIP-ENDCHARS (STRING)

STRUCTURED-SLOTP (SLOT)

SUBBAGP (SUBBAG BAG &KEY (TEST #'EQ))

SUBCLASSES-OF-THING

SUBSTITUTE-STRING (OLD NEW STRING &KEY RECURSIVEP)

SUBSTITUTE-STRING0 (OLD NEW STRING &KEY RECURSIVEP)

SUBSTITUTE-STRINGS (STRING ALIST &KEY RECURSIVEP)

SUBSUMES (XS YS)

SUITABLE-FOR-CLONING (INSTANCE SLOT PROTOTYPE)

SUPERSITUATION-OWN-RULE-SETS (INSTANCE SLOT &KEY RETAIN-COMMENTSP (SITUATION (TARGET-SITUATION (CURR-SITUATION) INSTANCE SLOT)))

SUSPEND-TRACE (&OPTIONAL (DEPTH *DEPTH*))

SYMBOL-LESS-THAN (PAIR1 PAIR2)

SYMBOL-STARTS-WITH (SYMBOL CHAR)

T2F-OFF

T2F-ON (&OPTIONAL FILENAME)

TAG-WRITE (TAGS &OPTIONAL (STREAM T) (FIRST-TIME-THROUGH T))

TAGS-IN-EXPR (EXPR &KEY (USE-CLONED-FROM T))

TARGET-SITUATION (SITUATION INSTANCE SLOT &OPTIONAL VALS)

TAX-OBJ-WRITE (CONCEPT TAB HTMLIFY &KEY INSTANCEP)

TAXONOMY (&OPTIONAL (CURRENT-NODE 'Thing) (RELATION-TO-DESCEND 'subclasses) HTMLIFY)

TELL (FILE)

TELL-APPEND (FILE)

TEST-VAL-CONSTRAINT (VAL CONSTRAINT SPECIAL-SLOT-TYPE &KEY MODE)

TEST-VAL-CONSTRAINTS (VAL CONSTRAINTS SPECIAL-SLOT-TYPE &KEY MODE)

THE-CLASS-EXPRP (EXPR)

THROW-CTRL-C-ERROR

TIDY-CLASSES (SLOT VALS)

TOLD

TOLD-APPEND

TOP-LEVEL-GOAL

TRACE-AT-ITERATION (N)

TRACE-RULE (RULE-PATTERN FACT BINDINGS)

TRACE-TO-FILE-OFF

TRACE-TO-FILE-ON (&OPTIONAL FILENAME)

TRACECLASSIFYP

TRACECONSTRAINTSP

TRACEKM

TRACEOTHERSITUATIONSP

TRACEP

TRACESUBSUMESP

TRACEUNIFYP

TRANSPOSE (LIST)

TRIM-FAILED-EXPLANATIONS (EXPLANATIONS DEPTH COMMENT-TAGS)

TRIM-FROM-END (STRING N)

TRIM-FROM-START (STRING N)

TRIM-NUMBERS (STRING &KEY NUMBER-CHARS (WITH-WARNINGS T))

TRIM-PROTOTYPE (PROTOTYPE0 &KEY ESSENTIAL-PARTICIPANTS)

TRIM-WHITESPACE (STRING)

TRIPLE-CLONED-FROM (TRIPLE)

TRIPLE-CLONED-FROM-COMPLEX* (F S V)

TRIPLE-CLONED-FROM-ORIGINALLY (TRIPLE)

TRIPLE-CLONED-FROM-SIMPLE* (F S V)

TRIPLE-CLONED-TO (TRIPLE)

TRIPLE-CLONED-TO-COMPLEX* (F S V)

TRIPLE-CLONED-TO-SIMPLE* (F S V)

TRIPLE-EXPANDED-FROM (TRIPLE &KEY IGNORE-PROTOTYPES)

TRIPLE-IN (ISV-EXPLANATION)

TRIPLE-NAME (TRIPLE &KEY HTMLIFY)

TRIPLEP (LIST)

TRIPLES-TO-ALIST (TRIPLES)

TRUNCATE-STRING (STRING &OPTIONAL (MAXLEN 60))

TRY-CLASSIFYING (INSTANCE POSSIBLE-NEW-PARENT &KEY SLOTS-THAT-CHANGED)

TRY-CLASSIFYING-AS-PROTOTYPE (INSTANCE PROTOCLASSES CLASS-DEFINITION)

TRY-EQUATING (INSTANCE POSSIBLE-COREFERENTIAL-INSTANCE &KEY SLOTS-THAT-CHANGED)

TRY-LAZY-UNIFY (INSTANCENAME1 INSTANCENAME2 &KEY CLASSES-SUBSUMEP (CHECK-CONSTRAINTSP T))

TRY-LAZY-UNIFY2 (INSTANCE1 INSTANCE2 &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

UN-ANDIFY (VALS)

UN-DONE (FRAME &KEY SLOT SITUATION)

UNDECLARED-SLOT (SLOT)

UNDO (&OPTIONAL CHECKPOINT-ID)

UNDO-CREATIONS (&KEY (CHECKPOINT-ID *CHECKPOINT*) (WITH-COMMENT T) REMOVE-CHECKPOINT)

UNDO-POSSIBLE (&OPTIONAL CHECKPOINT-ID)

UNDO0 (HISTORY CHECKPOINT-ID)

UNDO1 (COMMAND)

UNFILTERED-OBJ-STACK

UNIFIABLE-WITH-EXISTENTIAL-EXPR (INSTANCE EXPR &KEY CLASSES-SUBSUMEP)

UNIFIABLE-WITH-EXISTENTIAL-EXPR0 (INSTANCE EXPR &KEY CLASSES-SUBSUMEP)

UNIFICATION-OPERATOR (X)

UNIFIED-SVS (I1 I2 &KEY (SITUATIONS (ALL-SITUATIONS-AND-THEORIES)) CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

UNIFIED-SVS-IN-SITUATION (I1 I2 SITUATION &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

UNIFY-IN-PROTOTYPE (INSTANCE PROTOTYPE &OPTIONAL SLOT)

UNIFY-IN-PROTOTYPES (INSTANCE0 &OPTIONAL SLOT)

UNIFY-NAMES (INSTANCE1 INSTANCE2 &KEY CLASSES-SUBSUMEP EAGERLYP)

UNIFY-STRUCTURED-LIST-VALS (INSTANCE10 INSTANCE20 &KEY CLASSES-SUBSUMEP EAGERLYP FAIL-MODE)

UNIFY-STRUCTURED-LIST-VALS2 (ELEMENTS1 ELEMENTS2 &KEY CLASSES-SUBSUMEP EAGERLYP FAIL-MODE)

UNIFY-WITH-EXISTENTIAL-EXPR (INSTANCE EXPR &KEY EAGERLYP CLASSES-SUBSUMEP (FAIL-MODE 'FAIL) TARGET (CHECK-CONSTRAINTSP T))

UNIFY-WITH-INSTANCE (INSTANCE POSSIBLE-COREFERENTIAL-INSTANCE)

UNIFY-WITH-SLOTSVALS2 (INSTANCE CLASSES SLOTSVALS00 &KEY CLASSES-SUBSUMEP EAGERLYP (CHECK-CONSTRAINTSP T) (FAIL-MODE 'FAIL))

UNINSTALL-INVERSE (FRAME SLOT VAL0 &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

UNINSTALL-INVERSES (FRAME SLOT VALS &OPTIONAL (SITUATION (TARGET-SITUATION (CURR-SITUATION) FRAME SLOT)))

UNIQUEP (X LIST)

UNIVERSALP (SLOT)

UNPOINT-PARENTS-TO-DEFINED-CONCEPT (FRAME PARENTS FACET)

UNQUOTE (EXPR)

UNSATISFIED-PROPOSITIONS (PROPOSITIONS)

UNSPY

UNSUSPEND-TRACE

UNTRACEKM

UNUNIFIABLE (FRAME2)

UNUNIFY (FRAME2)

UNUSABLE-FRAME-NAME (FNAME)

UPDATE-ASSOC-LIST (ASSOC-LIST NEW-PAIR)

UPDATE-DICT (DICT KEY VAL)

UPPERCASE-LETTERP (WORD)

USE-INHERITANCE

USE-PROTOTYPES

USED-SLOT-IN (SLOTVALS)

USER-COMMENTP

VAL-CONSTRAINT-EXPRP (EXPR)

VAL-OF (VAR BINDINGS)

VAL-SETS-TO-EXPR (EXPRS0 &KEY SINGLE-VALUEDP COMBINE-VALUES-BY-APPENDINGP (JOINER (COND (SINGLE-VALUEDP '&) (T '&&))))

VAL-SETS-TO-EXPR0 (EXPRS &KEY SINGLE-VALUEDP (JOINER (COND (SINGLE-VALUEDP '&) (T '&&))))

VAL-TO-VALS (VAL)

VAL-UNIFICATION-OPERATOR (X)

VALS-IN

VALS-IN-CLASS (VALS CLASS)

VALS-SUBSUME (SER-EXPRS SEE-VALS &KEY (BINDINGS *NULL-BINDINGS*) CURRENT-VAR)

VALS-TO-&-EXPR (VALS &KEY (JOINER '&) (FIRST-TIME-THROUGH T))

VALS-TO-CLASS-DESCRIPTION (CLASSES)

VALS-TO-VAL (VALS)

VALSET-SUBSUMES-VALSET (VALSET1 VALSET2)

VALSETS-TO-&&-EXPRS (VALSETS)

VAR-BOUNDP (VAR BINDINGS)

VAR-P (VAR)

VARIABLES-IN (X)

VIOLATED-CARDINALITY-CONSTRAINT (EXPR-SETS CONSTRAINT)

VIOLATED-CONSTRAINTS (VALS0 CONSTRAINTS0 SLOT &KEY MODE INCOMPLETEP)

VIOLATED-SET-CONSTRAINTS (EXPR-SETS CONSTRAINTS0)

VIOLATED-VAL-CONSTRAINTS (VAL CONSTRAINTS SPECIAL-SLOT-TYPE &KEY MODE)

VISIBLE-THEORIES

WHITE-SPACE-P (STRING &KEY (WHITESPACE-CHARS *WHITESPACE-CHARS*))

WHITE-SPACE2-P (STRING N NMAX WHITESPACE-CHARS)

WHITESPACE-CHAR (CHAR)

WHY (&OPTIONAL TRIPLE (SITUATION (CURR-SITUATION)))

WHY0 (TRIPLE &OPTIONAL (SITUATION (CURR-SITUATION)))

WILDCARD-VARP (VAR)

WRITE-BEHAVIOR-VARIABLES (&OPTIONAL (STREAM T))

WRITE-COMPILED-HANDLERS

WRITE-FILE (FILE LINES)

WRITE-FILE-ARRAY (FILE ARRAY &KEY ELEMENT-TYPE)

WRITE-FRAME (FRAME &KEY (SITUATIONS (ALL-SITUATIONS)) (THEORIES (ALL-THEORIES)) HTMLIFY NULLS-OKAYP ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW SAVE-PROTOTYPEP)

WRITE-FRAME-IN-SITUATION (FRAME SITUATION &KEY HTMLIFY THEORYP ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW SAVE-PROTOTYPEP)

WRITE-FRAME0 (FRAME &OPTIONAL (SITUATIONS (ALL-SITUATIONS)) (THEORIES (ALL-THEORIES)) HTMLIFY ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW SAVE-PROTOTYPEP)

WRITE-FRAME2 (FRAME SITUATION SLOTSVALS0 QUANTIFIER JOINER &KEY HTMLIFY THEORYP ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW SAVE-PROTOTYPEP (TAB 0))

WRITE-KB (&KEY (STREAM *STANDARD-OUTPUT*) (OBJECTS (GET-ALL-OBJECTS)) SITUATIONS0 (RESET-KB T) (INCLUDE-EXPLANATIONSP T))

WRITE-KM-LIST (LIST &OPTIONAL (STREAM T) (FIRST-TIME-THROUGH T))

WRITE-KM-VALS (VALS &OPTIONAL (STREAM T))

WRITE-KM-VALS2 (VALS &OPTIONAL (STREAM T))

WRITE-KMEXPR (KMEXPR _TAB HTMLIFY)

WRITE-LINES (STRUCTURE &OPTIONAL (STREAM T))

WRITE-SITUATION-SPECIFIC-ASSERTIONS (SITUATION-CLASS &KEY HTMLIFY)

WRITE-SLOTSVALS (SLOTSVALS &OPTIONAL (TAB 2) HTMLIFY ESSENTIALS PARTIALLY-CLONED-FROM SLOTS-TO-SHOW SAVE-PROTOTYPEP)

WRITE-SLOTVALS (SLOTVALS &OPTIONAL (TAB 2) HTMLIFY ESSENTIALS PARTIALLY-CLONED-FROM SAVE-PROTOTYPEP)

WRITE-STATE-VARIABLES (&OPTIONAL (STREAM T))

WRITE-VALS (VALS &OPTIONAL (TAB 2) HTMLIFY)

X-OR (A B)

XMLIFY (STRING)

YNREAD (&OPTIONAL (QUESTION-STR ))

ZERO (N)

MACRO

Private

Undocumented

DELAY (&REST BODY)

DO-OBJECTS (VAR &BODY BODY)

KEEPING-KB (&BODY BODY)

VARIABLE

Private

*BINDINGS*

Alist (pattern-var . binding), used for rule compilation.

*FILENAME-EXTENSIONS*

Filename extensions for Common Lisp. A cons of the form (Source-Extension . Binary-Extension). If the system is unknown (as in *features* not known), defaults to what compile-file-pathname produces.

*TRACE-FILE*

default trace file

*TRACE-TO-FILE?*

if true, the km traces are sent to the trace file set by (trace-to-file-on [<filename>]) and (trace-to-file-off) from lisp set by (t2f-on [<filename>]) and (t2f-off) from km

Undocumented

*ACL-READTABLE*

*ACTIVE-OBJ-STACK*

*ADD-COMMENTS-TO-NAMES*

*ADDITIONAL-KEYWORDS*

*ALL-FACETS*

*ALLOW-UNUNIFY*

*AM-CLASSIFYING*

*AM-IN-SITUATIONS-MODE*

*AM-REASONING*

*ANNOTATED-CONSTRAINTS*

*APPEND-STREAM*

*ARE-SOME-CONSTRAINTS*

*ARE-SOME-DEFAULTS*

*ARE-SOME-DEFINITIONS*

*ARE-SOME-PROTOTYPE-DEFINITIONS*

*ARE-SOME-PROTOTYPES*

*ARE-SOME-SUBSLOTS*

*ARE-SOME-TAGS*

*BUILT-IN-AGGREGATION-SLOTS*

*BUILT-IN-ATOMIC-VALS-ONLY-SLOTS*

*BUILT-IN-BAG-AGGREGATION-SLOTS*

*BUILT-IN-CLASSES*

*BUILT-IN-CLASSES-WITH-NO-BUILT-IN-SUPERCLASSES*

*BUILT-IN-CLASSES-WITH-NONFLUENT-INSTANCES-RELATION*

*BUILT-IN-COMBINE-VALUES-BY-APPENDING-SLOTS*

*BUILT-IN-FRAMES*

*BUILT-IN-INERTIAL-FLUENT-SLOTS*

*BUILT-IN-INSTANCES*

*BUILT-IN-INVERSE2S*

*BUILT-IN-INVERSES*

*BUILT-IN-MULTIVALUED-SLOTS*

*BUILT-IN-NON-FLUENT-SLOTS*

*BUILT-IN-NON-INERTIAL-FLUENT-SLOTS*

*BUILT-IN-NONFLUENT-LOOKUP-ONLY-SLOTS*

*BUILT-IN-REMOVE-SUBSUMEES-SLOTS*

*BUILT-IN-REMOVE-SUBSUMERS-SLOTS*

*BUILT-IN-SET-AGGREGATION-SLOTS*

*BUILT-IN-SINGLE-VALUED-SLOTS*

*BUILT-IN-SLOTS*

*BUILT-IN-SLOTS-WITH-CONSTRAINTS*

*CALLED-FORCES-UNIFICATION*

*CASE-PRESERVING-READTABLE*

*CATCH-EXPLANATIONS*

*CATCH-NEXT-EXPLANATIONS*

*CHECK-KB*

*CLASSES-USING-ASSERTIONS-SLOT*

*CLASSIFICATION-ENABLED*

*CLASSIFY-SLOTLESS-INSTANCES*

*CLONE-BUILT-FROM-SLOT*

*COERCE-UNDECLARED-SLOTS*

*COMPILE-HANDLERS*

*COMPILED-HANDLERS-FILE*

*CONSTRAINT-KEYWORDS*

*CONSTRAINT-SLOTS*

*CREATIONS*

*CURR-PROTOTYPE*

*CURR-SITUATION*

*CURRENT-RENAMING-ALIST*

*DECOMMENT-TOP-LEVEL-ONLY-HEADWORDS*

*DEFAULT-BUILT-IN-INERTIAL-FLUENT-SLOTS*

*DEFAULT-CARDINALITY*

*DEFAULT-FLUENT-STATUS*

*DEFAULT-KM-BEHAVIOR-FOR-EXPAND-TEXT*

*DELETED-FRAMES*

*DEPTH*

*DEREFERENCE-EXPLANATIONS-DURING-CLONING*

*DEREFERENCING-ON*

*DEVELOPER-MODE*

*DOWNCASE-KM-LISP-EXPRS*

*EAGERLY-UNIFY-PROTOTYPES*

*END-OF-SENTENCE-CHARS*

*EQUALITY-RELATIONS*

*ERROR-STRUCTURES*

*ERRORS*

*EXPAND-ESSENTIALS*

*EXPLANATIONS*

*FAST-DELETE-FRAME-STRUCTURE*

*FLUENT-INSTANCE-MARKER-STRING*

*FORCE-WITH-CLONED-FROM*

*GOAL-STACK*

*HISTORY*

*HTML-ACTION*

*HTML-WINDOW*

*INDENT-LEVEL*

*INDIRECT-CLASSIFICATION*

*INEQUALITY-RELATIONS*

*INFERENCE-REPORT-FREQUENCY*

*INFINITY*

*INSTALLING-INVERSES-ENABLED*

*INSTANCE-OF-IS-FLUENT*

*INTERACTIVE-PRECONDITIONS*

*INTERACTIVE-TRACE*

*INTERNAL-LOGGING*

*INVERSE-SUFFIX*

*JUSTIFY-LEAVES*

*KB-OBJECTS*

*KM-BEHAVIOR-PARAMETERS*

*KM-DEPTH-LIMIT*

*KM-FIXED-PARAMETERS*

*KM-GENSYM-COUNTER*

*KM-HANDLER-ALIST*

*KM-HANDLER-ALIST1*

*KM-HANDLER-ALIST2*

*KM-HANDLER-FUNCTION*

*KM-LISP-EXPRS*

*KM-PROFILE-START-CPU*

*KM-PROFILE-TOTAL-CPU*

*KM-PROFILE-TOTAL-ENTRIES*

*KM-READTABLE*

*KM-RUNTIME-VARIABLES*

*KM-STATE-PARAMETERS*

*KM-VERSION-STR*

*LAST-ANSWER*

*LAST-QUESTION*

*LENGTH-OF-INVERSE-SUFFIX*

*LESS-AGGRESSIVE-CONSTRAINT-CHECKING*

*LINEAR-PATHS*

*LOADSAVE-COMMANDS-WITH-KEYWORDS*

*LOGGING*

*LOGGING-CREATIONS*

*LOOPING*

*MAX-PADDING-INSTANCES*

*MULTIDEPTH-PATH-DEFAULT-SEARCHDEPTH*

*NEWLINE-STR*

*NEWLINE-STRING*

*NO-DECOMMENT-HEADWORDS*

*NO-HEURISTIC-UNIFICATION*

*NODES-CLONED-TO-CACHING*

*NODES-CLONED-TO-KEYS*

*NON-INVERSE-RECORDING-CONCEPT*

*NON-INVERSE-RECORDING-SLOT*

*NOSPACE-STRING*

*NOTED-DONE*

*NULL-BINDING*

*NULL-BINDINGS*

*OBJ-STACK*

*ON-ERROR*

*OUTPUT-PRECISION*

*OVERRIDING-IN-PROTOTYPES*

*PARTIALLY-INCLUDED-PROTOTYPE*

*POSTPONED-CLASSIFICATIONS*

*PRINT-EXPLANATIONS*

*PROFILING*

*PROJECT-CACHED-VALUES-ONLY*

*PROPOGATE-EXPLANATIONS-TO-CLONES*

*PROTO-MARKER-STRING*

*PROTOTYPE-CLASSIFICATION-ENABLED*

*PROTOTYPE-EXPLANATION-TYPES-TO-SAVE*

*PROTOTYPE-SLOTS-NOT-TO-SAVE-TO-FILE*

*RECORD-EXPLANATIONS*

*RECORD-EXPLANATIONS-FOR-CLONES*

*RECORD-SOURCES*

*RECURSIVE-CLASSIFICATION*

*RECURSIVE-PROTOTYPES*

*REMOVE-TEMPORARY-VIA-BACKTRACKING*

*REMOVE-VIOLATING-INSTANCES*

*REPORT-EXPLANATION-CLONE-WARNINGS*

*RESERVED-KEYWORDS*

*RESET-STATISTICS-ENABLED*

*SANITY-CHECKS*

*SEE-STREAM*

*SEE-UNIFICATIONS*

*SET-CONSTRAINT-KEYWORDS*

*SHOW-COMMENTS*

*SHOW-INFERENCE-NUMBERS*

*SILENT-SPYPOINTS*

*SILENT-SPYPOINTS-LOG*

*SILENT-SPYPOINTS-STACK*

*SLOT-CHECKING-ENABLED*

*SLOTS-NOT-TO-CLONE-FOR*

*SLOTS-SLOTS*

*SLOTS-WITH-NONPARTICIPANT-SKOLEMS*

*SPECIAL-SYMBOL-ALIST*

*SPOT-RUNTIME*

*SPYPOINTS*

*START-JUSTIFICATIONS-WITH-BECAUSE*

*STATISTICS-CLASSIFICATION-INFERENCES*

*STATISTICS-CLASSIFICATIONS-ATTEMPTED*

*STATISTICS-CLASSIFICATIONS-SUCCEEDED*

*STATISTICS-CPU-TIME*

*STATISTICS-KB-ACCESS*

*STATISTICS-MAX-DEPTH*

*STATISTICS-QUERY-DIRECTED-INFERENCES*

*STATISTICS-SKOLEMS*

*STATISTICS-UNIFICATIONS*

*STATS*

*STORED-KB*

*STRUCTURED-LIST-VAL-KEYWORDS*

*SUBSLOT-COMMENT*

*SUBSLOT-COMMENT-TAG*

*SUSPENDED-TRACE*

*T-PACKAGE*

*T-READTABLE*

*TELL-STREAM*

*TMP-COUNTER*

*TOLERANCE*

*TOP-LEVEL-FAIL-MODE*

*TRACE*

*TRACE-CLASSIFY*

*TRACE-CONSTRAINTS*

*TRACE-GOAL-STACK*

*TRACE-MERGE-PROTOTYPE-VALS*

*TRACE-OTHER-SITUATIONS*

*TRACE-PROTOTYPE-ASSERTIONS*

*TRACE-RULES*

*TRACE-SUBSUMES*

*TRACE-UNIFY*

*TRACE-UNIFY-IN-PROTOTYPE*

*UNCLONABLE-SLOTS*

*UNSTACKABLE-KB-INSTANCES*

*USE-INHERITANCE*

*USE-NO-INHERITANCE-FLAG*

*USE-PROTOTYPES*

*USER-DEFINED-INFIX-OPERATORS*

*USER-HAS-BEEN-WARNED*

*USING-KM-PACKAGE*

*VAL-CONSTRAINT-KEYWORDS*

*VALID-CARDINALITIES*

*VALID-FLUENT-STATUSES*

*VAR-MARKER-STRING*

*VERBOSE-NUMBER-TO-TEXT*

*VISIBLE-THEORIES*

*WARNINGS*

*WHITESPACE-CHARS*

*YEAR*

CLASS

Private

Undocumented

DELAY (&REST BODY)

CONSTANT

Private

Undocumented

*BUILT-IN-SEQ-AGGREGATION-SLOTS*

*BUILT-IN-SUBSLOTS*

*CHECKPOINT*

*CLASSIFY-IN-LOCAL-SITUATIONS*

*COMMENT-MARKER-CHAR*

*DEFAULT-DEFAULT-FLUENT-STATUS*

*DEFAULT-FAIL-MODE*

*GLOBAL-SITUATION*

*IGNORE-ITEMS*

*INDENT-INCREMENT*

*KM-PACKAGE*

*MAXDEPTH*

*PRUNE-POINTS*

*VAR-MARKER-CHAR*