(you may click
the number of the subfile to be viewed, or
scroll down)
This
file contains the following subfiles:
17
- disassembly of objects
18 - Syllables, words, and phrases: levels
of information
19 - various types of interrelations among
axes
19.8 - recognizing phrase types
(subfile17: decomposition – the inverse
of concatenation)
At a shallow level, this decomposition is a trivial matter, since
1) primitive words’ definitions consist of completely discreet units –
namely, an axis number and a value, and 2) compound words' definitions
consist of groups of primitives. It is of use, however, to be
able to take any subset of a primitive word’s definition (or of a path,
transform, etc.) and find out quickly if that subset comprises a word
in the dictionary or in any recognized concept. This capability is a
natural result of the associative, content-addressable memory that is
utilized by the algorithm. (This technique of memory management, which
is the “PUSS” part of Andreae's “PURR-PUSS” program, is clarified
(p.27) in the description of the historical progression of experiments
that preceded this project.)
To record that a subset does in fact occur repeatedly, the only thing
required is to store an 'on' bit at the MS location of the subset, or
perhaps a value, representing the number of times that bit has been
'turned on'. Such storage could easily take place simultaneously with
other functions or could operate as an unconscious process (one that
happens while nobody is interacting with the program – see “crawlers”,
main file, p.36). It may prove more useful to store a list of objects
in which the subset occurs, directly at locations calculated from the
subset - such storage is also a common PURR-PUSS function. The
interaction of a large number of such lists provides one of the network
structures made convenient by the MS paradigm - see p.<>.
Likewise useful is a parallel operation at a higher level, namely,
finding out if some subset of word-objects exists in other
collections. For instance, the phrase “you know” occurs millions of
times, while the phrase “know, butterflies” (from a sentence such as
“You know, butterflies are pretty, too.”) may not appear in training at
all. The list of such subsets includes
primitive-words-in-a-compound, words-in-a-path, paths-in-a-concept,
primitive-daemons-in-a-script, etc. These can all involve linguistic
elements or various levels of elements in other realms, including the
actions of the program itself. Examples follow: in the left column, a
description of each subset level is given for language, because that’s
the realm we understand most readily. Examples are in the next column –
each with 3 related elements: that is, 1), 2), and 3) in each example
possess related or identical elements. For most levels, there are
triplets from both linguistic and another realm in which the program
operates. Remember, everything below that is 1), 2), or 3) can be made
into a single MS point (the fact that a collection can be made into a
single-point-object is no guarantee of any type of utility or validity;
these evaluations constitute an entirely different kettle of fish).
subset
description examples of
objects with common sub-elements
syllables
in words
linguistic:
1)important – 2)importer –3) importune
musical:
1) first three events in “happy
birthday”
(common element:
2) first three events in Josquin’s “Missa
Pangea Lingua”
pitch contour)
3) first three
events in the inversion of theme I, Brahms, “Sym. No. 2”
primitives
in compounds linguistic: 1)horseapple –
2)crabapple – 3)adam’s apple
robot
manipulator:
1) access proprioceptors – decide on the direction
to the goal – move the arm
(common element: 2)
access proprioceptors – decide if you have reached the goal – move
observe
self:
if necessary
make
a decision 3) access
proprioceptors – decide if they are functioning – debug if required
words in a
path
linguistic:
1) I have, as pets, some bunnies.
2) I have, as vehicles, some motorcycles.
3) I have, as boundary values on axis # 324, the
numbers 27 and 56.
computer language: (see
“Fly”, main file, part two, simulations)
1) buffer A holds a positive increment– buffer B:no
increment :
ergo, stored association=command#1
(each of these is
2) buffer A:positive
increment– buffer B: positive increment – stored
one Puss-cycle)
association=command#2
3) buffer A:no increment– buffer B:no increment – no
stored association
paths in a
concept
linguistic:
1) “2” and “3” are numbers. Put them together. “5”
is also a number.
2)”Tom” and “doe”
are (genders of) cats. Put them together. “Kitten” is also a
cat.
3) “#1 above” is an element of an example, as
is #2. Put them together. You get
another element of an example.
robot navigation:
1)recognize current location:
match with goal = fail: apply negative
(see below)
reinforcement
2)actuate sonar sensor: return value = fail: apply
operator “use partial windows”
3)recognize current location: teacher signals
“error”: apply operator “expand
windows”
concepts
in an argument linguistic:
1) I thought it was an “E”.
George says it was an “F”. My eyes are better than
George’s, so I still think it was an “E”.
(the common element 2) I
wanted to watch the train. George was afraid. I knew it was safe because
here is “conflict
we weren’t on the tracks, so we
didn’t run away.
resolved by
additional 3) I thought there was too much
rubato. George liked it. But it’s MY
information”.)
performance, and so I won’t play it that way.
The robot navigation example is a bit opaque. There is really no reason
to use the level designations “path” and “concept” with respect to this
realm, but it’s easiest, and in no sense “wrong” to the program, to
continue to use those labels for this level: the problems listed in
this triplet exist at the same distance from the primitives of the
realm as linguistic paths. In any event the common element is the
appearance of “fail” or “error” followed by the action “apply
Puss-predicted behavior”.
(subfile 18: Syllables, words, and
phrases: levels of information)
It is useful for the computations required to be the same, even at
widely differing levels of resolution; not only does this reduce the
complexity of the programming task, but it makes it easy for logical
operations to either be insulated from irrelevant details, or can
descend to the level of those details when necessary. Ascending in
level means details are used less, and descending makes them all
visible again. Having all levels the same means that top-down vs.
bottom-up processes can use the same code. As an example: I don’t
often think about the safety, convenience, etc., of my “home” when I
think about leaving work to go home, but I have to know about all those
things when having a discussion about the “value” of having such a
place to go. (Such details of a word like "home" are the "lower" level
of information, in my formulation.)
(Subfile 19: relationships among axes in words
- Semantic Networking)
These relationships primarily fall into two categories. First, at the
top level of the definition of “apple” would appear “red” and “fruit”.
Both of these are words themselves, and a lower level of apple’s
definition would then be the definitions of these two words. Second,
“red” has a pointer to “fruit”, and the pointer is of type “modifies”.
A wide variety of such relational pointers provide the logical
structure necessary to complete the word definitions, and, since the
pointers are themselves expressed as axes, they take part in the
location of words in MS. Thus two words with identical axes, but with
differing relations among them, would appear to exist at different
locations. In addition to "modifies", there are such operators as
"contains", "precludes", "can_operate_on", and their logical inverses,
or passives: "is_contained_by", "is_precluded_by", and
"is_subject_to". The list of such operators is quite long, and since
the
program can learn to add new ones, it will increase. These operators
are exactly analogous to the labels of edges/vectors in semantic
network definitions.
(subfile 19.8: recognizing phrase types)
The mechanism for recognizing, storing, and defining this equivalence
is the "resonance" (see p.17 main file) that occurs between an object
"noun_with_article" and all the other phrases in training conversations
that follow the target phrase "I would like...". Any object that
directly follows such a phrase would be considered to be a single
element by certain Purr-puss modules, simply because it follows a
known, previously concatenated object. Each such element would acquire
an association to the target phrase. (These following-objects could be
of any complexity, summed or decomposed, etc.)
The object "noun_with_article" exists every time the program observes
the appearance of two adjacent words, one of which matches the template
“noun” and the other which matches that for “article”. This sort of
reduced-world-view object is very important in the history of this
program (see CHANTER and CONVERSOR in part two.)
In addition to reduced-world-view Puss-windows, there are of course
windows that take in whatever is literally present. Therefore whenever
the phrase “I would like. . . “ occurs in the training set, followed by
a “a cat”, the program would store both “a cat” and “noun-with-article”
at a memory location defined by “I would like”.
All the associations with “a cat” are seen the same way as the ones
acquired by the object "noun_ with_article", when it follows the
original concatenated phrase "I would like…". The two groups of
associations then form part of a group called a resonance: “a cat” and
“noun-with-article” are said to resonate because of their equivalent
association from “I would like”. The smallest and simplest element of
this resonance is the noun/article object.
As the resonant group acquires more and more members, the program would
learn that this group is useful – simply because the target phrase
occurs often. Likewise, the program would not incorrectly learn
that other relationships are important via this same mechanism, simply
because they would not be repeated. Thus this mechanism wouldn't clog
up the process with irrelevant or useless information.