Program control and control of a Program

There has been a sporadic discussion as to what is controlled at the Program level, e.g. in 1994 and 2009. Rick’s ‘Program control’ demo updates his 2004 proposal. This exemplifies the view that ‘program control’ is control of whether or not a program is currently ‘running’. I have disagreed with this, most recently last October.

Intuitively, one does not execute a program just in order to know that it is being executed. You don’t perform the steps of a recipe just to know that you are indeed gathering ingredients, mixing, heating, stirring, and so on; you do so in order to taste and enjoy the sauce that results.

A program controls a series of perceptions, the last of which is the conclusion or result ‘returned’ by the program. A program ‘runs’ because another system requires that ‘conclusion’ perception as part of its perceptual input and generates the signal that starts the program. In B:CP, Bill’s desire to read initiates the process of finding his glasses, and what is important there is the result of having his glasses in hand so that he can put them on and read.

Whether or not the procedure is still ‘running’ is of secondary importance. The system that ‘calls’ the program may also monitor whether or not it is running, but only as means of being sure to obtain the final perception that is controlled by the program (its conclusion or result). But really it is the persistence of Bill’s desire to read that ensures that the reference signal for finding his glasses persists even if the search is interrupted, perhaps by a telephone call.

Three terms need to be distinguished.

  • Control by means of a program: A system generates a reference signal to ‘run’ a program.
  • Control of a program: A system monitors whether or not a program is currently in process of running.
  • Program control: A Program-level perceptual function generates reference signals for a series of control loops, such that some CVs are requisite inputs for control of others, in an orderly way, and the last of the series of CVs is the perception controlled by the program and sent to the system that started the program.

How are control loops linked together in an orderly way such that the perceptual inputs which each requires are controlled, leading to control of the perception that the ‘calling’ system requires in its input?

Something must structure the program that is perceived in control of a program; what else, but the system that detects whether or not it is running? I believe this opens a way to reconcile the appearance of controversy in this discussion.

The phrase “a series of control loops” suggests that we start by looking at how a system to control sequences might be structured. Bill (B:CP 145) diagramed a system that could recognize a monosyllable, an Event perception:

That system can observe and recognize the Event perception. To control that Event perception by producing the successive perceptions that it recognizes (i.e. to pronounce that monosyllable) requires some reference input signals for the lower-level loops that control the constituent perceptions. The signal that initiates the first ‘recirculation loop’ and the reference signal below it are branches of the same error output from the comparator above.

Note: The ‘recirculation loop’ at each step perseverates a signal that the given step has been controlled. This could be branched up to some system that does control of the the event-control process (is it running or not?). It is not the only way to do on/off control of the process.

This structure is best understood as the perceptual input function (PIF) for the comparator above it. We haven’t done much modeling of input functions. Below the Event level, perceptual signals generally enter a perceptual input function concurrently, though it is often the case that not all need be present, or that some may come from lower systems that are controlled in imagination mode.

Here, a perceptual signal is controlled and enters the PIF only when a reference signal for it is sent to the lower subsystem that controls that signal, and only after that signal is controlled is a reference sent to the next subsystem. The sequence and timing is determined by the structure of the PIF.

An Event is brief, each of its successive inputs is transient, and it cannot be interrupted and resumed. All that matters is that the Event has occurred. An arpeggiated chord is still a chord, and Bach develops chord sequences in the solo cello suites equally as in keyboard and ensemble music.

A Sequence need not be temporally compact, and it can be interrupted and resumed. The PIF structure proposed above for event control can serve for sequence control, with one change: instead of merely returning news of completion, it returns the last perception controlled in the sequence.

This signal could equally well serve as “news of completion” for Event control. In each case, some other system generates a reference signal at the reference input function (RIF) of the comparator at the top of the diagram. Given its nature (an Event is brief, well-known, well-practiced) all that is needed at that level is a signal that out of the finite inventory of familiar Event perceptions this one has occurred. But a Sequence has a purpose that is served by controlling the last of its series of CVs. Only when you finish the list of steps can you taste the sauce.

