
#$
# 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 
