Metacat

Metacat

http://science.slc.edu/~jmarshall/metacat/

Version 1.2
Last updated: September 2020
Author:  James B. Marshall
j + (my last name) + @slc.edu

This page provides information about the Metacat computer model of analogy-making and perception, including downloadable source code and instructions for running the program.

The definitive source of information about Metacat is my PhD dissertation, Metacat: A Self-Watching Cognitive Architecture for Analogy-Making and High-Level Perception, Department of Computer Science, Indiana University, Bloomington, 1999. A PDF version is available here:

• Metacat PhD dissertation

---

Overview

Metacat is a computer model of analogy-making and perception that builds on the foundations of an earlier model called Copycat. Copycat was originally developed by Douglas Hofstadter and Melanie Mitchell as part of a research program aimed at computationally modeling the fundamental mechanisms underlying human thought processes. Central to the philosophy of this research is the belief that the mind's ability to perceive connections between apparently dissimilar things, and to make analogies based on these connections, lies at the heart of intelligence. According to this view, to understand the analogical mechanisms of thinking and perception is to understand the source of the remarkable fluidity of the human mind, including its hidden wellsprings of creativity.

Like Copycat, Metacat operates in an idealized world of analogy problems involving short strings of letters. Although the program understands only a limited set of concepts about its letter-string world, its emergent processing mechanisms give it considerable flexibility in recognizing and applying these concepts in a wide variety of situations. The program's high-level behavior emerges in a bottom-up manner from the collective actions of many small nondeterministic processing agents (called codelets) working in parallel, in much the same way that an ant colony's high-level behavior emerges from the individual behaviors of the underlying ants, without any central executive directing the course of events.

Metacat focuses on the issue of self-watching: the ability of a system to perceive and respond to patterns that arise not only in its immediate perceptions of the world, but also in its own processing of those perceptions. Copycat lacked such an "introspective" capacity, and consequently lacked insight into how it arrived at its answers. It was unable to notice similarities between analogies, or to explain the differences between them or why one might be considered to be better or worse than another. In contrast, Metacat's self-watching mechanisms enable it to create much richer representations of analogies, allowing it to compare and contrast answers in an insightful way. Furthermore, it is able to recognize, remember, and recall patterns that occur in its own "train of thought" as it makes analogies. For instance, by monitoring its own processing, Metacat can often recognize when it has fallen into a repetitive cycle of behavior, enabling it to break out of its "rut" and try something else.

Additional Information

If you are interested in learning more about Copycat and Metacat, or other similar projects, the following publications and web sites are good places to start (in addition to downloading and trying out the code itself):

• Marshall, J. (2006). A self-watching model of analogy-making and perception. Journal of Experimental and Theoretical Artificial Intelligence, 18(3), pp. 267-307.
• Marshall, J. (2002). Metacat: a self-watching cognitive architecture for analogy-making. Proceedings of the 24th Annual Conference of the Cognitive Science Society, pp. 631-636.
• Marshall, J. (2002). Metacat: a program that judges creative analogies in a microworld. Proceedings of the 2nd Workshop on Creative Systems: Approaches to Creativity in Artificial Intelligence and Cognitive Science, 15th European Conference on Artificial Intelligence, pp. 77-84.
• Fluid Concepts and Creative Analogies, by Douglas R. Hofstadter and the Fluid Analogies Research Group, Basic Books, 1995.
• Analogy-Making as Perception, by Melanie Mitchell, MIT Press, 1993.
• The Subtlety of Sameness, by Robert M. French, MIT Press, 1995.
• A sampler of Copycat analogy problems
• Original Copycat source code (in Common Lisp)
• Center for Research on Concepts and Cognition

---

Downloading and Installing Metacat

The Metacat source code is available for Linux, Macintosh, or Windows from the links below, under the terms of the GNU General Public License.

• Metacat source code (gzipped tar archive)
• Metacat source code (zip archive)

Metacat requires the following software packages:

