Page Numbers: Yes First Page: 1
Heading:

January 29, 1977 1:44 PM [IVY]<KRL>document>str-formal

APPENDIX D -- THE STANDARD UNITS

NOTE: This is a first pass.

This file contains unit definitions for many of the standard parts of KRL-1. It is intended as a manual, providing a source of standard names, and a first cut at defining what they mean. It is divided up into sections of units all having a common domain of meaning, with the units listed alphabetically within each section. There is an index at the end which lists all units and functional names in alphabetical order, giving the section (and in the case of functional names, the unit) for each. It is not a formal definition of the concepts it contains or an explanation of what things mean or why they are that way. Other documents will serve those purposes for the various subsections The major sections are:

* The semantics of KRL

* Level 1 (entities, mappings, etc.)

* Level 2 (descriptions, anchors)

* Level 3 (description forms, units, slots, etc.)

* Building blocks for basic logical notions

* LISP objects (strings, integers, ...)

* Standard logical forms (Or, Not, ...)

* Sets and sequences

* Quantifiers

* Worlds and description spaces

* Category Hierarchies

* Events and States

* The interpreter processes

* Basic operations (Match, Seek, Describe, SendMessage)

* Standard Process Descriptions

* Interpreter data structures (hypotheses, goals, etc.)

* Triggers

* Agendas and Scheduling

* Internal structuring

* Further Specification

* Compaction

Section ??? The semantics of KRL

Section ??? Level 1 (entities, mappings, etc.)

# Entity
self: MemberOf(The entities from My system)
system: A ConceptSystem

# Belief
self: Or(An Existence, A Distinguisher, A CoReference, A Lineation,
A NonCoReference, A Mapping)
system: A ConceptSystem

# Existence↑1 1: HasFunctional (entity, ExistsIn, point)
self: MemberOf(The beliefs from My system)
system: A ConceptSystem
entity: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

