Page Numbers: Yes First Page: 1
Heading:

April 26, 1979 7:04 PM[IVY]<krl>document>str-syntax-old

Part 3. Examples

# Bring

self: A Happening
An Act with actor = My bringer

A Go with
goer = My bringer
destination = My destination
source = My source

A Go with
goer = My brought
destination = My destination
source = My source

bringer: A Person

brought: A PhysicalObject

source: A Place

destination: A Place

# FoodArrives↑11: WhichIs InCluster RestaurantScript

self: A Bring with
bringer = WhichIs Our server
brought = WhichIs Our meal
source = The kitchen from a Restaurant thatIs WhichIs Our restaurant
destination = WhichIs PlaceOf WhichIs Our table

# Enactment

self: Category(Basic, Thing)

script: A Script

eventSequence: SequenceOf(A StoryEvent)
knownEvents:↑1 SequenceOf(A StoryEvent)
InitialSubsequenceOf(My eventSequence)

1: A MonotonicallyChangingSequence with direction = Increase

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

# Family↑11: HasFunctional(woman, MotherOf, MemberOf offspring)
HasFunctional(man, FatherOf, MemberOf offspring)
HasFunctional(man, HusbandOf, woman)
HasFunctional(woman, WifeOf, man)
HasFunctional(MemberOf parents, ParentOf, MemberOf offspring)
HasFunctional(MemberOf offspring, ChildOf, MemberOf parents)
HasFunctional(parents, HaveFamily, Sequence offspring)
woman: An Adult; A Female
man: An Adult; A Male
parents: {My woman, My man}
offspring: SetUnion(My femaleChildren, My maleChildren)
maleChildren: SetOf(A Child; A Male)
femaleChildren: SetOf(A Child; A Female)

# Family1↑11: Comment ("This and the following unit give semantically equivalent information")
self: A Family with
parents = {John, Sue}
offspring = {Susie, Sally, Joe}

# Family1↑11: Comment ("This and the preceding unit give semantically equivalent information")
self: A Family with
parents = {John, Sue}
Which HaveFamily(Susie, Sally, Joe)

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

# NoBlanks↑11: RelatedTo (Column)
WhenIdentified (’(TryStrategy))

self:A Column with
topLetter = Not(Blank)
bottomLetter = Not(Blank)
A Summation with
summands = {My carryIn,
The value from My topLetter,
The value from My bottomLetter}

# Problem↑11:WhenIdentified (’(SETQ currentProblem (GetVal instance)))
WhenAllKnown ({topWord, bottomWord, sumWord},
’(SetUpProblem))

topWord: A String

bottomWord: A String

sumWord: A String

columns: SequenceOf(A Column)

freeDigits:↑2 SetOf(An Integer)

2: A DecreasingSet with initialValue = IntegerInterval(0, 9)

lettersAppearing: SetOf(A Letter); A Set with cardinality = 10

freeLetters:↑3
SetOf(A Letter)
SubsetOf(My lettersAppearing)

3: An EliminationSet with
initialValue = My lettersAppearing
filter = \Not(CanGetIt (\The value from ThisElement
viewedAs a Letter))

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

# CoReference↑1
1: HasFunctional (MemberOf entities, CoReferentWith, MemberOf entities, point)
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↑11: HasFunctional (entity1, DistinctFrom, entity2, point)
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)

########
# 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 = [↑1]1: Comment ("I haven’t figured this out yet")
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)
#########

# DoOperation
self: An Event with affected = My actor
actor: A Processor
type: MemberOf(The operations from My actor)
externalActs: SetOf(An ExternalAct with actor = My processor)

# DataModification
oldForms: SubsetOf(The structures from
a DescriptionState thatIs
the initialState from My self
viewedAs an Operation)
SetOf(Not(MemberOf(The structures from
a DescriptionState thatIs
the resultingState from My self
viewedAs an Operation)))
newVersion: SubsetOf(The structures from
a DescriptionState thatIs
the resultingState from My self
viewedAs an Operation)

# MatchReferent↑1 1: 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
[] ->
Using My mode selectFrom
’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)