• Chez Scheme
• Scheme Widget Library (SWL)
• Tcl/Tk version 8.3 or later

Chez Scheme is an ANSI/IEEE-compliant implementation of the Scheme programming language. SWL is a windowing and graphics package based on Tcl/Tk that extends the capabilities of Chez Scheme. To install SWL, you must first install Chez Scheme and Tcl/Tk, if they are not already on your system. All three packages are available for Linux, Macintosh, or Windows from the links below.

Thanks to Frank Sinapsi for patching SWL to work with the latest version of Chez Scheme! With the new version of SWL, Metacat now runs much faster than before. It also runs on macOS 10.15 (Catalina), which no longer supports 32-bit applications.

Virtual Machine

You can now run Metacat as a virtual machine using the free, open-source VirtualBox software from Oracle, which is available for several platforms including Mac and Windows. With this option, you don't need to install anything other than VirtualBox itself on your system. This option requires about 8G of free disk space.

1. Download and install VirtualBox version 5.2 (NOT version 6, which doesn't seem to work as well). The installer for MacOS is here. The installer for Windows is here. Installers for other platforms are available here.

2. Download the Metacat virtual machine file MetacatVM.ova to your Desktop. This file is a bit large (1.7G), so it might take a while to download.

3. Start VirtualBox. (If you get a message about updating to a newer version, just ignore it.) Choose File → Import Appliance, and navigate to the saved MetacatVM.ova file. Then click Continue, and then Import. You will only need to do this step once. After it finishes importing, you can start Metacat by double-clicking on MetacatVM in the panel to the left.

4. When the MetacatVM virtual machine boots up, it automatically starts Metacat. You will see two windows appear, labeled repl and Interaction window. In the repl window at the > prompt, type "(setup)" to initialize all of Metacat's windows. You can then minimize the repl and Interaction windows by clicking on the - button in each window's upper left corner, to get them out of the way since they aren't actually needed to interact with the program (closing them, however, will cause problems, so don't click on the x button).

   To shut down the virtual machine, click on the "power" button at the top right of the MetacatVM window (next to the clock time), and choose Shut Down. If you get the warning message VirtualBox quit unexpectedly after shutting down Metacat, just ignore it, as it doesn't seem to affect anything. You can also restart Metacat within the virtual machine by opening a terminal window and typing metacat.

5. (Optional) Delete the VirtualBox installer file and the MetacatVM.ova file from your Desktop, since they are no longer needed.

Linux

Metacat is known to work on 64-bit Ubuntu 16.04 LTS by following the installation instructions below.

1. First we need to install some support packages. Open a Terminal window and type the following command:

      sudo apt install curl uuid-dev libncurses5-dev libx11-dev tcl8.6-dev tk8.6-dev
   

2. Download and unpack ChezScheme-9.5.4.tgz on your Desktop. Then run the following commands in a Terminal window to compile and install Chez Scheme:

      cd ~/Desktop
      tar xfz ChezScheme-9.5.4.tgz  (run this command if needed to unpack the file)
      cd ChezScheme
      ./configure --installprefix=/usr/local
      sudo make install
   

3. Download and unpack swl1.3-src-patched-linux.tgz on your Desktop. Then run the following commands in a Terminal window to install SWL:

      cd ~/Desktop
      tar xfz swl1.3-src-patched-linux.tgz  (run this command if needed to unpack the file)
      cd swl1.3
      sudo make install
   

4. Download and unpack Metacat-1.2.tgz on your Desktop. Then change to the Metacat directory and edit the file metacat.ss by uncommenting (and modifying if necessary) the appropriate lines defining the variables *platform*, *metacat-directory*, and *file-dialog-directory* for your system.

      cd ~/Desktop
      tar xfz Metacat-1.2.tgz  (run this command if needed to unpack the file)
      cd Metacat
      nano metacat.ss
   

