    #$
    # ke version 3.3 1999/3/31

    	Knowledge Explorer User Manual

    1. Getting Started
    ==================
    #$
    1.1. knowledge: knits & chits
    =============================

    The Knowledge Explorer (ke) is an interactive tool
    for organizing knowledge.  It helps the user to
    record, change, and search knowledge, and provides
    extensive error checking to ensure the internal
    consistency of the knowledge.

    Knowledge is an identification of the facts of reality,
    using words and sentences.  Knowledge Explorer uses
    a simplified English-like language to specify facts.
    The primary external knowledge sources are relational
    databases and transliterated English sentences.  The
    internal knowledge unit is an entity-characteristic-relation
    hierarchy; the change unit is a space-time dependent
    event.

    Knowledge depends on space, time, and view.  View
    refers to the hierarchy of concepts which is the
    context of all knowledge.

    #$
    1.2. knowledge representation
    =============================

    Knowledge is represented by English-like sentences.
    The basic input statement has this format

    	subject verb object prepphrase

    Here are examples of the four fundamental input statement
    types.

      Dick,Bob isa person				# hierarchy
      person is animal with identify		# definition
      Dick has sex=male,email=rhm@cdepot.net	# attribute name=value
      at time=now  Dick do walk  \			# action/event
              from space=home to space=store

    There are other speical input formats.

    The most obvious differences from ordinary English are

    	subject    is a comma-separated list of phrases
    	verb       is a knowledge representation verb
    	object     is a comma-separated list of phrases
    	prepphrase is a blank-separated list of prepositional phrases
    	phrase     is a blank-separated group of consecutive words
    	words      may contain many "special" characters, e.g.
    			   : / \ + - _ * .  @

    Ordinary English verbs are objects following the do operator.
    Verb tense information is supplied by the at phrase.
    Verb number information is redundant, and is discarded.
    Noun number information is supplied by quantifiers, e.g.,
    a, the, some, all, none.

    Other sentences accepted by ke are commands, questions,
    and assignments.  A command directs ke to perform a
    specific action, and has the format

    	! verb object prepphrase

    where verb is any ke action, e.g., read, write, check, hsize.
    A question directs ke to search its knowledge for specific
    information, and has the format

    	subject verb object ?		# true or false
    	subject verb ?
    	subject ?    object
    	?       verb object

    The attributes of ke are "parameters" and "variables" which can
    be set by the user.  An assignment requests ke to change the
    value of an attribute, and has the format

    	attribute = value

    (The assign action is implied by the presence of "=".)
    The user can ask for the current value of any attribute
    with a question of the form

    	attribute = ?

    Examples of parameters are kformat, hformat, hcheck, cname.
    Examples of variables are
    	$question, $command, $assignment, $if,
    	$I, $we, $he, $she, $it, $they, $none

    #$
    1.3. executing ke
    =================

    ke can be executed from the command line prompt in UNIX or
    a DOS window.  In Windows, ke can be executed from the RUN menu,
    or from Windows Explorer by double-clicking on ke or any file
    whose extension has been associated with ke.  A complete
    execution command has the format

    	ke input-file

    Here is a simple example of the console input/output resulting
    from executing ke.  (Some output lines are not shown.)

    	ke
    	input  file <input>
    	output file <output>
    	error  file <output>
    	log    file <input.log>
    	Tuesday, February 3, 1998  10:00 am
    	Knowledge Explorer version 2.1 program 1998/2/3 knowledge 1998/2/3
    	##### new knit: <view=v_input> #####
    	<v_input:.=existent> animal is ?
    	animal is entity with live,move
    	<v_input:.=existent> man is ?
    	man is person is animal with identify
    	<v_input:.=existent> !exit
    	##### exit #####

    Typing "ke" begins the execution, and produces 9 lines of
    output from ke.  The first 4 lines show the default
    file names, used because no files were specified on the
    command line.  "input" and "output" refer to the keyboard
    and the display.  The next 2 lines give the time of execution
    and the version of ke.  "v_input" is the view name automatically
    assigned for the input file "input".  "<v_input:.=existent>" is the
    prompt which indicates that ke is waiting for user input from
    the keyboard.  "v_input" is the current view (knowledge unit).
    "." is the symbol denoting the current concept.
    "=" is the current separator for characteristic name-value pairs.
    "existent" is the current concept.
    "animal is ?"  requests ke to search its knowledge for the definition of animal.  The next line is the definition.  Ditto for
    "man is ?", but the definition has been augmented with the list of aliases for man.  "!exit" commands ke to immediately terminate this
    execution, without checking the knowledge or recording it in
    input.out.

    #$
    1.4. self knowledge
    ===================

    The initial knowledge, <view=tabula_rasa>, of the Knowledge
    Explorer includes a knowledge of itself.  Consequently, the
    user can can ask ke what actions/attributes it has,

    	ke do ?
    	ke has ?

    and what the definition of any action/attribute is, e.g.,

    	kformat is ?

    The ke attributes are "parameters" and "variables" which
    you can change by assignment.

    #$
    1.5. context stack
    ==================

    Many English words are ambiguous, i.e., they have many different
    definitions.  Each definition corresponds to a different view
    (hierarchy).  A convenient technique for resolving ambiguity is
    to build a stack of hierarchies containing the defintions,
    and search down the stack to find the appropriate definition.

    Knowledge Explorer maintains a view stack, which can be accessed
    using the commands

    	!vpush vname,...
    	!vpop

    Commands and questions can be applied to all views using the
    vdo and vfind commands

    	!vdo sentence
    	!vfind name     # "*" is a wildcard

    2. Input
    ========
    #$
    2.1. input menu
    ===============
    The menu command

    	!menu

    provides a user friendly interface which prompts the user for all
    necessary information and automatically generates input with the
    correct syntax.  It is especially useful when first learning the
    Knowledge Representation language.

    The menu command is available for Windows and UNIX, but not for MS-DOS.

    There are two input windows: "KE input menu" and "wke" ("ke" on UNIX).  You can exit from "KE input menu" by selecting File/Exit, and reactivate it by typing !menu in the "wke.bat" window.  If you close either window, the other window is also closed, i.e., the execution of wke is terminated.

    You may find it faster to navigate "KE input menu" using the keyboard rather than the mouse. After pressing the ALT key, you can then select a menu item by typing the first letter of its name, or by using the arrow keys.

    A scrollable "wke" window will be available in the near future.
    For now, the default output format (in KEHOME/kb/newknit.ku) has been changed from charformat=line to charformat = column to minimize the chances of output flowing off the edge of the window.
    Line format looks like this
        Dick has sex=male, email=rhm@cdepot.net
    Column format looks like this
        Dick has
            sex=male,
            email=rhm@cdepot.net

    #$
    2.2. input format
    =================

    The fundamental unit of input is a phrase -- a group of
    consecutive words, e.g.:

    	the big red house

    Phrases are separated by the keywords of the KR language
    (e.g.: isa, is, has, do, =).  For example:

    	the house has color=bright red

    Wherever a phrase can occur, a comma-separated list of phrases
    is allowed, e.g.:

    	John, Mary isa person
    	Mary, Jane has sex=female

    There are 6 different input formats, specified by values of
    the ke parameter kformat.

    	kformat	meaning
    	-------	-------
    	ku		knit file
    	cu		chit file
    	rel		relation file
    	ho		hierarchy outline
    	htm,html	embedded HTML commands

    In addition, there are ke parameters which supply "global"
    information for an input file.  These global parameters are
    saved before each read, and restored after the read.

    	parameter	meaning
    	---------	-------
    	kname		current knit name
    	cname		current concept name
    	kformat		input format (default "ku")
    	hformat		output format (default "ho")
    	nvseparator	name value separator (default "=")
    	rseparator	relation separator (default ";")
    	hseparator	hierarchy outline separator (default "/")
    	removehtml  remove HTML option (default YES)
    	kerror	number of errors detected

    File names are automatically mapped into values of kformat
    and cname.  For example, the input file sibling.rel
    automatically maps to cname=sibling and kformat=rel.
    You can override the automatic mapping with extra
    parameters on the read command.  For example

    	!read brother with cname=sibling,kformat=rel,rseparator=","

    The cu format is identical to the ku format, but the
    processing of action/events is different.  The input
    statement

    	Dick do walk

    is interpreted as an action declaration in ku format,
    but is interpreted as as an event declaration (the occurrence
    of an action) in cu format.  Specifically, the statement is
    interpreted as

    	at space=SPACE,time=TIME,view=VIEW  Dick do walk

    where SPACE,TIME,VIEW are the current values of space,time,view.
    Each at phrase resets the current values.

    When a statement is prefixed with an explicit "at" phrase, e.g.,

    	at space=s,time=t  Dick do walk

    ku format is changed to cu format while processing of that one
    statement.

    The ho format is a conventient visual format for input and
    output of concept subhierarchies.  Here is a simple example:

    	animal
    	/	cat
    	/	dog
    	/	person
    	//		man
    	//		woman

    The "/" specifies the number of levels below the top concept
    in the subhierarchy, "animal".  White space (blanks and tabs)
    preceding concept names is ignored, and is used to make the
    subhierarchy easier to read.

    The htm,html format (and the other formats if removehtml=YES) allows embedding internet addresses in the data, e.g.,

    	email=<a href="mailto:rhm@cdepot.net">rhm@cdepot.net</a>

    allows you to use your web browser to send email by the
    "point and click" method.  ke ignores the HTML commands.

    #$
    2.3. statements
    ===============

    	at space=s,time=t,view=v				# create/load view

    	subject,... isa object,...				# hierarchy
    	subject,... ise object,... 				# hierarchy
    	subject is object						# identity/alias
    	subject is object with charname=charvalue,...	# definition
    	subject,... isin relname=relvalue			# general relation
    	subject,... has attrname=attrvalue,...		# attribute
    	subject,... haspart partname=partvalue,...	# part
    	subject,... do actname aobject = event		# action
    	event changes eobject \					# event
    		from attrname=initial \
    		to attrname=final

    	sentence1 causes sentence2				# causality
    	if sentence1 then sentence2 else sentence3 fi	# conditional
    	every variable is object,... do sentence done	# iteration
    	every variable isa object do sentence done	# iteration

    	subject do know sentence
    	subject do believe sentence
    	subject do say to person sentence

    #$
    2.4. events
    ===========

    The knowledge unit (knit) identifies what actions
    an entity has the capability of executing

    	at view=v  entity do action

    The change unit (chit) identifies the events of the
    actual execution of an action

    	at space=s,time=t,view=v 		entity do action aobject = event;
    	event changes eobject \
    			from attribute=initial \
    			to attribute=final

    The view is necessary because no concept has meaning
    without reference to its defining hierarchy.  In the
    general case, actions may have multiple events and/or
    multiple objects.  For the simplest case where the
    action is characterized by a single event and object,
    the above form may be simplified to

    	at space=s,time=t,view=v
    	entity do action aobject \
    		from attribute=initial \
    		to attribute=final

    For example,

    	at time=6pm  Bob do move car \
    		from space=driveway to space=garage

    For additional details, refer to the files
    	help/event.txt
    	cu/live.cu
    	cu/move.cu
    Online, enter
    	!help event
    or
    	action,event has ?

    #$
    2.5. commands
    =============

    	!menu
    	!read file,...  with attribute=value,...
    	!write file,...  with attribute=value,...
    	!cd file
    	!help topic,...
    	!check item,...
    	!hsize cname,...
    	!psize cname,...

    The result of each command (value of !) is stored in
    the variable $command.  $command can be used in
    formulating new questions, requests, or statements.
    For example,

    	!find *computer*
    	$command has ?

    lists the attributes of all concepts whose name
    includes the string "computer".

    For the complete list, see Appendix D.
    Online, ask ke by entering

    	ke do ?

    #$
    2.6. questions
    ==============
    Questions are formed from statements by appending ?

    	subject verb object ?		# true or false

    or by replacing subject, verb, or object by ?

    	? verb object
    	subject ? object
    	subject verb ?

    In addition, there are some specialized forms

    	subject isa**? object
    	subject ise**? object
    	subject has charname=?
    	? is ?			# dictionary
    	? has ?			# all attributes of all concepts

    In response to a question, ke searches its knowledge
    for facts that match the pattern.  The value of ?,
    i.e., the facts which match that part of the pattern,
    are saved in the variable $question.  $question can
    be used in formulating new questions, requests, or
    statements.  For example,

    	person ise ?
    	!first-name $question

    lists the first-names of all persons.

    For finding names in a hierarchy, a pattern may be specified
    using the "wild card" character "*".  "*" matches any string
    of characters.  For example,

    	!find Dick*

    finds all concepts beginning with "Dick".  find matches
    either upper or lower case.

    To search all views, use the vfind command.

    	!vfind name

    #$
    2.7. relations
    ==============

    The definition of a relation must be given before reading
    its relation file.  For example,

    	r_phone is relation with
    		format="phone:1; person:2",
    		meaning="$2 has phone=$1"
    	r_phone has rseparator=";"
    	!read r_phone.rel

    If separator is not specified, the default is the value
    of the ke parameter rseparator.  At startup, the default
    value is ";".

    If the relation file contains

    	209-295-1365;	Dick McCullough

    then ke records the following knowledge

    	209-295-1365 isa* phone
    	Dick McCullough isa* person
    	Dick McCullough has phone=209-295-1365

    ke trims leading and trailing white space (blank,tab,return)
    from each field of the relation tuple, and encloses the
    field in quotes if necessary (if it contains comma or
    semicolon).

    By using cname and kformat, relation definitions and data
    can be put into a single file.  For the preceding example,
    the single file would be

    	r_phone is relation with
    		format = "phone:1; person:2",
    		meaning = "$2 has phone=$1"
    	cname = r_phone
    	kformat = rel
    	209-295-1365; Dick McCullough

    For additional details, refer to file help/relation.ku.
    Online, enter

    	relation has ?

    #$
    2.8. attributes
    ===============

    Attribute values can be simple strings

    	Dick has sex=male
    	r_phone has format="phone:1; person:2"

    or comma-separated lists

    	Dick has child += Sheila
    	Dick has child += Ted
    	Dick has child -= John
    	Bob has child = [Amy, Diana, Kathy]

    The operator =  replaces the current value of the attribute.
    The operator += inserts the value into the list of values.
    The operator -= deletes the value from the list of values.
    "[" and "]" are used to delimit lists of values.
    The operators = and += can be used in questions

    	Dick has child = Ted ?	# exactly 1 child named Ted
    	Dick has child += Ted ?	# 1 or more children, 1 named Ted

    The separator character for charname/charvalue processing
    is the value of the ke parameter nvseparator.  If the subject and
    "has" are omitted, the applicable concept name is the value of
    the ke parameter cname.  (Except if charname is a ke parameter, which
    is a "global" name, and "ke" is the applicable concept name.)

    #$
    2.9. parameters
    ===============

    For a full list of ke parameters, see Appendix E.
    Online, enter

    	ke has ?

    To get the current value of any parameter, e.g., hformat

    	hformat = ?
    or
    	ke has hformat=?

    To get a definition, enter

    	hformat is ?

    All the parameters are listed in help/ke.ku.
    Their definitions are given in kb/kedef.ku.
    Their range of values and initial values are given
    in help/kvalue.ku and kb/newknit.ku.  You can
    change the initial values of parameters by
    editing kb/init.ku.

    You can define additional ke attributes for your
    own purposes, e.g.,

    	ke has temp="now is the time"

    These additional attributes are not "parameters", since
    there are no predefined control functions associated with
    them.

    3. Output
    =========
    #$
    3.1. output format
    ==================

    	hformat	alpha,ho,ku
    	htab		indent (integer)
    	hpad		minimum size of name field (integer)
    	charformat	line,column

    hformat = alpha   alphabetical list (good for systematic reviews)
    hformat = ho      hierarchy outline
    hformat = ku      successive levels of hierarchy (ise)

    #$
    3.2. hierarchy
    ==============

    Output is generated by the write command and by questions.
    The concepts which are written depend on the ke parameters
    hfocus and hminfactid.  hfocus specifies a list of concepts

    	hfocus = [concept,...]
    	hfocus += concept

    hminfactid is a threshold on the unique number used to
    identify facts input to ke; it can be used to filter out
    "old" facts, e.g.

    	hminfactid = 100
    	hminfactid = klastid

    (klastid is a readonly ke parameter which contatins the last
    unique number assigned.)  Before terminating, ke automatically
    writes to the output-file nonexistent and the hfocus list for
    each knit.  This automatic output is skipped if "!exit" is the
    last input command.  Note that the values of hfocus and
    hminfactid can be different in each view.

    #$
    3.3. checks
    ===========

    	loop
    	link
    	genus
    	newword
    	newstatement
    	chit
    	event
    	alias
    	definition
    	characteristic
    	value
    	part
    	enumeration
    	requisite
    	sequence
    	set
    	hierarchy
    	lattice

    Entering "!check knit" performs all of the checks.

    For details, see Appendix C.
    Online, enter

    	enum_check isenum ?

    Before terminating, if hcheck = "yes", ke automatically writes
    to the output file the results of "!check knit" for each knit.
    This automatic output is skipped if "!exit" is the last input command.

    #$
    3.4. searches
    =============
    The information generated by a search of ke's knowledge can take
    any form, from a single name to a long list of names or a hierarchy.
    An appropriate format is automatically determined by ke.  The output
    format will usually be the same as the input format, so that output
    data can be processed as input data at a later time.  Hierarchies
    are an exception to this rule: default input format is "ku", and
    default ouput is "ho".

    4. Processing Knowledge
    =======================
    #$
    4.1. conditional and iteration
    ==============================

    Conditional statements:

    	if sentence:1 then sentence:2 else sentence:3 fi

    Examples:

    	if	unit isa concept and
    		concept has type=x then
    		unit has type=x fi

    	if	subject do verb then
    		verb has type=action fi

    	if	subject has name=value then
    		name hasval value fi

    Condtionals are automatically continued when the last symbol
    on the line is "if","then","else","and","or","not".  ("and" is automatically
    translated to "&", "or" to "|",
    "not" to "~".)

    Iteration statement:

    	every x is cname,... do sentence done
    	every x isa cname do sentence done

    Within the sentence, the value of the variable x is denoted by $x.
    For example,

    	every x isa person do
    		$x is ?; 	# definition, including all aliases
    		$x has ?; 	# all attributes
    		$x do ?; 	# all actions
    		$x isin ?;	# all relations, methods
    	done

    #$
    4.2. variables
    ==============

    Variables are used in

    	every variable isa cname do
    		... $variable ... done
    	every variable is  clist do
    		... $variable ... done

    	m is method with
    		format="class:1,...",
    		meaning="... $1 ..."

    	r is relation with
    		format="class:1;...",
    		meaning="... $1 ..."

    	!cc concept

    To facilitate accessing the attributes and actions of a concept,
    the "cc" command sets the following $ variables:

    	$class 	# concept isa* class
    	$genus 	# list of all genus (more than one for a lattice)
    	$unit 	# list of all units
    	$alias 	# list of all aliases
    	$attribute 	# list of all attributes
    	$attr 	# value of an individual attr
    	$action 	# list of all actions
    	$act 		# event of an individual act
    	$1,$2,... 	# role values of a relation unit
    	$fact 	# input text (if applicable)

    #$
    4.3 identify
    ============

    By definition,

    	knowledge is the identification of a fact of reality

    i.e., it is the result of a person identifying some aspect
    of reality.  In my KR language, this is expressed as

    	knowledge := person do identify existent

    There are many ways to represent knowledge, depending
    on the person's purpose for identifying.  This can be
    expressed as

    	knit := person do identify existent with purpose

    If a specific person identifies a specific entity, we
    can record that as

    	at space=s,time=t
    	John do identify book_123

    This information can be retrieved using the question

    	John do identify ?

    In order to deal with this kind of knowledge, the
    "empty" base view, tabula_rasa, must include the
    axiomatic concepts:

    	existent
    		entity
    			man
    			knowledge
    		characteristic
    			attribute
    				space
    				time
    				view
    			action
    				identify
    		relation
    				[knowledge := man do identify existent]

    and these additional concepts:

    	existent
    		entity
    			knowledge
    				knit
    			Knowledge Explorer
    		characteristic
    			attribute
    				purpose
    				Knowledge Explorer attribute
    			action
    				identify
    				Knowledge Explorer action
    		relation
    				[knit := man do identify existent
    									with purpose]

    Multiple views are described as follows

    	at view=tabula_rasa
    	...
    	v1 := person1 do identify existent with purpose=p1
    	at view=v1
    	sentence1
    	...
    	v2 := person2 do identify existent with purpose=p2
    	at view=v2
    	sentence2
    	...

    In essence, identify is the process of concept formation.
    Some further details may be found in

    	KEHOME/id/identify.htm

    #$
    4.4 measure and classify
    ========================

    	!measure cname with attrname

    	!classify newcname with attrname to oldcname

    #$
    4.5. integrate and differentiate
    ================================

    isa,ise are used to define a hierarchy.  isd,isi are used to
    move concepts in an existing hierarchy, and to create new
    concepts.  For example,

    	man isa animal
    	man isa person

    produces an ambiguous concept of man, i.e.,

    	man isa animal or person

    On the other hand,

    	man isa animal
    	man isd person

    replaces the original concept man isa animal with the
    concept man isa person.

    	x,y,z   isd concept
    	concept isi x,y,z

    are equivalent statements.  ke moves x,y,z from current positions
    in the hierarchy to positions under concept.

    	x isd nonexistent

    declares x to be nonexistent, i.e., a logical contradiction,
    an "imaginary" concept.  x is effectively "destroyed", but
    "for the record" ke positions it under nonexistent.

    If a list of characteristics is specified

    	new-concept isi x,... with char,...
    	!isi x,... with char,...
    	!isd y with char,...

    ke creates one (or more) level(s) of intermediate concepts,
    creating new concept names as necessary.  The new concepts
    which are created are groups with equal values of the
    characteristic(s) specified in the "with" phrase.

    #$
    4.6 exploring a concept-hierarchy
    =================================

    # 1. find a concept
    #------------------#
    	!find *name*	# search by name ("*" wildcard)
    	? has attr		# search by attribute
    	? do act		# search by action

    # 2. change concept
    #------------------#
    	!cc $command 		# set "." to the concept
    	!cc $question 		# set "." to the concept

    # 3. explore details
    #-------------------#
    	. is ?		# definition
    	. has ?		# attributes (intension)
    	. do ?		# actions
    	. isa* ?		# wider concepts
    	. ise* ?		# referents (extension)

    	!nc ..		# step through genus of concept
    	!nc ...		# step through units of concept

    	. isa**1 ?; $question ise**1 ?	# siblings
    	. isa**2 ?; $question ise**2 ?	# cousins

    # 4. calculate attribute
    #-----------------------#
    	!measure . with newattr	# new attribute (conceptual scaling)

    # 5. differentiate concept
    #-------------------------#
    	!isd . with newattr	# new concept-hierarchy
    					  (concept-formation)

    To facilitate the exploration of concept-hierarchies
    (or concept-lattices), I have extended the UNIX directory
    "dot" notation to three levels:
        /   is existent
        ..  is the current genus of the current concept
        .   is the current concept
        ... is the current unit of the current concept
    The three "dot" concepts can be used in any Knowledge Explorer
    statement, command or question.  The "next concept" command
    steps through all possible values of ".." or "...".  The "dot"
    concepts are especially handy when the concept names are long.

    For example, consider the heading lattice from Keith Devlin's
    book "Goodbye, Descartes" (KEHOME/book/gd.ho).  It is a lattice,
    not a hierarchy, because "Goodbye, Descartes" is the heading
    for both the book (the title) and a chapter section.
    If I hadn't included the chapter number, straight from the
    table of contents, "Goodbye, Descartes" would also be the
    heading of chapter 11.

    After loading the lattice
        !read gd.ho
    and making "Goodbye, Descartes" the current concept
        !find Goodbye*
        !cc $command
    successive applications of the next concept command
        !nc ...
    give all the chapter headings, and
        !nc ..
    gives the heading of chapter 11.

    The Knowledge Explorer input prompt has one of the three forms
        <cview:..=cgenus>
        <cview:.=cconcept>
        <cview:...=cunit>
    depending on whether or not the "nc" command is in progress.
    The names are
        cview    current view
        cgenus   current genus of current concept
        cconcept current concept
        cunit    current unit of current concept

    5. Examples
    ===========
    #$
    5.1. backyard (integrate)
    =========================
    see
    	KEHOME/id/backyard.ku

    #$
    5.2. dynamic search hierarchy (multilevel differentiate)
    ========================================================
    see
    	KEHOME/id/topic.ku
    	KEHOME/id/r_book.rel

    #$
    5.3. English
    ============
    see
    	KEHOME/english/nurse.cu		# from Reuter news story
    	KEHOME/english/schank.cu	# from artificial intelligence 							  textbook

    #$
    5.4. Family History (change unit)
    =================================
    see the directory
    	KEHOME/family/

    #$
    5.5. Family Relations (multilevel operators)
    ============================================
    see
    	KEHOME/family/readme.txt

    6. Advanced Features
    ====================
    #$
    6.1. types
    ==========
    Each concept has a ctype and a vtype.  ctype is used to make some high level checks of concepts.  The units of a concept inherit its ctype.
    The legal values of ctype are

    	concept
    	existent, nonexistent
    	knit, chit
    	entity, characteristic, attribute, action
    	relation, event, phenomenon
    	undefined
    	etc (unique names generated to replace "...")
    	fact
    	any (named "*")
    	unknown (named "unknown")

    vtype is used to make some high level checks of attribute values.
    The legal values of vtype are
    	enumeration
    	requisite
    	sequence
    	set
    	integer
    	hierarchy
    	lattice

    #$
    6.2. values
    ===========
    The value of an attribute is the measurement of a common property
    of the members of a group.  Conceptually, the value can be anything,
    e.g., a simple name, a multidimensional vector, ...
    For simplicity, ke represents the attributes as lists of strings,
    e.g.,
    	Dick has sex=male
    	hfocus = [person, event]
    	Dick has child+= Sheila

    The interpretation of the meaning of the list is left to the user.

    #$
    6.3. parts
    ==========
    The attributes and actions of an entity constitute the identity, or fundamental nature, of the entity.  They cannot be separated from the entity.

    The parts of an entity are subentities that can be separated, physically or conceptually, from the entity.

    For example, the "identify" action is the defining characteristic of
    man.  It cannot be separated from man.  By contrast, the
    picture tube in a television set is a part, which can be physically
    separated from the television set.  If you remove the picture
    tube, what remains is not the same entity, although you might still
    consider it a television set.

    Knowledge Explorer describes parts as follows:

    	entity haspart partname=partcount,...

    #$
    6.4. logic
    ==========

    Knowledge Explorer accepts sentences of the form

    	if clause:1 then clause:2 fi
    	if clause:1 then clause:2 else clause:3 fi

    ke determines the truth of clause:1 by matching it against its stored knowledge, as in

    	clause:1 ?

    If clause:1 is "true", then ke records/executes clause:2.
    If clause:1 is "false", ke records/executes clause:3.
    If ke does not know how to determine the truth (clause:1 not implemented), it reports "unknown" and does not record/execute
    either clause.  The truth value ("?") is saved in variable "$if".

    A causal relation is denoted by

    	clause:1 causes clause:2
    	clause:1 => clause:2
    	clause:2 <= clause:1

    Implication is denoted by

    	clause:1 implies clause:2
    	clause:1 |- clause:2

    Other common notations accepted are

    	clause:1 iff clause:2

    and

    	space=s,time=t,view=v |=  sentence:1

    #$
    6.5. context stack
    ==================

    Knowledge Explorer maintains a stack of views.
    The following commands are available to manipulate
    this "context stack".

    	!vpush vname,...
    	!vpop

    Currently, only vpush is invoked automatically by
    Knowledge Explorer.  Each new view name is automatically
    pushed onto the view stack.  You can use the view stack
    commands to manually explore context dependence.

    #$
    6.6. enumeration, requisite, sequence, set
    ==========================================

    ke treats all attribute values as strings, as though
    they were simple names.  But when ke interprets the
    meaning of these strings, it must consider the true
    nature of the attribute value.  The most basic value
    types are

    	enumeration	x isenum y or   z or   ...
    	requisite	x isreq  y and  z and  ...
    	set		x isset  y and  z or   q and r or ...
    	sequence	x isseq  y next z next ...

    ke can associate a single value of each of the above
    types with each concept.  These associated values have
    been used for more efficient implementation of attributes
    that match these value types.

    For example, the format attribute of a relation is
    sequential by nature.

    	x has format="y:1; z:2"

    is represented internally as

    	x isseq y:1 next z:2

    Ditto for the event sequence of an action.

    	live is action with a_event="birth:1; death:2"

    is represented internally as

    	live isseq birth:1; death:2

    The four basic logic operators have the following aliases.

    	or   is "|"
    	and  is "&"
    	next is ";"
    	not  is "~" is non

    (Future versions may define "non x" relative to the genus of x,
    instead of relative to "existent".)

    The genus/unit operator which defines the concept
    hierarchy

    	x ise y,z,...

    is also an enumeration, but it has a separate set of links
    for its implementation.  Enumerations are used for the
    value types of attributes like kformat.

    The combination of requisites and enumerations can be
    used to implement the canonical minterm expansion of a
    boolean set.  For two variables, this has the form

    	x isenum y&z | y&~z | ~y&z | ~y&~z

    #$
    6.7. operator lists
    ===================
    The equivalent expressions

    	x isa y
    	y ise x

    mean that x and y are on adjacent levels of the concept-hierarchy.
    Knowledge Explorer extends this notation to concepts which are n levels apart,

    	x isa**n y
    	y ise**n x

    where n may be any integer (including 0 and negative values).
    ke also accepts the "regular expression" style of notation

    	x isa* y
    	x isa+ y

    for concepts separated by 0 or more levels, and concepts separated
    by 1 or more levels.

    In a formal algebraic sense, the isa* and isa+ are operator lists

    	isa* isenum isa**0, isa**1, isa**2, ...
    	isa+ isenum isa**1, isa**2, ...

    where isa**0 and ise**0 are equivalent to is.

    In this sense, we can say that Knowledge Explorer accepts
    verb/operator lists, as well as subject and object lists.

    Appendices
    ==========
    #$
    A. author
    =========

    	Richard H. McCullough
    	26459 Parkwood Drive
    	Pioneer, CA 95666-9586
    	USA

    	mailto:rhm@cdepot.net
    	http://www2.cdepot.net/~rhm
          phone:209-295-1365

    Visit the Knowledge Explorer Home Page

    	http://www2.cdepot.net/~rhm

    for links to

    	Knowledge Explorer download files
    	Knowledge Explorer News (free)
    	Secure online registration (credit card)

    #$
    B. installation
    ===============

    # Downloads
    #----------
    ftp:/ftp.cdepot.net/pub/ke/kewin.exe	Windows 98/95/NT/3.x
    ftp:/ftp.cdepot.net/pub/ke/kelin.tgz	Linux
    ftp:/ftp.cdepot.net/pub/ke/kebsd.tgz	BSD/OS UNIX
    ftp:/ftp.cdepot.net/pub/ke/kesol.tgz	Sun Solaris UNIX
    ftp:/ftp.cdepot.net/pub/ke/kewin.exe	MS-DOS

    # Directory Structure
    #--------------------
    ke
    	bin		executables
    	book		book examples
    	context	context examples (AAAI 1997 symposium)
    	cu		change unit examples
    	english	English examples
    	family	genealogy application
    	fca		Formal Concept Analysis examples
    	help		help files
    	ho		hierarchy outline example
    	id		concept formation examples
    	indexing	book and library indexing application
    	internet	internet examples
    	kb		initial knit files
    	ku		knowledge unit examples
    	logic		logic examples
    	rel		relation examples
    	src		ke source code

    # Executables
    #------------
    	ke		knowledge explorer
    	ksc		knowledge syntax checker
    	iversion	identify Icon version & features
    	icont		Icon translator
    	iconx		Icon executor

    	wke		Windows knowledge explorer
    	wksc		Windows knowledge syntax checker
    	wiversion	identify Windows Icon version & features
    	wicont	Windows Icon translator
    	wiconx	Windows Icon executor
    	wi		Windows Icon Integrated Development Environment

    # Initial knit files
    #-------------------
    	init.ku	user initialization file
    	newknit.ku	minimum hierarchy
    	newdef.ku	definitions
    	kedef.ku	ke attribute and action definitions
    	kversion.ku ke version number and date

    # Windows Installation
    #---------------------
    1. Decompress files
    	double-click kewin.exe
    2. Restart system
    3. Execute ke using "Run" window or "DOS" window
    	ke input-file output-file error-file log-file
       or
    	double-click on ke.exe
       or
    	double-click on .ku,.cu files

    # UNIX Installation
    #------------------
    1. Decompress files
    	mkdir your-installation-directory
    	cd your-installation-directory
    	gzip -d kebsd.tgz
    	pax -r -f kebsd.tar
    2. Change .profile
    	KEHOME=your-installation-directory; export KEHOME
    	PATH=$KEHOME/bin:$PATH; export PATH
    	ICONX=$KEHOME/bin/iconx; export ICONX
    	MSTKSIZE=20000; export MSTKSIZE
    	BLKSIZE=1000000; export BLKSIZE
    3. Execute .profile
    4. Execute ke
    	ke input-file output-file error-file log-file

    #$
    C. checks
    =========

    	knit  (performs all checks listed below)

    	alias
    	characteristic
    	chit
    	definition
    	enumeration
    	event
    	genus
    	hierarchy
    	lattice
    	link
    	loop
    	newstatement
    	newword
    	part
    	requisite
    	sequence
    	set
    	value

    #$
    D. commands
    ===========
    	menu

    	cc, nc
    	cd, pwd
    	check
    	count
    	dir, ls
    	dump
    	exit
    	find
    	help
    	print
    	read
    	write
    	vpush, vpop
    	vdo, vfind

    	isd
    	isi
    	measure
    	classify

    	hsize, psize, fsize, hlevel, hdepth
    	hlist, plist, flist
    	upath, gpath
    	lub
    	glb

    	type, ctype, vtype
    	val_size
    	genus_size
    	unit_size
    	enum_size
    	req_size
    	seq_size
    	alias_size
    	echar_size
    	char_size
    	part_size
    	do_size
    	id_size
    	fact_size

    #$
    E. parameters & variables
    =========================
    	charformat
    	cname
    	debug
    	echo
    	hchar
    	hcheck
    	hfocus
    	hformat
    	hmaxlevel
    	hmethod
    	hminfactid
    	hop
    	hpad
    	hreduce
    	hseparator
    	htab
    	kaction
    	kcase
    	kehome
    	kerror
    	kformat
    	klastid
    	kversion
    	mseparator
    	nvseparator
    	pseparator
    	qseparator
    	removehtml
    	rseparator
    	roleseparator

    	variables
    	---------
    	$assignment, $command, $if, $question
    	$I, $we, $he, $she, $it, $they, $none
    	$name 	(name is an alphanumeric string)

    #$
    F. tabula rasa
    ==============
    see
    	KEHOME/kb/newknit.ku
    	KEHOME/kb/newdef.ku

    #$
    G. operators
    ============
    see
    	KEHOME/src/token.icn

    #$
    H. separators
    =============
    see
    	KEHOME/src/token.icn

    #$
    I. quantifiers
    ==============
    	a, all, any, some, the
    	no
    	either

    #$
    J. grammar
    ==========
    see
    	KEHOME/src/symbol.icn
    	KEHOME/src/token.icn

    #$
    K. references
    =============

    1. David Kelley, "The Art of Reasoning", Second Expanded
    Edition, W. W. Norton & Company, 1993.

    2. David Kelley, "The Evidence of the Senses: A Realist Theory
    of Perception", Louisiana State University Press, 1988.

    3. Ayn Rand, "Introduction to Objectivist Epistemology",
    Expanded Second Edition, Meridian, 1990.

    4. Leonard Peikoff, "Objectivism: The Philosophy of Ayn
    Rand", Dutton, 1991.

    5. Harry Binswanger, "The Ayn Rand Lexicon", Meridian,
    1986.

    6. Leonard Peikoff, "Principles of Grammar",
    audio tapes.

    7. Morris I. Bolsky, David G. Korn, "The KornShell
    Command and Programming Language", Prentice-Hall, 1989.

    8. B.A. Davey and H.A. Priestley, "Introduction to Lattices and Order",
    Cambridge University Press, 1990.

    9. Keith Devlin, "Logic and Information",
    Cambridge University Press, 1995.

    10. Ronald Fagan, Joseph Y. Halpern, Yoram Moses and Moshe Y. Vardi,
    "Reasoning about Knowledge", The MIT Press, 1995.

    11. Ralph E. Griswold and Madge T. Griswold, "The Icon
    Programming Language", Third Edition, Peer-to-Peer
    Communications, Inc., 1996.

    12. Ralph E. Griswold, Clinton L. Jeffery, and Gregg M. Townsend,
    "Graphics Programming in Icon", Peer-to-Peer Communications, Inc.,
    1998.

    13. Richard H. McCullough, "Knowledge Explorer",
    The Icon Newsletter, No. 52, April 1, 1997.

    14. Richard H. McCullough, "Knowledge Explorer Tutorial",
    Internet, http://www2.cdepot.net/~rhm/tutorial.txt.

    15. Richard H. McCullough, "Knowledge Explorer User Manual",
    Internet, http://www2.cdepot.net/~rhm/ke.rtf.

    16. Richard H. McCullough, "Knowledge Explorer Home Page",
    Internet, http://www2.cdepot.net/~rhm.

    #$
    L. glossary
    ===========
    These definitions are from Ayn Rand, "Introduction to Objectivist
    Epistemology".

    concept is mental integration of two or more units possessing
    the same distinguishing characteristic(s), with their particular
    measurements omitted.

    conceptual common denominator is the characteristic(s) reducible to
    a unit of measurement, by means of which man differentiates two or
    or more existents possessing it.  (For example, number of sides is
    a common characteristic which can be used to differentiate between
    triangles and rectangles.)

    consciousness is the faculty of perceiving that which exists.

    definition is a statment that identifies the nature of the units
    subsumed under a concept.  (The purpose of a definition is to
    distinguish a concept from all other concepts and thus to keep its
    units differentiated from all other existents.)

    differentia is the distinguishing characteristic(s) which separate
    the units of the concept being defined from all other existents
    subsumed under the genus of the concept.

    epistemology is the science of the discovery of the proper methods
    of acquiring and validating knowledge.

    essential characteristic is the distinguishing characteristic that
    explains the greatest number of other characteristics.  (Metaphysically,
    the distinctive characteristic which makes possible the greatest
    number of other characteristics.)

    genus is the wider class of existents which share a conceptual
    common denominator(s) with the existents subsumed by the concept
    being defined.

    grammar is the science which deals with the formulation of the
    proper methods of verbal expression and communication (i.e., the
    methods of organizing words into sentences).

    knowledge is a mental grasp of a fact(s) of reality, reached either
    by perceptual observation or by a process of reason based on
    perceptual observation.

    language is a code of visual-auditory symbols that serves the
    psycho-episemological function of converting concepts into the
    mental equivalent of concretes.

    logic is the art of noncontradictory identification.

    measurement is the identification of a quantitative relationship
    established by means of a standard that serves as a unit.  (The
    purpose of measurement is to expand the range of man's consciousness,
    beyond the perceptual level.)

    meaning is the existents subsumed under a concept.

    number is a mental symbol that integrates units into a single larger
    unit (or subdivides a unit into fractions) with reference to the basic
    number of "one", which is the basic mental symbol of "unit".

    percept is a group of sensations automatically retained and integrated
    by the brain of a living organism.

    science is an organized body of knowledge, acquired by and communicable
    to a human consciousness.

    similarity is the relationship between two or more existents which
    possess the same characteristic(s), but in different measure or degree.

    unit is an existent regarded as a separate member of a group of two
    or more similar members.

    word is a visual-auditory symbol used to represent a concept.

    #$
    M. Icon
    =======

    The Knowledge Explorer is implemented entirely in Icon
    (see references by Griswold, etal).  Icon is a high-level language with
    built-in lists, sets, associative tables, generators,
    and string processing functions.

    The Knowledge Explorer package includes the Icon translator
    and executor.  Translators and executors for other machines,
    program libraries, and extensive documentation are available
    at the Icon web site

    	http://www.cs.arizona.edu/icon/

    There are several environment variables which control Icon
    memory allocation.

    	variable	Icon default	KE default
    	--------	------------	----------
    	BLKSIZE	500000		1000000
    	COEXPSIZE	  2000
    	MSTKSIZE	 10000		  20000
    	STRSIZE	500000

    If Knowledge Explorer aborts with a stack overflow,
    you can increase the value of MSTKSIZE.

    Index
    =====
    use Windows help file:

    	KEHOME/help/ke.hlp

    version
    Version
    gs_knowledge
    knowledge: knits & chits
    gs_knowledge_representation
    knowledge representation
    gs_executing_ke
    executing ke
    gs_self_knowledge
    self knowledge
    gs_context_stack
    context stack
    in_input_menu
    input menu
    in_input_format
    input format
    in_statements
    statements
    in_events
    events
    in_commands
    commands
    in_questions
    questions
    in_relations
    relations
    in_attributes
    attributes
    in_parameters
    parameters
    out_output_format
    output format
    out_hierarchy
    hierarchy
    out_checks
    checks
    out_searches
    searches
    proc_conditional_iteration
    conditional and iteration
    proc_variables
    variables
    proc_identify
    Identify
    proc_measure_classify
    measure and classify
    proc_integrate_differentiate
    integrate and differentiate
    proc_exploring_a_concept-hierarchy
    exploring a concept-hierarchy
    ex_backyard
    backyard (integrate)
    ex_dynamic_search_hierarchy
    dynamic search hierarchy (mulilevel differentiate
    ex_english
    english
    ex_family_history
    Family History (change unit)
    ex_family_relations
    Family Relations (multilevel operators)
    adv_types
    types
    adv_values
    values
    adv_parts
    parts
    adv_logic
    logic
    adv_context_stack
    context_stack
    adv_enum_req_seq_set
    enumeration, requisite, sequence, set
    adv_operator_lists
    operator lists
    a_author
    author
    a_installation
    installation
    a_checks
    checks
    a_commands
    Commands
    a_parameters
    parameters
    a_tabula_rasa
    tabula_rasa
    a_operators
    operators
    a_separators
    separators
    a_quantifiers
    quantifiers
    a_grammar
    grammar
    a_references
    references
    a_glossary
    glossary
    a_icon
    icon