When the interrupting Sequence provides control of a perception that is required input in the main Sequence, that is like a subroutine in a program. If the required CV is already present, the reference signal for it generates no error to initiate the sub-Sequence; if the CV is not already present, the reference signal for it generates an error signal that initiates the sub-Sequence. This is the structure of a simple IF/THEN conditional test.

We may expect that control at any point in a given sub-Sequence may require input of more than one perceptual variable into a perceptual input function, any one or more of which may be provided by Sequence control. Sometimes several sequences can be alternative means of control (attach a plate by gluing, nailing, screwing, bolting). This has the external appearance of a program choice-point. Several kinds of branches are possible.

The perceptual signal controlled at the conclusion of sequence n is part of the perceptual environment available to the input functions of the set of candidate sequences {*mi…j}. I do not know of a way to test the ‘match’ of a perception to an input function other than by controlling it. This can be control in imagination mode.

Subjective investigation of sequence control, and the assembly of sequences to attain a result, suggests to me that we select one branch over another by controlling them in imagination until we find a pathway through them that (in imagination) leads to controlling the finally desired result with the least adverse side effects and the fewest disturbances and other failures of control that are imagined based on memory.

That which returns the strongest signal is selected (flip-flop). (IF … THEN code must use a static symbolic representation to represent the dynamic perceptual conditions under which one or another of these alternatives has a stronger signal.) If the selected sequence does not control successfully, the candidate next step with the now strongest signal is selected as above. It may be that candidate paths are tested concurrently. Awareness is not required.

In the case that Bill describes as “a ‘tree,’ one test leading to a choice of succeeding tests without further intervening operations” the set of alternative sequences are themselves programs. Nothing special is required in addition.

If Sequence m fails to control its last input, and there are no alternatives, the program fails (error signal).

The program PIF in the figure above does not specify a desired result. Manipulate the buttons on the calculator and use whatever number results. Carry out the TCV until you have identified the CV, whatever it turns out to be. The Program-invoking or Sequence-invokin system initiates the program with no reference signal for the perception that its last step controls. This is like a subroutine call in computer code. An investigation, where the outcome is not known, is of broad and general use in life.

The desired outcome may be known in advance. When the CV that is controlled by the last loop of a sequence or program has a reference value specified by a system that is using that Sequence or Program to obtain that value of that perception, error controlling the final loop branches back to the entry point of the reference signal for the first loop.

A class of simple examples is represented in computer program code by logical loops written WHILE … DO, UNTIL … DO, etc. “Add salt to taste.”

Perseveration of prior steps by those ‘recirculation loops’ enables reconsideration of earlier branch-points when alternatives at a given branch-point don’t pan out. Capacity to do this is measured by the ‘rigid/flexible’ parameter of cognitive temperament that Rokeach studied. (The ‘open/closed’ parameter is a measure of capacity or willingness to control in imagination in ways that depart from memory of controlling through the environment, extending familiar analogies.)

A fourth term is control of Program structure. If the program fails in all alternatives (all that were tried) a higher-level system may control perceptions of the structure of the program. It controls constituent steps (and their alternatives) in imagination and alters the program by trial and error. This may not be the same system that initiated the program but was unable to control using perceptual input from the program (from its final step). This kind of control is also used for planning.

There is much still to be understood, and none of it has been demonstrated, but even in outline I believe the above reconciles the appearance of controversy in this discussion. The perceptual input function of a program-level control system creates the program, and it also perceives whether or not it is running after another system has started it.

I think it’s better to say that program control is control of whether or not a program is happening; whether you are carrying it out (like Bill’s “searching for glasses” example) or if it’s being carried out by others (like a game plan in sports).

But you do have to know (perceive) whether or not you are executing the desired program. Hence, Bill’s hypothesized program control level of the perceptual control hierarchy.

This isn’t true of a computer program (the program doesn’t really perceive the results of carrying out each step of the program). But it can be true of a person controlling for a program type perception, as in Bill’s searching for eyeglasses example but not necessarily, as in my program control demo where all that is controlled is the occurrence of the entire program itself, not the results of each step.