5. To start Metacat, make sure you are in the Metacat directory, then type the following command (this might take longer the first time SWL is run):

      swl metacat.ss  
   

6. (Optional) Delete the downloaded .tgz files and the ChezScheme and swl1.3 directories from your Desktop, since they are no longer needed. You can also move the Metacat directory to another location on your system if you prefer, though you'll need to update the *metacat-directory* variable to point to the new location.

MacOS

Using the PKG files to install Chez Scheme and SWL no longer works on El Capitan 10.11 (and later), because they attempt to install files in /usr/bin and /usr/lib, which is no longer allowed. Instead, the instructions below will install everything in your top-level home folder (i.e., /Users/your_username).

1. Download and unpack ChezScheme-9.5.4.tgz on your Desktop, which will create the folder ChezScheme. Then run the following commands in a Terminal window, which will compile and install Chez Scheme in /Users/your_username/bin and /Users/your_username/lib, and will put the man pages in /Users/your_username/man1:

   cd ~/Desktop/ChezScheme
   ./configure --installprefix="$HOME" --installman="$HOME"
   sudo make install
   

2. Download and unpack swl1.3-src-patched-macOS.tgz on your Desktop, which will create the folder swl1.3. Then run the commands below in a Terminal window. I have modified this package so that it will install in /Users/your_username/bin and /Users/your_username/lib instead of /usr/bin and /usr/lib.

   cd ~/Desktop/swl1.3
   sudo make install
   

   You can now start SWL by simply typing the command swl in a Terminal window, assuming that /Users/your_username/bin appears in your PATH (to verify this, type echo $PATH). If you get the error swl: command not found, try updating your PATH by typing the following command:

   export PATH="$HOME/bin:$PATH"
   

   If you want to be able to run SWL as an app, download and unpack swl.app.tgz, and drag it to your Applications folder. If you get the message SWL can't be opened because it is from an unidentified developer the first time you try to run it, open your Applications folder in Finder, Control-click on SWL, choose Open, and then click Open again.

3. Download and unpack Metacat-1.2.tgz on your Desktop. Then in a Terminal window, change to the Metacat folder and edit the file metacat.ss by uncommenting (and modifying if necessary) the appropriate lines defining the variables *platform*, *metacat-directory*, and *file-dialog-directory* for your system. The command below will open the file with the Nano text editor:

      cd ~/Desktop/Metacat
      nano metacat.ss
   

4. To run Metacat, start SWL (this might take longer the first time SWL is run) and then load the file metacat.ss at the > prompt in the repl window using its full pathname. For example:

   > (load "~/Desktop/Metacat/metacat.ss")
   

5. (Optional) Delete the downloaded .tgz files and the ChezScheme and swl1.3 folders from your Desktop, since they are no longer needed. You can also move the Metacat folder to another location on your system if you prefer, though you'll need to update the *metacat-directory* variable to point to the new location.

Older versions of MacOS (Yosemite 10.10 and earlier)

• pcsv8.4-i3osx-1.pkg.tar.gz: Petite Chez Scheme PKG for Intel/AMD Mac OS X
• swl1.3-i3osx-1.pkg.tar.gz: Scheme Widget Library PKG for Intel/AMD Mac OS X

To install Scheme, unpack pcsv8.4-i3osx-1.pkg.tar.gz and click on the pkg file. If needed, install Tcl and Tk next by unpacking tcl8.4.4.pkg.tar.gz and tk8.4.4.pkg.tar.gz and clicking on the pkg files. Then unpack swl1.3-i3osx-1.pkg.tar.gz and click on the pkg file. Then continue with Step 3 above to install Metacat itself.

Windows

Note: for Windows, the virtual machine version of Metacat may be the best option.

• pcsv84.exe: Petite Chez Scheme self-extracting .exe for Intel/AMD Windows. Under Windows, the Petite Chez Scheme installer automatically installs SWL and Tcl/Tk. (Scheme, SWL, and Tcl/Tk can be uninstalled via the Add/Remove Programs option in the Windows control panel.)

