Page Numbers: Yes First Page: 1
Heading:

April 28, 1979 2:00 PM[IVY]<KRL>document>str-formal-terry

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

# 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")

# Event↑11: Comment("Should this be treated more generally -- i.e. not having
a single affected which is a processor?")
affected: A Processor
previousState: MemberOf(The states from My affected)
resultingState: MemberOf(The states from My affected)
SuccessorOf(My previousState, The states from My affected)

# DoOperation
self: An Event with affected = My actor
@?WhatIsThis??
(A Mapping with
pairs = {<The action from My type, My self>,
<The previousState from My type, My previousState>,
<The resultingState from My type, My resultingState>,
<The externalActs from My type, My externalActs>})
actor: A Processor
type: MemberOf(The operations from My actor)
externalActs: SetOf(An ExternalAct with actor = My processor)

# Operation
processor: A Processor
previousState: A State with processor = My processor
@WhichIs Prototype
resultingState: A State with processor = My processor
@WhichIs Prototype
externalActs: SetOf(An ExternalAct with actor = My processor)
@WhichIs Prototype
EmptySet↑11: A Default

# Program
processor: A Processor
inputs: SetOf(A Form; @WhichIs Prototype)
outputs: SetOf(A Form; @WhichIs Prototype)

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

# DescriptionSet
self: SetOf(A Description with processor = My processor)
processor: A DescriptionSystem
system: A ConceptSystem
content: SetUnion(MapSet(My self, \The meaning from This element))

# 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")

# 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,")

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

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

# CoReferenceTransitivity
self: An Inference with
premises = {My coRef1, My coRef2}
conclusions = {My coRef3}
point: A WorldPoint
entity1: An Entity; Not(My entity2)
entity2: An Entity; Not(My entity3)
entity3: An Entity; Not(My entity1)
coRef1: A Coreference with entities = {My entity1, My entity2}
point = My point
coRef2: A Coreference with entities = {My entity2, My entity3}
point = My point
coRef3: A Coreference with entities = {My entity1, My entity3}
point = My point

# MutualExclusion
self: An Inference with
premises = {My dist1, My dist2}
conclusions = {My nonCoRef}
entity1: An Entity; Not(My entity2)
entity2: An Entity; Not(My entity1)
dist1: A Distinguishment with entity = My entity1
point = My point
dist2: A Distinguishment with entity = My entity2
point = My point
nonCoRef: A NonCoReference with entities = {My entity1, My entity3}

# MapInheritance
self: An Inference with
premises = {My map1, My map2}
conclusions = {My map3}
templateEntity: An Entity
instanceEntity: An Entity
map1: A Mapping with
pairs = HasMember(<My templateEntity, My instanceEntity>)
map2: ????A Mapping with
pairs = HasMember(<My templateEntity, My instanceEntity>)
map3: ????A Mapping with
pairs = HasMember(<My templateEntity, My instanceEntity>)

# ApplyImplication
self: An Inference with
premises = {My implication,
@DescribedBy(The premises from My implication)}
conclusions = {@DescribedBy(The conclusions from
My implication)}}
implication: An Implication

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

# ExamineUnit
self: A DescriptionActivation with
oldDesc = {My oldDesc}
newDesc = My newDesc
oldDesc: A UnitLinkage
newDesc: The selfDescription from a Unit thatIs The unit from My oldDesc

# InterpretForm
self: An OperationSequence with
sequence = <My interpretCompiledPart,
My interpretDescriptionForm>
description: A Description
interpretCompiledPart:
MapSet (The compiledForm from My description,
\An InterpretCompiledPerspective with
record = This Element
referent = The referent from My description
worlds = The worlds from My description)
interpretDescriptionForm:
newDesc: The selfDescription from a Unit thatIs The unit from My oldDesc

# InterpretCompiledPerspective
self:
record: A CompiledRecord
referent: A ReferentDescription
worlds: A WorldDescription

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

# DescriptionAdded
self: A SystemEvent
oldDescription: A Description
newDescription: A Description

# DescriptionFilled
self: A SystemEvent
oldDescription: A Description
newDescription: A Description

# DescriptionAddedToFiller
self: A SystemEvent
context: A Description
newDescription: A Description
unit: A Unit
slot: A slot; SlotOf(My unit)

# FillerKnown
self: A SystemEvent
context: A Description
newDescription: A Description
unit: A Unit
slot: A slot; SlotOf(My unit)

# PrototypeKnown
self: A SystemEvent
context: A Description
instance: A Description
unit: A Unit

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

Units for the basic data structures

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

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

Units for the descriptors

# 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

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

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

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

Units having to do with multiple description systems and communication

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