# CoReference↑1
1: HasFunctional (MemberOf(entities), CoReferentWith, MemberOf(entities), point)
self: MemberOf(The beliefs from My system)
system: A ConceptSystem
entities: A Set with cardinality = 2
SubSetOf↑2(The entities from My system)
2: Comment ("We are thinking of this as a binary relation, but I have used
subset instead of having two slots, in order to make it really
symmetrical")
point: MemberOf(The points from My system)

# NonCoReference↑1
1: HasFunctional (entity1, DistinctFrom, entity2, point)
self: MemberOf(The beliefs from My system)
system: A ConceptSystem
entity1:↑2 MemberOf(The entities from My system)
2: Comment ("I gave up worrying about having it really be symmetrical")
entity2: MemberOf(The entities from My system)
Not(My entity1)
point: MemberOf(The points from My system)

# NonDistinguishment↑1 1: HasFunctional (entity, NotDistinctIn, point)
self: MemberOf(The beliefs from My system)
system: A ConceptSystem
entity: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

# Distinguishment↑1 1: HasFunctional (entity, DistinctIn, point)
self: MemberOf(The beliefs from My system)
system: A ConceptSystem with
entities = Not(HasMember
(An Entity
DistinctIn(My point)
Not(My entity)
CoReferentWith(My entity, My point))
entity: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

# Mapping
system: A ConceptSystem
point: A WorldPoint; MemberOf(The points from My system)
pairs: MapSet↑1 (My templates ,\<This element, MemberOf(My instances)>)
1: Comment ("Note that there is one pair per template, but a single instance
can appear in more than one pair")
templates: SubSetOf (The entities from My system)
instances: SubSetOf (The entities from My system)

# Implication
system: A ConceptSystem
premise: SetOf(A Belief with system = My system)
@WhichIs Prototype
conclusion: SetOf(A Belief with system = My system)
@WhichIs Prototype

Section ??? Level 2 (descriptions, anchors)

# Anchor
attachedDescriptions: SetOf(a Description with attachedAnchor = my self)
mentioningDescriptions: SetOf(a Description with attachedAnchor = Not(my self))
associatedEntity: an Entity
metaAnchor: an Anchor with associatedEntity = which Represents my self
a MetaAnchor

# Description↑1 1: HasFunctional (self, Comment, explanation)
HasFunctional(form, Describes, referent)
HasFunctional(self, IncludesBelief, MemberOf(meaning))
self: @HasBinaryFeature(PrimaryDescription)
processor: A DescriptionSystem
descriptionForm: A DescriptionForm
compiledForm: SequenceOf(A CompiledRecord)
worlds: SetOf(A WorldSpecifier)
anchor: A ???

meaning: SetOf(A Belief with system = My processor)
referent: An Entity with system = My processor

footNote: A Description with
referent = InternalEntityFor(My self)
worlds = {ModelOfSelf}
explanation: A↑2 String 2: Comment("The explanation string is an English
comment, not used by the program
but intended for human readers")

# MetaAnchor
self: an Anchor with associatedEntity =
which Represents my hookedTo
hookedTo: Or(a Description, an Anchor)

# MetaDescription
self: a Description with attachedAnchor = a MetaAnchor with
hookedTo = my hookedTo
hookedTo: Or(a Description, an Anchor)

# PrimaryDescription↑1
1: Comment ("The system assumes that there is at most one primary description
for any entity")
self: A Description; @FeatureNameFor(Description)
equivalentPointer:↑2 A DataStructure
2: Comment ("Not all descriptions have this -- only ones whose entities
correspond to units or machine objects like numbers, lisp
entities, and strings,")

# MapDescriptor↑1 1: Comment ("’ThatIs’ is treated as a ’self’ filler pair")
self: A Description with
content = SetUnion({My mapContent, My fillerContent,
My secondOrderContent})
mapContent: MapSet(The worlds from My anchor,
\An Applicability with
world = This element
mapping = My associatedMapping)
fillerContent: SetUnion(MapSet(My fillerPairs, \The content from This element)
secondOrderContent:
Using My templateUnit
\Description ->
Using My focusSlot
A Slot with SlotName = ’referent ->
Internalization(My contextEntity)
otherwise -> {}

contentEntity:↑2
An Entity
WhichIs IdentifiedIn The SelfModel from My descriptionSystem
WhichIs CoReferentWith
(Element(1, [MemberOf(The pairs from My associatedMapping)
<The associatedEntity from a Slot with
name = ’content
thatIs MemberOf(SlotsOf(\Description)),@>]),
The selfModel from my DescriptionSystem)
2: Comment ("This is filled only in the case of a mapping which is based
on the prototype for description")
templateUnit: A Unit
focusSlot: A Slot; SlotOf(My templateUnit)
selfDescriptor: The filler from a FillerPair
with slot = The selfSlot from My templateUnit
thatIs MemberOf(My fillerPairs)
fillerPairs: SetOf(A FillerPair with mapDescriptor = My self)
associatedMapping:
A Mapping with
pairs = Superset
(MapSet(My fillerPairs,
\<The templateEntity from This element,
The instanceEntity from This element>)

# FillerPair
self: An InternalKrlObject
mapDescriptor: A MapDescriptor with fillerPairs = HasElement(My self)
slot: A Slot; SlotOf(The templateUnit from My mapDescriptor)
slotDescriptor: Or(The slotName from My slot,
[A Description
Describes(The associatedEntity from My slot)])
filler: A Description with
worlds = The worlds from My mapDescriptor viewedAs a Description
content: SetUnion{The↑1 content from My filler,
MapSet(The worlds from My mapDescriptor
viewedAs a Description,
\An Existence with
world = This element
entity = My instanceEntity
1: Comment ("The content is recursive")
templateEntity: The associatedEntity from My slot
instanceEntity: The referent from My filler

Section ??? Level 3 (description forms, units, slots, etc.)

# Unit↑1 1: HasFunctional (slots, SlotsOf, self)
HasFunctional (MemberOf(slots), SlotOf, self)
self: An InternalKrlObject
unitName: A LispAtom
slots:SetOf(A Slot with baseUnit = My self)
The base from a OneOneMap with
mapDescription = \The slotName from This element
viewedAs a slot
selfSlot: A Slot with slotName = ’self
associatedEntity = My associatedEntity
MemberOf(My slots)
associatedEntity: The associatedEntity from My selfSlot
worlds: SetOf(A World)
existenceContent:
SetUnion(MapSet(My slots, \The existenceContent from This element))

# Slot↑1 1: Comment ("?")
self: An InternalKrlObject
SlotOf(My baseUnit)
baseUnit: A Unit
slotName: A LispAtom
slotDescription:
A Description with worlds = My worlds
Which Describes (My associatedEntity)
PrimaryDescriptionFor↑2(My associatedEntity)
associatedEntity: The referent from My slotDescription
worlds: SetOf(A World)
The↑2 worlds from My baseUnit2: A Default
existenceContent:
MapSet(My worlds,
\An Existence with world = This element
entity = My associatedEntity)

# DescriptionForm
self: An InternalKrlObject
type: A DescriptorType
anchor: A Description with form = My self
realization: A DataStructure

# PerspectiveForm↑1
1: Comment ("This is the form (having the ’with’ clauses, equal signs, etc.)
which is common to all of the different perspective forms")
self: A DescriptionForm with
anchor = A MapDescription with↑2
2: Comment ("I’m not filling in the slots having to do with the internal data
structure realization, or the details of the syntactic form")
templateUnit:
withClauses:

# SlotPerspective↑1 1: FurtherSpecified (PerspectiveForm)
self: A PerspectiveForm with
anchor = A MapDescription with
focusSlot = @↑2
2: Comment ("I’m not filling in the slots having to do with the internal data
structure realization, or the details of the syntactic form")
templateUnit:
focusSlot:

# PureSlotPerspective↑1 1: FurtherSpecified (SlotPerspective)
self: A SlotPerspective with
fillerPairs = {A FillerPair with
slot = The selfSlot from My templateUnit}

# UnitPerspective↑1 1: FurtherSpecified (PerspectiveForm)
self: A PerspectiveForm with
anchor = A MapDescription with
focusSlot = The selfSlot from My templateUnit

# Functional↑1
1: FurtherSpecified (PerspectiveForm)
Comment ("Since a functional is only a further specified map descriptor, it is
possible to write code using the same fields as for the explicit
perspectives. In this, as with the other units here, I have not yet
put in the additional stuff which corresponds to the syntax (e.g.
everything is listed as sets, not sequences.")
self: A PerspectiveForm
functionalName: A FunctionalName with definingUnit = My templateUnit
argumentList: SequenceOf(A DescriptionForm)

# # # # # # # # # # # # # # #

# CoReferenceDescriptor↑1 1: Comment ("Includes both linkages and pointers")
self: A Description with
content = SetUnion({My existenceContent, My coReferenceContent})
entity: An Entity
existenceContent:
MapSet(The worlds from My self,
\An Existence with
world = This element
entity = My entity)
coReferenceContent:
MapSet(The worlds from My self,
\A CoReference with
world = This element
entities = {My referent, My entity})

# LinkageForm↑1 1: Comment ("Unit linkages are considered linkages to the self slot")
self: A DescriptionForm with
anchor = A CoReferenceDescriptor with
entity = The associatedEntity from My slot
unit: A Unit
slot: A Slot; SlotOf(My unit)

# ReflexiveForm↑1 1: Comment ("This needs working out. I think we have agreed
that it is semantically equivalent to a
corresponding direct linkage with the unit
name filled in")
self: A DescriptionForm with
anchor = A CoReferenceDescriptor
definingUnit: A Unit
definingCluster: A Unit
slotName: A LispAtom

# PointerForm↑1 1: Comment ("These are indicated in the syntax with a prefix or
bracketing character")
self: A DescriptionForm with
anchor = A CoReferenceDescriptor with
entity = EntityForSymbolicObject(My object)
object: A SymbolicObject

# SymbolicObject↑1 1: HasFunctional(entity, EntityForSymbolicObject, self)
Comment ("These don’t really involve any kind of internal
self reference. They are just a shortcut to
avoid creating entities for things which exist
in the world of symbols, and are described
totally by their realization in data
structures. ")
self: Or(A Number, A String, A LispAtom, A LispExpression)
associatedEntity: An Entity

# InternalKrlObject↑1 1: HasFunctional(entity, EntityForKrlObject, self)
Comment ("This does involve explicit self-reference. ")
self: Or(A Unit, a Slot, a DescriptionForm)
descriptionSystem: A KrlSystem
associatedEntity: An Entity
Which ExistsIn The selfModel from My descriptionSystem

# QuotedDescriptionForm↑1
1: Comment ("Quoted descriptionForms are unanchored")
self: A DescriptionForm with
anchor = A CoReferenceDescriptor with
entity = EntityForKrlObject(My object)
object: A DescriptionForm

# QuotedUnitForm↑1
1: Comment ("We don’t need a form for quoted slots, since it is possible to
get the quoted unit, then pick out whatever pieces of the
structure are wanted")
self: A DescriptionForm with
anchor = A CoReferenceDescriptor with
entity = EntityForKrlObject(My unit)
unit: A Unit

# # # # # # # # # # # # # # #

# Selector↑1 1: Comment ("This needs filling in -- brian had it
covering booleans, cases, using, etc.")
self: A Description

# IndirectForm↑1
1: Comment ("Note that there is no description of type indirect -- only a form.")
self: A DescriptionForm

# ImplicitAndDescriptor↑1 1: FurtherSpecified (Description)
self: A Description with
content = SetUnion(MapSet(My components,
\The content from This element))
components: SetOf(A Description with
worlds = My worlds
referent = The referent from My self)

Section ??? Building blocks for basic logical notions

Section ??? LISP objects (strings, integers, ...)

Section ??? Standard logical forms (Or, Not, ...)

Section ??? Sets and sequences

see old hardcopy of basicunits.krl1

Section ??? Quantifiers

Section ??? Worlds and description spaces

# ConceptSystem
entities: SetOf(An Entity with system = My self)
points: SetOf(A WorldPoint with system = My self)
lines: SetOf(A Line with system = My self)
operations: SetOf (An Operation with system = My self)
beliefs: SetOf(A Belief with system = My self)

# WorldPoint
self: MemberOf(The points from My system)
system: A ConceptSystem

# WorldLine
self: MemberOf(The lines from My system)
system: A ConceptSystem

# WorldSpecifier
self: A UnitPointer with unit = my unit
unit: A Unit with selfDescription = HasMember(My description)
description: Or(A UnitPerspective with prototype = SimpleWorld,
A UnitPerspective with prototype = ChangingWorld,
A Functional with
functionalName = ’PointInWorld
arguments = {A UnitLinkage with
unit = A WorldSpecifier
@UnitFor(A ChangingWorld),
A Functional with
functionalName = ’CurrentPointInWorld
arguments = {A UnitLinkage with
unit = A WorldSpecifier
@UnitFor(A ChangingWorld)

# Operation
self: MemberOf(The operations from My system)
system: A ConceptSystem

# Change
system: A ConceptSystem
oldPoint: MemberOf(The points from My system)
newPoint: MemberOf(The points from My system)
changeEvent: MemberOf(The entities from My system)

# Processor
operations: SetOf(An Operation with processor = My self)
states: SequenceOf(A State with processor = My self)
events: SequenceOf(An Event with affected = My self)

# DescriptionSystem↑11: FurtherSpecified(Processor)
states: SequenceOf(A DescriptionState with processor = My self)

# State
processor: A DescriptionSystem
starter: MemberOf(The events from My processor)
ender: MemberOf(The events from My processor)

# DescriptionState↑11: FurtherSpecified(State)
descriptions: SetOf (A Description with processor = My self)
longTermDescriptions: SubSetOf(My descriptions)
activeDescriptions:↑2 SubSetOf(My descriptions)
2: Comment ("The active descriptions and long term descriptions are not
necessarily disjoint sets. Active descriptions are those which
will be considered in making inferences at any given time, and
are usually represetned by special data structures in the
interpreter. Long term descriptions are those which are attached
as parts of units")

# TranslateDescription↑1
1: HasFunctional (otherDescription, Translation, myDescription, otherSystem)
Comment ("This is not symmetrical -- there is a description system (explicit)
on one side, and the system in which the translation mapping
appears (implicit) on the other. It is this second system which
believes it to be a translation")
myDescription: A Description
otherSystem: A DescriptionSystem
otherDescription: A Description with descriptionSystem = My otherSystem

# ContingentDescription↑1
1:HasFunctional(referent, During, world, Quoted(form))
self:A Description with
referent = My referent
worlds = {My world}
form = My form
referent: An Entity
world: A World
form: A DescriptionForm

# ChangingWorld↑1 1: FurtherSpecified(World)
self: A World
time: SetOf(An Event; ExistsIn(My self))
states: SetOf(A WorldState with universe = My self)

# WorldState
self: A World
universe: A World
startEvent: An Event
MemberOf(The time from My universe)
endEvent: An Event
MemberOf(The time from My universe)

# Processor2↑1 1: FurtherSpecified(ConceptSystem)
HasFunctional (reality, WorldModel, self)
self: A ConceptSystem with
operations = {CreateNewEntity, CreateNewMapping, AddBelief,
RemoveBelief, TestBelief, ???}
realization: A PhysicalSymbolSystem
selfImage: MemberOf (My entities)
ExistsIn (My reality)
selfModel: MemberOf (My worlds)
reality: MemberOf (My worlds)
worldNow: MemberOf(My worlds)
A WorldState with universe = My reality
entityEntities: SubsetOf(My entities)
beliefEntities: SubsetOf(My entities)
mappingEntities: SubsetOf(My entities)

Section ??? Category Hierarchies

# CategoryDimension↑1
1: Comment ("A category dimension is associated with an entire hierarchy. It
operates somwhat like a viewpoint in selecting out relevant
categories to check for conflicts. Two categoies along different
dimensions are incommensurable. Hierarchies can branch off into
dimensions at any level (e.g. there can be a single hierarchy of
things down to Person, including PhysObj, etc. then multiple
categories below Person. The intention is that although the
semantics as defined here are sufficent for doing category
reasoning, there would be special triggers associated with these
units, which led the information to be included redundantly in a
much more computationaly efficient form, to be used by the
matcher in quick checks to see if a match can be rejected on the
basis of category incompatibility")
root: A Category with dimension = My self
leaves: SetOf (\A Category with dimension = My self)

# Category↑11:HasFunctional (self, Categorized, dimension, children)
HasFunctional (self, SubCategory, dimension, parent)
HasFunctional (self, CategoryFor, instances)
dimension: A CategoryDimension; Basic↑22: A Default
parent: A Category with dimension = My dimension
siblings: The rangeSet from a SetSelector with
base = The children from a Category thatIs My parent
selector = \Not(My Element)
children: SetOf(\A Category with dimension = My dimension)
instances:
SetOfAll(\WhichIs DescribedBy
A Mapping with template = My self)
SetOf(\Not(WhichIs DescribedBy
A Mapping with template = MemberOf(My siblings))
UsingMy self
Not(The root from a CategoryDimension thatIs My dimension)
~ SetOf(\WhichIs DescribedBy
A Mapping with template = My parent)
UsingMy self
Not(MemberOf (The leaves from a CategoryDimension
thatIs My dimension))
~ SetOf(\WhichIs DescribedBy
A Mapping with template = MemberOf(My children))

# Basic
self/Instance: A CategoryDimension
1: Comment ("This is a used for a default division of the entire world.")

Section ??? Events and States

Section ??? The interpreter processes

Section ??? Basic operations (Match, Seek, Describe, SendMessage)

# Seek
self: A Program with
inputs = {My initialDescription, My specifier}
outputs =
{Using My specifier
’Primary => My primaryDescription
’Pointer => My pointer
’Identity => My primaryDescription}
result =
Using My specifier
’Primary =>
Using My derivedDescriptions
HasMember(A PrimaryDescription) => ’Succeed
Otherwise => ’Fail
’Identity =>
Using My derivedDescriptions
HasMember(A PrimaryDescription
An IdentityDescription) => ’Succeed
Otherwise => ’Fail
’Pointer =>
Using My derivedDescriptions
HasMember(A PrimaryDescription
A PointerEquivalentDesc) => ’Succeed
Otherwise => ’Fail
specifier: Or(’Primary, ’Pointer, ’Identity)
initialDescription: A Description
derivedDescriptions:
SetOf(A Description with
referent = The referent from My initialDescription)
HasMember(My initialDescription)
primaryDescription:
A PrimaryDescription
MemberOf(My derivedDescriptions)
pointer: A DataStructure
The EquivalentPointer from My primaryDescription

# Describe
self: A Program with
inputs = {My initialDescription, My newDescription,
My worlds, My mode}
outputs = {The resultingDescription from My changePrimary}
result =
Using The result from My findPrimary
’Fail => ’Fail
’Succeed => The result from My CheckConsistency

mode: Or(’Describe, ’ReDescribe, ’Augment)
initialDescription: A Description
newDescription: A Description
worlds: SetOf(A WorldDescriptor)
primaryDescription:
A PrimaryDescription
A Description with referent = The referent from My initialDescription
A LongTermDescription
findPrimary:
A Seek with
initialDescription = My initialDescription
specifier = ’Primary
primaryDescription = My primaryDescription
checkConsistency:
A↑1 MatchDescription with
pattern = My newDescription
datum = My primaryDescription
mode = ’Possible
1: Comment("We need some way to specify effort -- in this case, only the
simplest forms of conflict are looked for. We need to decide
whether this should include categories")
changePrimary:
Using My mode
’Describe =>
A ChangeLongTermDescription with
description = My primaryDescription
newDescription = My newDescription
’ReDescribe =>
A ReplaceLongTermDescription with
description = My primaryDescription
newDescription = My newDescription
’Augment =>
An AugmentSetDescription with
set = My primaryDescription
newElementDesc = My newDescription

# Match
mode: Or(’Known, ’Possible)
patternType:↑1 Or (’Description, ’Referent)
1: Comment ("If the patternType is ’Referent, then it is assumed that the
pattern description has a referent, which is found (using
Seek) and checked to see if it is the same as the referent of
the datum. If the patternType is ’Description, then it is
assumed that the pattern is to be tested as a possible
description of the referent of the datum. In both cases, the
datum is assumed to have a referent. In those cases where
the datum represents an arbitrary entity fitting its
description, the input datum should be (explicitly) a
PrimaryDescription.")
pattern: A Description
datum: A Description

# MatchReferent↑1 1: FurtherSpecified(Match)
Comment ("Assumes there are referents for both
descriptions, and checks to see if they
are the same")
self: A Program with
result =
Using The content from My derivedDescriptions
HasMember
(A CoReference with
entities = {The referent from My datum,
The referent from My pattern}) => ’Match
HasMember
(A NonCoReference with
entities = {The referent from My datum,
The referent from My pattern}) => ’NoMatch
Otherwise =>
Using My mode
’Known => ’Unknown
’Possible => ’Match
patternType: ’Referent
patternPrimary: The primaryDescription from My findPatPrim
datumPrimary: The primaryDescription from My findDatPrim
findPatPrim: A Seek with
specifier = ’Primary
initialDescription = My pattern
findDatPrim: A Seek with
specifier = ’Primary
initialDescription = My datum
derivedDescriptions:
SetOf(A Description)
DerivationFrom(The longTermDescriptions from
a DescriptionState thatIs
The initialState from My self
viewedAs an Operation}))

# MatchDescription↑1
1: FurtherSpecified(Match)
Comment ("Assumes that there is a referent for the datum, and checks to see
if the pattern is a description of it. If the mode is ’Known,
then the pattern description must be derivable from other
available description. If it is ’Possible, then only lack of
incompatibility must be shown. If mode is ’DescDesc, then
it makes up a referent with no other properties")
self: A Program with
result =
Using The content from My hypotheticallyDerivedDescriptions
WhichIs Inconsistent => ’NoMatch
otherwise =>
Using My mode
’Known =>
Using The content from My derivedDescriptions
SupersetOf(My hypothesizedContent) => ’Match
otherwise => ’Unknown
’Possible => ’Match
patternType: ’Description
datumPrimary: The primaryDescription from My findDatPrim
findDatPrim: A Seek with
specifier = ’Primary
initialDescription = My datum
hypothesizedContent:
Substitution(The meaning from My pattern,
<The referent from My datum,
The referent from My patttern>)
hypothesizedDescription:
A DescriptionSet with content = My hypothesizedContent
derivedDescriptions:
SetOf(A Description)
DerivationFrom(The longTermDescriptions from
a DescriptionState thatIs
The initialState from My self
viewedAs an Operation}))
hypotheticallyDerivedDescriptions:
SetOf(A Description)
DerivationFrom(SetUnion({My hypothesizedDescription,
The longTermDescriptions from
a DescriptionState thatIs
The initialState from My self
viewedAs an Operation}))

Section ??? Standard Process Descriptions

Section ??? Interpreter data structures (hypotheses, goals, etc.)

Section ??? Triggers and traps

# AnchorCreation
self: a SystemEvent
anchor: an Anchor

# AnchorCreationTrigger
self: a Trigger with
eventType = an AnchorCreation with
anchor = my createdAnchor
procedure = my procedure
cataloguingAnchor = my cataloguingAnchor
process = my process
cataloguingAnchor: an Anchor
createdAnchor: an Anchor
procedure: a LISPExpression

# CurrentSystemEvent
self: a SystemEvent with
type = a DescriptionAttachment with
anchor = SelfSlot(’Fido)
descriptionForm = \a Dog with kind = Beagle
process = ... some appropriate process description ...

# DescriptionAttachment
self: a SystemEvent
anchor: an Anchor
descriptionForm: a DescriptionForm

# DescriptionAttachmentTrigger
self: a Trigger with
systemEvent = a DescriptionAttachment with
descriptionForm = my attachedDescriptionForm
anchor = my attachedAnchor
procedure = my procedure
cataloguingAnchor = my cataloguingAnchor
process = my process
cataloguingAnchor: an Anchor
attachedAnchor: an Anchor
attachedDescriptionForm: a DescriptionForm
process: a Process
procedure: a LISPExpression

# SystemEvent
type: Or(a DescriptionAttachment, an AnchorCreation)
process: a Process

# Trigger
systemEvent: a SystemEvent with
type = my eventType
process = my process
eventType: Or(a DescriptionAttachment, an AnchorCreation)
process: a Process
procedure: a LISPExpression
cataloguingAnchor: an Anchor

#WhenDescribedTrigger↑1
1: HasFunctional(cataloguingAnchor, WhenDescribed, procedure)
self: a DescriptionAttachmentTrigger with
cataloguingAnchor = my cataloguingAnchor
procedure = my procedure
attachedAnchor = my cataloguingAnchor
cataloguingAnchor: an Anchor
procedure: a LISPExpression

# WhenGroundedTrigger↑1
1: HasFunctional(cataloguingAnchor, WhenGrounded, procedure)
self: : a Trigger with
systemEvent =
Or(a DescriptionAttachment with
descriptionForm =
a CoReferenceDescriptionForm
which Mentions
Or(a PrimaryAnchor,
a CoreferentWithPrimaryAnchor)
anchor = my cataloguingAnchor,
a DescriptionAttachment with
descriptionForm = \whichIs Primary
anchor = a metaAnchor with
hookedTo = my cataloguingAnchor
procedure = my procedure
cataloguingAnchor = my cataloguingAnchor
cataloguingAnchor: an Anchor
procedure: a LISPExpression

#WhenIdentifiedTrigger↑1
1: HasFunctional(cataloguingAnchor, WhenIdentified, procedure)
self: a DescriptionTrigger with
cataloguingAnchor = my cataloguingAnchor
procedure = my procedure
attachedAnchor = my attachedAnchor
attachedDescription =
a Mapping with
mappingPairs = SetIncluding(
a MappingPair with
instanceAnchor = my attachedAnchor
templateAnchor = my cataloguingAnchor)
attachedAnchor: Or(a PrimaryAnchor,
a CoreferentWithPrimaryAnchor)
cataloguingAnchor: an Anchor
procedure: a LISPExpression

#WhenMappedTrigger↑1
1: HasFunctional(cataloguingAnchor, WhenMapped, procedure)
self: a DescriptionTrigger with
cataloguingAnchor = my cataloguingAnchor
procedure = my procedure
attachedAnchor = my attachedAnchor
attachedDescription =
a Mapping with
mappingPairs = SetIncluding(
a MappingPair with
instanceAnchor = my attachedAnchor
templateAnchor = my cataloguingAnchor)
attachedAnchor: an Anchor
cataloguingAnchor: an Anchor
procedure: a LISPExpression

# WhenReferredToTrigger↑1
1: HasFunctional(cataloguingAnchor,WhenReferredTo, procedure)
self: a DescriptionTrigger with
cataloguingAnchor = my cataloguingAnchor
procedure = my procedure
attachedAnchor = an Anchor
attachedDescription =
a CoReferenceDescription with
mentionedAnchor = my cataloguingAnchor
cataloguingAnchor: an Anchor
procedure: a LISPExpression

Section ??? Agendas and Scheduling

Section ??? Internal structuring

Section ??? Further Specification

Section ??? Compaction

.

Units having to do with something

# Description↑1 1: HasFunctional (self, Comment, explanation)
self: A Thing
anchor: A Description with baseSpace = My baseSpace
referent: The entity from a Describing with
space = My baseSpace
description = My anchor
explanation: A↑2 String 2: Comment("The explanation string is an English
comment, not used by the program
but intended for human readers")