• To install Metacat itself, download Metacat-1.2.zip to your Desktop and unzip it. Edit the file metacat.ss in the Metacat folder by uncommenting (and modifying if necessary) the appropriate lines defining the variables *platform*, *metacat-directory*, and *file-dialog-directory* for your system.

Important: After untarring or unzipping the source code, you must edit the configuration settings in the file metacat.ss before running Metacat for the first time. The *platform* variable should specify your operating system. The *metacat-directory* pathname should point to the directory containing the Metacat source code. The *file-dialog-directory* pathname should point to the default directory to use when saving files with the Save commentary to file menu option. And *tcl/tk-version* should specify which version of Tcl/Tk is installed.

Metacat uses a lot of memory. For best performance, at least 512MB of RAM is recommended, especially for some of the longer demo runs.

---

Running Metacat

To start the program, do one of the following:

• In Linux, cd to the Metacat subdirectory and type swl metacat.ss at the Linux prompt.

• On a Mac, start SWL and then load the file metacat.ss using its full pathname. For example:

  > (load "~/Desktop/Metacat/metacat.ss")
  

• In Windows, first create a shortcut on the Desktop to the SWL application: under the Start → Programs → Chez Scheme submenu, right-click on SWL and choose Send To → Desktop. Then simply drag and drop the file metacat.ss onto the Desktop SWL icon.

This will load all of the Metacat source code into Scheme/SWL. Next, type "(setup)" at the > prompt in the repl window to initialize all of Metacat's windows. These may be rearranged, resized, or iconified as desired. Closing a window hides it but does not destroy it (there are a few exceptions to this, however; see below). The following windows are created by Metacat:

• Control Panel
• Workspace
• Temperature
• Slipnet
• Coderack
• Top, Bottom, and Vertical Themes
• Temporal Trace
• Episodic Memory
• Commentary
• EEG (hidden)
• Metacat Logo (hidden)

Two other windows, labeled repl and Interaction window, are created automatically by SWL, and should not be closed. However, they can be iconified and ignored since they are not needed to run the program.

To quit Metacat, simply close the Control Panel window.

Control Panel

Most interaction with Metacat occurs through the Control Panel, shown below. (Note: the appearance of the graphics will be slightly different on non-Linux systems. For instance, in Mac OS X, the main menu bar is located at the top of the screen.) To run Metacat on an analogy problem such as abc -> cba; pqrs -> ?, type the problem into the Control Panel's input field as shown, and press Return. Punctuation is optional.

This will initialize the Workspace, Slipnet, and other program components accordingly. To begin the run, press Return again or click the Go button. In general, clicking Go is equivalent to pressing Return.

To interrupt execution, click Stop or click once anywhere in the Workspace window. Click Go or click on the Workspace again to resume execution. The Speed slider bar controls the speed of the graphics.

When Metacat finds a new answer, it stops running and displays the answer along with the Workspace structures (groups, bridges, rules, etc.) that gave rise to it. It also stores a description of the answer in its Episodic Memory. Continuing a run after an answer has been found may lead the program to discover other answers to the same problem. It may even discover an alternative way of producing some earlier answer based on a different interpretation of the letter-strings (i.e., by using a different rule to describe how the strings change). However, it will not reproduce an answer that is identical to one already in memory involving exactly the same letter-strings and rules.

The Step button single-steps program execution, where each step corresponds to running one codelet from the Coderack. After pressing Step, single-stepping may be continued by clicking directly on the Workspace window, until Go is pressed or the problem is reset. The default step size is one codelet, but this may be changed via the Step mode interval setting under the Control Panel Options menu. Program execution will be interrupted on every time step that is a multiple of the current step size setting.

It is also possible to specify a particular time at which to interrupt execution. This can be done via Set breakpoint under the Options menu. The breakpoint will remain in effect until it is cleared, which must be done manually using the Clear breakpoint menu option. It is not possible to set multiple breakpoints.