In Bill’s model this is true of every perception controlled by the hierarchy of control systems except those controlled at the highest level (currently system concepts).

In Bill’s model, higher level control systems generate reference signals for the perceptions, not the output, to be controlled by lower level systems. So, for example, the systems controlling principle perceptions send references fo program perceptions to be controlled by the lower level program control systems as the means of controlling those principle perceptions.

Yes, that’s what I’m talking about: control of a program perception. But I would add that control of a program perception involves both monitoring (perceiving that the program is occurring) and, if necessary, acting – generating reference signals to lower-level systems in a “programmatic” way – in order to maintain the program perception in the reference state. Remember, behavior – like the behavior of carrying out a program of activities-- is organized around the control of perception, as it has to be if it is being produced in a disturbance prone environment.

Perceptual functions don’t generate reference signals, control systems do. At least that’s the way it works in Bill’s model. In order to control a program perception it is usually necessary to produce a “programmatic” set of references for lower level perceptions, but not always, as in my demo, where all a person has to do to control the program perception is press or not press the space bar.

What your saying here could definitely be consistent with Bill’s model of program control. In Bill’s model, what structures the program that is perceived in program control is the output of the program control system. The system that controls the program compares the perceived program (as it is occurring) to a reference for the program that should be occurring and it acts, by sending references to lower level systems, to keep the desired program perception occurring.

I’ve made a high level sketch of what I think is going on in my program control demo according to Bill’s model:

The control system is organized around control of the perceptual signal, p, that represents the program is produced by the perceptual function, I. This neural network perceives the program of shapes and colors that is being shown on the computer display (the program display). The perceptual function for programs is shown at the interface to the environment, but this is obviously a simplification; there are several layers of perceptual functions – to perceive the colors and shapes that make up a program.

The program perceptual signal t is compared to a reference for the desired program. If there is an error(a difference between p and r) then there is an output, which is to press of the space bar. The effect of this press is to change the program that is running; the effect of the space bar on the program is mediated by the computer, which is the feedback function between output and controlled variable (the program that is occurring). In my demo the program can be kept at the reference by simply pressing the space bar when appropriate. But in most cases where people carry out programs of activities themselves the outputs that maintain the program will be much more complex.

I’ve emphasized the program perception function, I, in my diagram because that’s what has to be developed for a model that mimics the behavior in my program control demo. I made the output in that demo simple because I think we should try to figure out how programs are perceived before trying to figure out how to produce the the programmatic outputs that are used to control a perception of a program in real-life situations like Bill’s “search for eyeglasses” example.

The bulk of the rest of your post consists of explanations of diagrams that look like Bill’s suggested model of a perceptual function that perceives sequences. I didn’t see anything in your diagrams that suggested that they could be models of a program perceptual function, but maybe I missed something.

I can’t tell from this whether we are on the same page or not. The perceptual input function of a program control system doesn’t really create a program. But maybe that’s an OK way of saying it as long as it’s understood that the program being created (constructed might be a better term) is based on the raw material of what’s really happening. It will not create a perception of “if (circle) then (blue) else (red)” if what’s happening out there is “if (circle) then (red) else (blue)”.


Thanks for this Rick!
So the program itself is an automated process that’s not represented in the control system diagram? How are they represented as there are lots of them and can be quite detailed? In memory?

The program is a perception – a function of sensory effects of environmental variables. In my demo it is a perception of an aspect of the animated computer display of graphical objects of different shapes and colors.

In the diagram the program exists in two places: 1) in the environment as a very simple network of contingencies between the different shapes and colors that appear on the computer display; this is called the CV in the diagram and 2) in the control system as a perceptual variable, p, called the “program perception” in the diagram.

I don’t understand. I think there are only two possible states of the program perception, at least in the situation presented in my demo. What are the “lots of them” you’re thinking of?

Sorry, I think I do understand. We carry out (and recognize) many different programs. These would be the references to a program control system and Bill’s model would say that they are, indeed, stored in memory and accessed by reference (address) signals coming from higher level control systems.