Page Numbers: Yes First Page: 1
Heading:

April 28, 1979 2:34 PM[IVY]<KRL>document>str-lev-belief

Belief level

Units having to do with descriptions and entities

# DescriptionSpace↑1 1: HasFunctional (MemberOf(entities), EntityOf, self)
entities: SetOf(An Entity with baseSpace = My self)
describings: SetOf(A Describing with space = My self)

# Description↑1 1: HasFunctional (self, Comment, explanation)
baseSpace: A DescriptionSpace
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")

# Entity
baseSpace: A DescriptionSpace

# Describing↑1 1: HasFunctional (description, Describes, entity)
HasFunctional (entity, DescribedAs, description)
HasFunctional (space, InWhich, entity, description)
self: MemberOf(The describings from
a DescriptionSpace thatIs My space)
entity: An Entity
WhichIs EntityOf My space
WhichIs DescribedBy My description
with space = My space
description: A Description with baseSpace = My space
Which Describes My Entity
with space = My space
space: A DescriptionSpace

# *M*
self/Instance: A↑1 DescriptionSpace
1: Comment ("This is the space in which the program itself is
running. Descriptors which use it represent explicit
self-knowledge")

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

# DescriptionCorrespondence↑1
1: HasFunctional (description2, Translation, description1, space2)
space1: A DescriptionSpace; *M*↑22: A Default
space2: A DescriptionSpace
description1: A Description with baseSpace = My space1
description2: A Description with baseSpace = My space2

# EntityCorrespondence↑1 1: HasFunctional (entity2, ConceptFor, entity1, space2)
space1: A DescriptionSpace; *M*↑22: A Default
space2: A DescriptionSpace
entity1: An Entity; EntityOf(My space1)
entity2: An Entity; EntityOf(My space2)

# Implication↑1
1: HasFunctional (entity, Implies, Quoted(priorDescription),
Quoted(derivedDescription))
Comment ("This unit is described by using itself, a state of affairs which
means it can’t be interpreted, but is built in. It also follows the
pattern of the booleans, ’Or’, ’Not’ , in assuming a description
quote of its arguments.")
priorDescription: A Description with baseSpace = My space
derivedDescription: A Description with baseSpace = My space
space: A DescriptionSpace
entity: An Entity
EntityOf(My space)
Implies(DescribedBy(My priorDescription),
DescribedBy(My derivedDescription))

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

# Unit↑1 1: Comment ("more to be filled in later")
associatedPrototypeEntity: An Entity with baseSpace = *M*
associatedConceptEntity: An Entity with baseSpace = *M*

# Slot↑1 1: Comment ("more to be filled in later")
unit: A Unit
slotName: A String
associatedPrototypeEntity: An Entity with baseSpace = *M*
associatedConceptEntity: An Entity with baseSpace = *M*

# Functional↑1 1: Comment ("There is some special syntax for defining functionals,
using the pseudo-functional HasFunctional")
name: A String
definingUnit: A Unit

# String↑1 1: Comment ("Defined in the system")

# Integer↑1 1: Comment ("Defined in the system")

# Default↑1 1: Comment ("the definition of units like this will not be used by the
KRL mechanisms. It will have built-in code for
recognizing and doing the right things with them. It
is listed here for the sake of completeness")
self: A Description

# UniqueEntityCoreference↑1
1: Comment ("Used in specifying what kind of descriptor is neeeded as the result of a
seek. It represents a unit or slot coreference where the unit or slot is not
labelled as not referring to a unique entity. -- more to be filled in later")
self: A Description
associatedEntity: The referent from a Description thatIs My self

# ExplicitSequenceOfCoreferences↑1
1: Comment ("Used in specifying what kind of descriptor is neeeded as the result of a
seek. It represents a sequence, each element of which is an explicit
coreference. -- more to be filled in later")
self: A Description
A SequenceDescriptor with
elements = SequenceOf(\A UniqueEntityCoreference)
associatedEntitySequence:
The rangeSet from a SequenceMap with
base = the elements from a SequenceDescriptor thatIs My self
mapDescription = \[An Entity; DescribedBy(This element)]

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

# RealWorld↑1
self/Instance: The worldModel from a Processor thatIs *ME*
1:A TimeDependentSlot
Comment ("Those things I believe are true of the real world as it exists at time
*NOW*")

# LogicalWorld↑1
self/Instance: A DescriptionSpace
1:A TimeDependentSlot
Comment ("Those things I believe are true not only of the real world as it exists at
time *NOW*, but of all logically possible worlds as well")

# WorldExtension↑11: HasFunctional (self, ExtensionOf, base)
self: A DescriptionSpace with
entities = Superset(The entities from
a DescriptionSpace thatIs My base)
describings = Superset(The describings from
a DescriptionSpace thatIs My base)
base: A DescriptionSpace

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

Units having to do with fundamental semantic notions

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

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

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

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

# Operation
self: MemberOf(The operations 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)

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

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

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

# Inconsistency
system: A ConceptSystem
beliefs: SubSetOf(The beliefs from My system)

Note: -- we need non-Exist, or Non-Map, or maybe both????

# CoReferenceInconsistency
self: An Inconsistency with
system = My system
beliefs = {My coReference, My nonCoReference}
system: A ConceptSystem
coReference: A CoReference with
entities = {My entity1, My entity2}
point = My point
NonCoReference: A NonCoReference with
entity1 = My entity1
entity2 = My entity2
point = My point
entity1: MemberOf(The entities from My system)
entity2: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

# DistinghishmentInconsistency1
self: An Inconsistency with
system = My system
beliefs = {My distinguishment, My nonDistinguishment}
system: A ConceptSystem
distinguishment: A Distinguishment with
entity = My entity
point = My point
NonDistinguishment: A NonDistinguishment with
entity = My entity
point = My point
entity: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

# DistinghishmentInconsistency2
self: An Inconsistency with
system = My system
beliefs = {My distinguishment1,
My distinguishment2,
My coReference}
system: A ConceptSystem
distinguishment1: A Distinguishment with
entity = My entity1
point = My point
distinguishment2: A Distinguishment with
entity = My entity2
point = My point
coReference: A CoReference with
entities = {My entity1, My entity2}
point = My point
entity1: MemberOf(The entities from My system)
Not(My entity2)
entity2: MemberOf(The entities from My system)
point: MemberOf(The points from My system)

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

# CategoryInconsistency
self: An Inconsistency with
system = My system
beliefs = {My map1,
My map2,
My coReference}
system: A ConceptSystem
map1: MemberOf(The beliefs from My system)
A Mapping with
pairs = HasMember(<My prototype1, My entity>)
point = My point
map2: MemberOf(The beliefs from My system)
A Mapping with
pairs = HasMember(<My prototype2, My entity>)
point = My point
prototype1: MemberOf(The entities from My system)
Not(My prototype2)
prototype2: MemberOf(The entities from My system)
map3: MemberOf(The beliefs from My system)
A Mapping with
pairs = {<CategorySet, My set>}
point = ???
set: MemberOf(The points from My system)
membership1:
MemberOf(The beliefs from My system)
A Mapping with
pairs = {<Set, My set>
<Member, ConceptFor(My prototype1)}
membership2:
MemberOf(The beliefs from My system)
A Mapping with
pairs = {<Set, My set>
<Member, ConceptFor(My prototype2)}
point: MemberOf(The points from My system)