Since Metacat is nondeterministic, it may produce different results when run more than once on the same problem. The exact behavior of the program is determined by the seed value used to initialize the random number generator at the beginning of a run. The seed used for the current run appears in the upper right corner of the Control Panel. A particular seed value may be specified by including it after the letter-strings in the input field. For example, to run the above problem using the seed 123456, enter "abc cba pqrs 123456".

The Reset button resets the current run to the beginning, using the same seed value as before. Warning: resetting a run does not erase Metacat's Episodic Memory. If the program is rerun with the same seed after finding a new answer, it won't find that answer again, because it already exists in memory. To reproduce a run exactly, the state of the memory must be the same as it was at the beginning of the run.

To erase all answers from Metacat's memory, click Clear Memory on the Control Panel's main menu bar. (In Mac OS X, this option is located under the Options menu.)

The Windows menu makes it easy to hide and unhide Metacat's many windows, which can help to reduce screen clutter. To show or hide a window, choose the appropriate action from the menu. A window can also be hidden by closing it, usually by clicking on a small "X" in the corner of the frame. (Closing the repl, Interaction, or Control Panel windows, however, will destroy them, so don't do this.)

It is also possible to provide Metacat with an answer to a problem along with the problem itself. In this case, Metacat runs in answer justification mode, working backwards from the answer to try to discover why (or if) it makes sense. (See pages 49, 59-62, and 152-161 of the dissertation for an explanation of answer justification.) To provide an answer, simply include it as an extra letter-string when entering a problem in the Control Panel. For example, to specify sqrp as the answer to the earlier problem, enter "abc cba pqrs sqrp". As before, a seed value can be included after the letter-strings if desired, as in "abc cba pqrs sqrp 123456".

Workspace and Temperature

The Workspace temperature is an inverse measure of the amount and quality of built structures that currently exist in the Workspace, and is displayed in the Temperature window. At the beginning of a run, when no structures have yet been built, the temperature is very high (100 degrees). As the program builds up a more organized view of the letter-strings, temperature falls toward zero.The Workspace window displays the activity of codelets as they propose, evaluate, build, and destroy structures (groups, bridges, rules, etc.) during a run. Newly-proposed structures are shown as dotted lines, evaluated structures as dashed lines, and built structures as solid lines (see the image above).

Besides serving as a measure of Workspace organization, temperature also controls the amount of randomness used by codelets in making decisions. At higher temperatures, codelet decisions are largely random; at lower temperatures they become much more deterministic. The net effect is that the program gradually moves from largely random, exploratory behavior at the outset of a run to largely deterministic, focused behavior near the end, as it discovers more relationships among the letter-strings.

Slipnet

The Slipnet window shows the current activation of each Slipnet node (links between nodes are not shown). Each node corresponds to a particular concept that the program knows about the letter-string world. Some concepts start out highly activated at the beginning of a run, depending on the particular problem. In general, the more highly activated a concept is, the more influence it exerts on the nondeterministic decisions made by codelets in the Workspace. In turn, structure-building activity in the Workspace influences the amount of activation that concepts receive in the Slipnet.

Depending on the circumstances, concepts may be temporarily clamped by the program at full activation, which causes them to exert maximal influence over codelet activity. When a concept is clamped, its activation is shown in light blue, as in the example above.

If desired, the Slipnet display can be turned on or off by toggling the Slipnet graphics setting under the Control Panel Options menu. This can be useful for speeding up the graphics in the other windows.

Coderack

The Coderack holds the current pool of codelets waiting to run. On each time step, one codelet is chosen probabilistically from this pool, removed from the Coderack, and run. The Coderack window displays, for each codelet type, the number of codelets of that type currently in the pool and the relative probability that a codelet of that type will be chosen to run next (shown as a horizontal bar). Selection probabilities depend on the number of codelets of each type, the urgency values of each codelet (not shown), and the current Workspace temperature. In general, every codelet is assigned an urgency value at the time it gets created, with higher urgencies meaning a higher likelhood of being chosen to run. The most recent codelet type that ran is shown in dark pink.

For example, a typical Coderack state is shown to the left. Here the last codelet that ran was a Top-down description scout. The most likely type of codelet to run next is a Description evaluator, even though there is just one such codelet waiting. This is because its urgency value is much higher than that of the other codelets, even the combined urgencies of the 19 Rule scout codelets waiting to run.

If desired, the display of codelet counts (the numbers to the left of each codelet type) in the Coderack window can be turned on or off by toggling the Show codelet counts setting under the Control Panel Options menu. Likewise, the last-codelet-type indicator can be turned on or off via the Show last codelet type menu setting. Finally, the entire Coderack display can be turned on or off by toggling the Coderack graphics menu setting. This can be useful for speeding up the graphics in the other windows.

Themespace

Themes are structures that represent relationships between letter-strings at an abstract level. They play a key role in the descriptions created by Metacat of its answers to analogy problems, and serve as the basis for answer comparison. Themes reside in the Themespace, and are displayed in the three windows labeled Top Themes, Bottom Themes, and Vertical Themes. "Top", "bottom", or "vertical" refers to the particular string-mapping represented by a theme.

For example, the three top themes shown below represent properties of the horizontal abc -> cba mapping shown earlier in the top region of the Workspace window. The activation level of each theme is indicated by a green circle. In general, a theme whose activation level exceeds that of all other themes in its category by a sufficiently wide margin is called a dominant theme, and appears highlighted against a yellow background in the display. Themes can also be negatively activated, in which case they appear red instead of green.

Like Slipnet concepts, themes can be temporarily clamped by the program at full activation, which causes them to exert strong top-down pressure on the activities of codelets in the Workspace, effectively channeling Metacat's behavior in particular directions. A set of clamped themes is indicated by a bright green background in the theme window. For example, with the top themes String Position: identity and Direction: identity clamped, the Top Themes window would appear as shown below. This would encourage Metacat to reperceive abc and cba as going in the same direction, with the leftmost letter of abc mapping to the leftmost letter of cba, and so on. (See sections 4.1 and 4.2 of the dissertation for a complete discussion of themes and the Themespace.)

Temporal Trace

The Temporal Trace window shows a high-level record of the events that occur during a run. These events are monitored by codelets looking for patterns in the program's behavior. For example, several different types of events are shown below. These events include the building of the string-encompassing groups abc and pqrs, the activation of the Opposite concept in the Slipnet, the creation of a slippage between the concepts left and right, the creation of three different rules, and the clamping of a set of themes. (Section 4.4 of the dissertation describes the Temporal Trace in detail.)

An event can be examined more closely by clicking on its icon when the program is not running. Information about the event will be displayed in the Workspace window, and possibly other windows depending on the type of event. For example, clicking on one of the rule events shown below will display the rule along with the state of the Workspace at the time the rule was created. In addition, the concepts making up the rule will be displayed in the Slipnet window, and the themes associated with the rule will be displayed in the appropriate Theme window. Clicking on the event's icon again will restore the contents of the Workspace and the other windows.

Episodic Memory and Commentary

Metacat stores descriptions of problems and answers in its Episodic Memory. These descriptions contain the themes, rules, bridges, and other Workspace structures that gave rise to each answer, in addition to the letter-strings themselves. Each description appears as a labeled icon in the Episodic Memory window. For example, the left image below shows the contents of the memory after the program was run in answer justification mode on the answers srqp and sqrp for the earlier problem.

An answer can be displayed by clicking on its icon in the window. This will show the answer together with all of its supporting structures in the Workspace window, as well as the answer's associated themes in the Theme windows and its temperature in the Temperature window. Clicking on the icon again will restore the contents of the windows.

To have Metacat compare two answers stored in memory, simply click on the answers' icons in succession. The program will generate a summary in English of the similarities and differences that it sees, based on an analysis of the underlying themes and other structures stored in the answer descriptions. This summary appears in the Commentary window. For example, comparing the answers srqp and sqrp resulted in the commentary shown below. A few other messages generated during the sqrp run are also visible. (See section 4.7 of the dissertation for a detailed discussion of answer comparison and reminding).

The Commentary window font can be changed via the Commentary font face and Commentary font size settings under the Control Panel Options menu. The Save commentary to file menu option can be used to save the current contents of the window to a text file.Whenever Metacat works on an analogy problem, it generates a running narrative of its "thoughts" in the Commentary window. The tone of this commentary can be controlled via the Eliza mode setting under the Control Panel Options menu. Turning Eliza mode off results in more neutral-sounding commentary (this is useful for the humor-impaired, or for those worried about the notorious "Eliza effect"). Toggling Eliza mode on or off causes all of the text currently in the Commentary window to be redisplayed in the new mode, but does not change the number of paragraphs. This makes it easy to see the corresponding "translation" of any part of the text. (See sections 4.6 and 4.7.4 of the dissertation for more information about Metacat's commentary-generating mechanisms.)

The Verbose mode setting under the Options menu controls the printing of technical codelet messages in the Interaction window, and is unrelated to the generation of English commentary. These messages are useful for debugging, or for seeing what individual codelets are doing, but otherwise are not important. They do, however, slow down the program considerably, so turning Verbose mode on is not recommended.

EEG

The EEG window can be used to track the progression of numerical values such as temperature as they change over time. This can be useful in understanding the long-term behavior of parameters or other values during a run. By default, the EEG is configured to plot temperature and average Workspace activity (see below), but can easily be changed to track any desired values that fall within the range 0-100. See the file eeg-graphics.ss for more information. (The Workspace activity measure is described on pages 169-170 of the dissertation.)

Demo Runs

The sample runs of Metacat discussed in Chapter 5 of the dissertation are available under the Demos menu of the Control Panel. Selecting a demo will initialize the letter-strings and random number seed value appropriately. Click Go to begin the run. Many of these demos assume an initially empty memory, so it is a good idea to clear the memory before beginning each run.

This is not true, however, for the Answer comparison and reminding demos (discussed on pages 247-255 of Chapter 5). For example, to have Metacat compare the answers mrrkkk and mrrjjjj to the problem abc -> abd; mrrjjj -> ?, as shown at the bottom of page 249, first run the demos labeled "abc / mrrkkk" and "abc / mrrjjjj" in succession, without clearing the memory between runs. Then click on the icons for these answers in the Episodic Memory window in order to make the program compare them. The program's commentary will appear in the Commentary window.

A few other interesting runs, which were not discussed in the dissertation, are included in the Demos menu under Other sample runs. For instance, the first one (a long run of 7794 time steps) illustrates the program's ability to make sense of the answer mmmrrj to the problem abc -> cba; mrrjjj -> ?. This requires the program to see the lengths of the groups m and jjj in mrrjjj as getting swapped, rather than their positions or letter-categories (which would yield the answers jjjrrm and jrrmmm, respectively).

The second one asks Metacat to justify the answer abd to the problem abc -> abd; ijk -> ?. To do this, the program creates a rule describing both strings abc and ijk as changing their leftmost letter to a, their middle letter to b, and their rightmost letter to d, even though in abc's case the leftmost and middle letter "changes" are from a to a and b to b. Under normal circumstances the program would never perceive a letter as "changing" into itself, but given the context here, this idea makes perfect sense.

The last three examples demonstrate nondeterministic rule translation. In the first one, abc -> aabbcc; kkjjii -> ?, the program sees all letters in abc as increasing their lengths by one. The successor-predecessor symmetry between abc and kkjjii leads the program to decrease the lengths of the groups in kkjjii, yielding kji. Shortly thereafter, however, the program finds the answer kkkjjjiii by using the same rule as before, but this time ignoring the symmetry. (It also finds the answer kkjjii using a more literal-minded rule later.) In the next two examples, a -> b; z -> ? and abc -> abd; glz -> ?, Metacat notices the alphabetic symmetry between a and z (after hitting the z-snag multiple times, and answering b in the case of a -> b; z -> ?). The alphabetic symmetry causes a "coattail" slippage to occur between the symmetric concepts of successor and predecessor, yielding, respectively, the answers y and flz. (See section 3.4 of the dissertation for more information.)

Pattern Clamping and Self-Watching

Metacat uses the information in the Temporal Trace to monitor its own behavior, and can alter its behavior by clamping patterns of themes, concepts, or codelet urgencies in response to this information. This gives the program a high degree of self-control. There are three main types of codelets responsible for monitoring the Temporal Trace and responding to clamped patterns: Progress watchers, Jootsers, and Thematic bridge scouts. These codelets, together with the top-down effects of clamped themes, are the principal mechanisms for self-watching in Metacat. (See section 4.5 of the dissertation for a full discussion of self-watching.)

If desired, these codelet types can be turned off, along with the top-down effects of themes, by toggling the Self-watching mode setting under the Control Panel Options menu. With self-watching off, all activity in the Themespace is suppressed, and no new Progress watcher, Jootser, or Thematic bridge scout codelets are allowed to run, although new events are still recorded in the Temporal Trace and newly-found answers are stored in memory as before. This feature makes it possible to explore how Metacat's self-watching mechanisms influence its behavior on particular problems.

It is also possible for the user to manually clamp patterns of themes. To specify a theme pattern, choose Clamp theme pattern under the Control Panel Options menu, and then click on one or more Theme windows to select the themes to include in the pattern. When a Theme window is clicked, it will appear as shown below.

At this point, individual themes can be specified by left- or right-clicking on their names. Left-clicking selects maximum positive activation (green), and right-clicking selects maximum negative activation (red). On a Macintosh, Shift-clicking is equivalent to right-clicking. Clicking on an already-selected theme removes it from the pattern. When the desired theme pattern has been created, click the Clamp Themes button in the yellow confirmation dialog (not shown here) to clamp the pattern. A corresponding clamp event will appear in the Temporal Trace. The clamped pattern will remain in effect until undone by the program in the normal fashion at a later time, or until the user manually unclamps it.

To undo a clamp manually, select Undo last clamp from the Control Panel Options menu. This will undo the most recent clamp event in the Temporal Trace (whether created by the program or user), assuming that one is still in effect.

In addition to theme patterns, codelet patterns can also be clamped manually. A predefined set of codelet patterns is available under the Clamp codelet pattern submenu. Clamping a codelet pattern temporarily imposes a set of urgencies on the Coderack that overrides the urgencies of individual codelets. This enhances the likelihood that certain types of codelets will run, which may in turn encourage the program to focus on building specific types of structures, such as rules.

For example, a codelet pattern that promotes the discovery of new rules is shown below on the left. This pattern enhances the urgencies of all Rule scout, Rule evaluator, and Rule builder codelets, while suppressing the urgencies of all other codelet types (urgencies are indicated by shades of grey, with lighter shades corresponding to higher urgencies). On the other hand, the pattern shown on the right encourages the creation of new Workspace structures of any type, by enhancing the urgencies of all bottom-up scout codelets and, to an even greater degree, all evaluator and builder codelets. Top-down codelet types are not affected. Note that these two examples involve exactly the same pool of codelets in the Coderack. The only difference is the codelet pattern clamped, which results in a very different profile of selection probabilities in each case.

Send bug reports or other feedback to j + (my last name) + @slc.edu. If the program crashes on a particular run, please make sure to indicate the exact letter-strings and random number seed value, as well as the state of the Episodic Memory at the beginning of the run. Thanks!Feedback

============ End