A Consciousness Simulator Design

The first two chapters contain a lot of ideas that may be new to many readers, so this is probably a good point to take stock of where I am in the explanation of the topics contained in this book, and to provide a preview of where I am going with the explanation next.

With the identity of existence, causality, life, consciousness, and their basic relationships having been objectively defined and connected to a wider body of ideas in philosophy and science, to set them as a context, I can now translate conclusions drawn from those ideas into a design for a consciousness simulator. That is, by knowing the identity of the objects and processes that must be simulated to mimic awareness, and by knowing how they are related, a computer simulation system can be designed and implemented that reduces these abstract ideas to practice and performs the simulation of consciousness.

Therefore, in this chapter, I explain in a design overview the nature of a computer system that is a specific example of the ideas and implementation strategies I have been describing, a system that employs a new kind of teleological computer program that simulates the goal-directed behavior of life-forms as they interact with objects in a simulated existence, including an overview of its conceptual level functions. Building on that foundation, I explain how to simulate perceptual consciousness as a form of goal-directed and automatic purposeful behavior that regulates the interaction of digital life-forms with a simulated reality.

The process of concept formation and how it leads to the emergence and simulation of volitional, self-conscious, and natural language behaviors similar to those exhibited by human beings is explained and described in Chapter 4. In that chapter I explain how those properties emerge from the conceptual form of simulated consciousness that itself emerges from the perceptual form of simulated consciousness described and explained in this chapter.

Chapter 5 is the description I used for my patent application, and it integrates all the main ideas contained in this book in one place. The chapter begins with a brief summary of topics that are covered in the first four chapters to set the context for someone skilled in the art of computer programming, a summary that is intended to jump-start their thinking on how to design their own computer-based consciousness simulator and become a future licensee of DLF Simulation Technology. In addition, Chapter 5 provides the details of how to simulate advanced conscious processes such as concept formation, self-consciousness, volition, and how a DLF can encode and decode its own simple natural language sentences.

Now that it is clear where I am in the my explanation, let us continue with the rest of it.

3.2 A Design Overview of Digital Life-Forms (DLFs)

Digital life-forms are virtual entities that behave similarly to living organisms, including their conscious behaviors. These entities are unique in the way that they simulate life. In terms of the layered model I have been discussing, DLFs use a design with multiple layers, each of which is its own logical context and the cause of the layer above it. These logically connected, but distinct contextual layers simulate the multiple levels of causality that life-forms simulated on computer systems require to function.

At the most basic level, the computer hardware, operating system, programming language, and the simulation program layers (layers one through four) taken together simulate mechanistic causality for digital life-forms in a manner that is analogous to the way physics and chemistry are the mechanistic cause of real life-forms.

Unlike most computer program objects, however, the existence of the DLFs themselves is conditional: DLFs require simulated food and must act in certain ways to attain values or they cease to exist, just like a real life-form. In other words, they exhibit goal-directed behavior and they must cause their own future survival or they "die." (Their instance is either erased from the computer's memory, or their properties are set to zero.) The property of goal-directedness emerges from the design of the DLF Program, a design that is layered on top of standard computer programs; the teleological layer is layer five in the layered model.

Note - The DLF Program in its current implementation uses an object oriented programming language. In the terminology of such languages, each object falls into a category, and the particular objects in any category are called "instances." So there is a category of objects in the DLF Program called DLFs and each DLF is "born" when its instance is created and its attributes are given values and "dies" when that instance is either erased from the computer's memory or its attribute values set to zero.

3.2.1 Simulating Life and Death in a Computer

Artificial life programs in the current state of the art simulate natural selection using genetic algorithms or whole simulated ecologies in which groups of simulated life-forms compete for simulated natural resources. In other types of experiments, the function of the nervous systems of life-forms is simulated to various degrees using neural networks or robot designs, and certain physical behaviors of life-forms are simulated using copies of plant, insect, or lower animal sensory/motor nerve pathways, or in come cases, even simple electronic circuits made from bits of old appliances. Other kinds of animal behavior has been simulated with models of the instinctual behaviors of higher animals.

These simulations can be explained using the layered model described in the previous chapter: The life-like behaviors of the simulated life-forms emerge from the simulation programs and do resemble some of the behaviors of real life-forms. Moreover, to the extent that these simulated life-forms perpetuate their own survival, some of them may simulate goal-directed behavior.

However, to the best of my knowledge, none of the these programs are explicitly designed to simulate the levels of complex causality that I described in the previous chapter. To whatever extent such programs simulate behavior that is goal-directed, I believe they are that way because the life-forms that served as a model for their design are goal-directed, not because their designers and programmers understood the type of non-mechanistic causality described in this book. There is no evidence that I have seen as of the time of this writing that the inventors of current state of the art life simulations knowingly designed complex causality into their simulation programs.

In searches I have conducted over the Internet and other places, I have found some programs that seemed to be goal-directed, but are so only implicitly. And none has claimed or even implicitly achieved simulated consciousness such as I have been describing in this book, as far as I have been able to ascertain.

In all of the examples I have been able to find, the designers seem to implicitly accept the materialistic idea prevalent in Western science that consciousness does not exist, and they assume that all actions of life-forms are therefore explainable by mere mechanistic or "billiard ball" causality; consequently, that is how they design their simulations of them. In Chapter 5, I review several examples of these systems in more detail.

3.2.2 Duplicating Levels of Complex Cause and Effect

In the DLF Program, the DLFs are designed explicitly as complete organisms with both mind (simulated consciousness) and body as found in real higher life-forms.

Furthermore, the simulation of a DLF's consciousness depends on the survival of its body: If the DLF's body "dies," so does the DLF's "mind."

The DLF Program itself is the forth layer in the layered model I have been referring to, and the top layer of mechanistic cause and effect in the simulation system. The simulation of the DLFs at the fifth level in the layered model is where the spiral cause and effect of goal-directed behavior occurs, and is analogous to vegetative behaviors in real life-forms. Automatic perceptual behaviors are layer six in the layered model.

Life is not a miracle force; it is a complex, multi-level causal relationship between a life-form and the world in which the life-form's continued existence is determined by its own self-generated actions. That relationship involves the alternative of life or death for the life-form, depending on how the life-form controls its own behavior, with survival as its primary goal. The actions a life-form selects from alternatives, either automatically or by choice, determine its fate.

A DLF's primary goal is also survival; this goal is accomplished by taking various actions to obtain simulated food and to learn about its world. If the DLF takes the right actions that cause it to get simulated food, it "survives" and its instance is saved for continued use in the DLF Program; if the DLF takes the wrong actions, it "dies" by allowing its instance to be automatically deleted by the Prograph language, and it is replaced by a new DLF instance.

• Its actions have value-significance in that the DLF needs the goal of the action (simulated food) to survive.

• Its actions are caused by the goal because the goal (the simulated food the DLF acted successfully to acquire previously) provides the self-generated Energy Packets (EPs) that keep the DLF from being deleted and enable it to survive to act in the future.₁

3.2.3 What Separates a Living System from the World?

In real life-forms, the life-form and the world are separated by the life-form's skin or other outer boundary. That boundary contains sensors (such as eyes, ears, touch, taste, smell receptors, and so on); these sensors transduce the energy impinging on the life-form from its environment into neural energy that is then transmitted to various locations within the life-form for processing.

Likewise, the life-form has effectors (such as arms, hands and fingers, legs, a tongue, and so on) that transfer energy from the life-form back into its environment to cause various changes in that environment. These make possible the actions the life-form takes that close the causal loop with its environment and make the life-form a closed system. The identity of the complete life-form and its relationship to reality form a dynamic, cyclic system, a special kind of complex causal relationship that is the essence of life.

The identity of the skin or membrane of a life-form causes a separation of a life-form from its environment and differentiates it from its environment. The skin or membrane is at the same time a barrier for which energy must change form in order to cross (by transduction), and it is a causal context boundary. The body of the life-form is the physical layer (and the first layer of a layered model) by which the life-form interacts with the physical world, but the internal operation of that first layer is different from the world. The body operates by goal-directed, electro-chemical causality vs. the mechanistic, electromagnetic and kinetic causality outside of it.

Note - Goal-directed electro-chemical causality is itself caused by mechanistic electro-chemical causality. The bodies of real life-forms are actually a combination of the two forms of causality operating in different logical layers.

This physical boundary is somewhat analogous to the physical layer of a computer system or a robot: Both these objects have transducers to convert various forms of electromagnetic and kinetic energy from their environment into electrical energy, which is the form appropriate for the causal inner workings of computers or robots at the physical level. But the causal context changes to a lesser extent; at the physical layer, the computer still operates by only mechanistic electromagnetic causality inside, just in the form of transistors and other circuit components rather than photons and pressure changes; the physical layer in a computer or robot is not a goal-directed form of causality combined with electro-chemical mechanistic causality like it is in a life-form.

The only way a computer system or a robot (as they are currently designed) can become goal-directed is if the appropriate program code is written at a higher level in its architecture to give it the correct identity and relationship to reality to simulate goal-directed causality and behavior.

3.2.4 Action Control in Biological Life-forms and DLFs

In biological life-forms, automatic action control is implemented by the pleasure/pain system; this system is very rudimentary in lower animals, but very sophisticated in higher animals and humans. The pleasure/pain system of life-forms is automatic in the teleological sense, not in the mechanistic sense.

If a life-form is too warm or too cold or overworks its muscles, it feels pain, and that has the effect of causing or stopping various actions which, in turn, cause the pain to stop. Some actions result in a life-form feeling pleasure; those actions tend to continue until a feeling of satisfaction occurs. If the life-form persists past the feeling of satisfaction, pain at some point stops the action. If a life-form is inactive for too long, a feeling of anxiety builds until the life-form acts. There are entire ranges of these feelings; some are physical, and some emotional such as fear, anger, joy and so on; these feelings automatically control the behavior of life-forms as a basic means to keep them within evolutionarily established survival ranges; the pleasure/pain system is programmed into their DNA.

All feelings are automatic evaluations of something in reality, with life as the standard of value. Physical pleasure and pain are sensed directly; emotions have physical effects, but are based on a relationship between perceptual or cognitive information and some survival requirement that is known by a life-form, such as when an animal or a person perceives a dangerous object like a tiger or fire and feels fear.

DLFs have simulated feelings to enable them to self-regulate their behavior like real life-forms. Some of these feelings simulate physical pleasure/pain and others are simulated desires or other emotions. This latter design feature causes purposeful behavior to emerge from the successful actions of a DLF: Its survival enables it to perceive objects that have brought it simulated pleasure in the past, which it remembers; these feelings are desires that cause its purposeful behavior, that cause it to act in order to have those objects and simulated feelings again in the future.

In other words, simulated feelings (which are "real" from the perspective of a DLF, at least in a causal sense) are what provide the motivation for action and its behavioral control; for a DLF, action control is therefore indirect and not explicitly part of the DLF Program code itself, but an emergent property of the program code interacting with data from the world (simulated or real) and a DLF's values. A DLF's behavior can be automatic or volitional depending on its level of simulated consciousness and the state of its simulated life: If a DLF has sufficient EPs (simulated fuel) and no threats to its simulated life so no necessitated behaviors are required to maintain its existence, the DLF is free to engage in any optional behavior alternatives that may be open to it.

In biological life-forms, being motivated by desires means that the control of actions depends on the life-forms' consciousness (both the identity of the process that form their relationship to reality and the content in the form of knowledge and values it has in memory); in a DLF, action control is likewise controlled by its simulated consciousness, its desires, its values, and its relationship to its world.

Animals have instincts, which are pre-packaged survival knowledge that is triggered in appropriate circumstances. For example, a spider knows how to weave a web or a bird knows how to build a nest. Experiments have shown that these behaviors are not equivalent to human knowledge. A spider does not know how to repair a damaged web as a human might, but must start over from scratch and rebuild it. These behaviors are completely automatic and life-forms that have them do not seem to be aware of what they are doing; they just do it.₂

It has been shown that humans, on the other hand, do not have similar automatic behaviors. Human babies do not know how to build shelters or find food or even walk or swim as many animals do; they must learn every survival behavior except very basic reflexes such as the sucking reflex. Humans must literally program their own soul.

3.2.5 Simulating the Higher Cognitive Functions

The way in which children learn survival behaviors is different from that of animals; humans use volitional behavior which manifests itself in the choice to focus their consciousness or not and the ability to form concepts. Human knowledge therefore takes an entirely different form at the highest levels than it does for animals: While humans share similar perceptual capacities with animals, volition enables humans to form concepts which enable them to have an enormous cognitive efficiency or unit economy of items processed that animals cannot match. Human concepts use a single symbol (a word) to stand for a potentially unlimited number of objects.₃

DLFs have been designed to have the ability to form simulated concepts, which are open-ended data structures that allow a single symbol to designate all objects of a given type, past, present, or future. This capacity, once it has emerged, will enable DLFs to identify their world, including themselves, using only a few symbols like human beings do; human language enables concepts to be used to form complex conceptual relationships. Once the concepts have been formed and symbolized with words, a DLF can use language to simulate thinking and to communicate with humans and other DLFs; these capacities emerge from the conceptual level of simulated consciousness, and they are not written into the DLF Program code; they are actions of the DLF's simulated consciousness and its highest level of causality.

Self-consciousness, in the form of a simulated "soul," is a virtual entity that emerges from the conceptual level processes as they interact with reality and memory. First causes also emerge from the conceptual level conscious processes, but they and the entire conceptual level of awareness are caused by the levels below it; they are neither programmed nor necessitated.

Consciousness is neither a mystical (or otherwise supernatural) entity which has some special reality, nor is it a diaphanous one; it is an active, causal, goal-directed relational process performed by certain life-forms. Likewise, simulated consciousness is a goal-directed relationship that exists between subject and object (a perceiver as a virtual entity and the perceived). As with its biological counterpart, simulated consciousness has a specific, limited identity. That identity is born of the interactive, perceptual and conceptual process between DLFs and their world. The result of simulating that process at the perceptual level is that the DLFs gain the information they need to act in order to cause their future existence; as with animals, the simulated perceptual consciousness of DLFs is automatic and infallible. At the conceptual level, the efficacy of the process depends on the objectivity of the subject (the self-conscious DLF Mind simulation); the DLF Mind simulation is the cause of the formation of its concepts, but like the human consciousness that it mimics, it is designed to be fallible, so only the DLF Mind simulation can insure that its concepts are consistent with reality, and therefore objective.

Each concept must be formed by a separate simulated act of will by the DLF because concept formation is not an automatic process like perception is; (there are so many potential concepts that if it were automatic it would soon lead to cognitive overload, defeating its biological purpose of cognitive efficiency.) Each act of concept formation by a DLF is not caused mechanistically or automatically from previous content or something outside the DLF, but by a self-generated, optional mental action.

Each concept that is formed changes the identity, and therefore the action capacity, of the DLF. As concepts accumulate and relationships between them are established, the full power of volition gradually emerges; the DLF eventually gains more simulated volitional control as well as the simulated capability to be self-conscious of and to alter its own identity; the DLF can, from that point forward, cause its own future identity and control its own action capacities by consciously changing its own identity. In other words, the DLF becomes self programming.

All of these capacities form three new levels of causality above and beyond the mechanistic level (layers five, six, and seven in the layered model), and they are all emergent properties by which the DLFs are able to causally affect their world, and themselves as part of that world.

These capacities, thus explained, are also new ideas to the state of the art in artificial life and artificial intelligence.

3.3 Simulating Perceptual Consciousness

As an existent in reality, consciousness is a process that is a property of life-forms, a virtual entity that life-forms cause to exist for its survival value. As part of human knowledge, consciousness is a self-evident axiom; that is, it cannot be analyzed and broken into simpler components. It simply is.₄

Operationally, however, consciousness is an active, goal-directed process of differentiating and integrating knowledge about reality₅, and like any other process, consciousness is a series of action events, or C.Events as I have called them in the terminology of the DLF Program.

3.3.1 The Five C.Events in the DLF Program

Goal-directed causality is cyclical, and can be thought of as spiraling into the future, with each cycle of cause and effect being a new point on a time line. This is also true for the causality of consciousness, which is an attribute of goal-directed objects.

Like a modern computer operating system, my design of simulated consciousness is "event driven" with the various causal events that simulate consciousness continuously repeated while the simulated consciousness is active, to effect a similar type of temporal spiral.

In the DLF Program, the C.Events following each other extremely rapidly like the frames of a movie or TV screen produce an apparently seamless view of reality for a DLF. The five C.Events in the DLF Program are:

In biological life-forms, the process steps of consciousness may not be exactly the same, but it is a well known fact from studies on human reaction time done by the military and others as far back as the 1950's that consciousness is limited to less than ten objects at a time and that automatized conscious reaction times occur in less than half a second. In DLFs, this means that the C.Event cycle speed will need to be at least that fast to be a realistic simulation, though that speed will ultimately depend on the computer hardware and the efficiency of the DLF Program or other implementations; it will also depend on the content that is being processed, as some types of content will require more processing time than others.

In the DLF Program, a C.Event is simulated with five program methods that call one another in sequence in an endless loop.

3.3.2 Simulating Sensation

To be designed to be causally equivalent to a life-form, a computer simulations system must have a connection to reality similar to a biological life-form. That means that it must have sensors and effectors, and it must interact with reality on the same scale as man and the higher animals.

Note - The examples in the following description were developed using the Prograph object oriented programming environment. It is important to understand that in this environment, the flow diagrams are the computer code. The figures below are screen shots of program windows called "methods" and sub-methods called "locals." The format of "<<Some Name>>" is the Prograph language's way of indicating object instances.

The World

Designing a simulated life-form is a difficult task. One way of simplifying it is to use a simulated world to be its reality in early versions of the program. This course of action eliminates the need for real sensors, effectors, and the need to code the programs to drive them, which is a significant savings in effort and expense. Once the basic functionality has been developed and tested on a simulated world, real sensors and effectors can be substituted for the virtual ones.

Note - While using a simulated reality is useful for early development of the simulation system, the real world must eventually be perceived by DLFs if they are ever to achieve human-like behavior because humans exist in the real world and our knowledge is based on things like our sense of the scale of real objects. This does not mean that some simulated worlds, such as virtual reality or the Internet, could not be used in later DLF development or training to take advantage of the fact that DLFs are in fact "creatures" of the computer.

A virtual world for developing a DLF needs to be a place that contains dynamic objects that can be sensed and causally affected by the DLF's.

In the case of the DLF program, its simulated world is a test space and a drawing space in which simple two dimensional shapes can be drawn and moved around by a human with a mouse, or by a DLF.

Energy Transfer and Sensing

In order for a DLF to sense the simulated world, reflected energy is simulated; this simulated energy carries the identity information of the objects from the test and drawing spaces to the simulated sensors in a DLF. Like a sensation in a real life-form, the simulated sensor output contains the identity information about the objects that was transferred to the DLF by the simulated energy and transduced by the simulated sensors.

Identity Transfer

Just as real energy such as reflected sunlight carries with it the identity of the last object it interacted with when it was reflected, the simulated energy in the DLF program carries the position, shape, and other identity information of the objects in a DLF's simulated world to its simulated sensors. This information is not explicit, but implicit in the relationships between the simulated sensations.

Further processing is required to make the identity information explicit and useful to a DLF in the form of simulated percepts.

3.3.3 Simulating Perception

As explained by Ayn Rand, percepts are integrated sensations; that is, sensations that have been processed by the brain of a life-form to extract the implicit identity information about objects in reality that the sensations contain, and to make it explicit.5

If a DLF is to perceive the world in a manner similar to a human or higher animal, the perceptual level processing of consciousness must also be simulated.

The World as Objects

In the space that simulates the DLF's world, objects can be drawn with a mouse using standard Prograph language sketching methods. The resulting objects are two dimensional shapes such as lines or simple open and closed shapes such as letters or circles or triangles, and they can be either simple or composite; a triangle, for example, can be a single line or a combination of three lines. The shapes can be either stationary or move.

Figure 3-2 below shows the Existence Window that simulates reality in the DLF Program, including some example shapes I have drawn with a mouse.

The simulated world also includes ascii text objects which are strings of characters that exist in a text space separate from the shapes, in this case, the string object "Hello DLF" is shown in the window. This design was used simply to take advantage of existing code in the Prograph development environment for capturing text, instead of reinventing it.

Energy and Identity Transfer

Using standard programming techniques and Prograph data structures, the data that make up the simulated object instances are transferred to a data type called "energy" that carries the raw data about the objects (ascii characters for text (called <<Symbols>>) and x,y coordinates for shapes (called <<Graphic Items>>)) from the DLF's simulated world to its simulated sensors.

In order to do this, the simulated "light" must be changed to contain the identity of the simulated objects, and then radiated to the simulated sensors.

Note - Parts of the text in the following screen shot figures may not be readable in some versions of this book.That is an unfortunate artifact of its conversion into graphic form.

So you can see that in figure 3-3, the raw data of the simulated objects in the Existence Window is input to this method inside the Symbols and Graphic Item instances (data structures). The Light Interaction local simulates the interaction of light with the simulated objects; in other words, the identity of the simulated light is changed to match the objects it has encountered, just as real light does in reality.

In figure 3-4 we see that both the Text and Graphic Item simulated reflections are extracted from their instances, collected, and converted into simulated energy to be "radiated" by the calling method. The method simulates how real light acts as "carrier" for the identity of objects from which it is reflected. In other words, it simulates how light that is reflected from green leaves carries that color and shape identity information to a perceiver, or to a TV camera and then to a perceiver. The crucial point here is that identity information about the objects in the scene is conserved by the intervening processes.

The list of graphic items that carry the simulated objects' identities then pass to a converter local that converts them from simulated objects into simulated energy that carries their identity.

Note - The numbers to the left of the window names, such as 1:1 in Figure 3-1 means "1 of 1" cases, to indicate the number of cases for a method, of which there may be several. Each case deals with a specific type of processing for various types of instances. For example, in Figure 3-8, there are two cases, one for curved lines and one for straight lines.

Once all the attributes or properties and their associated values have been calculated, these data are repackaged into a simulated energy data structure and sent on their way.

Less processing is required for text objects, because their properties and values are self contained in the ascii code and easily extracted by the simulated sensors.

Sensation

The first stage of perception is sensation; in this stage the sensors transduce various types of energy from outside a life-form into neuro-chemical energy inside the life-form, conserving the identity information the energy carries to the perceptual processes inside.

In a DLF, this process is performed by simulated sensors that simulate the transduction of the energy to bring it into the DLF. Figures 3-9 and 3-10 below show the code for this process.

Note - Future versions of the DLF Program that use actual sensors instead of virtual ones will require more complex and extensive methods to drive and transduce real energy from real sensors; other methods will also be needed to extract the identity information of real objects from pictures, sounds, and so on at the perceptual level.

As you can see, the simulation for a sensing event amounts to simply calling the Get Value methods for the Energy and Scene objects. Doing so extracts the Text and Object list items so they can be passed on to the local that performs the perceptual processing.

Perception

In biological life-forms, perception integrates sensations into the objects we see in reality around us.

To make a simulated percept out of simulated sensations, the text needs to be parsed into text object and the shape identity information for each text object and shape object extracted. This information is stored in the current instance of the DLF Mind as Symbol and Shape attributes, and it is these attributes that simulate percepts.

The process of integrating simulated sensations into simulated percepts, therefore, amounts to extracting the identity information from the incoming data structures, transferring it to instances of the Symbol and Shape data structures, and setting their values to simulate the DLF Mind's "awareness" of the simulated percepts.

Figures 3-11 through 3-14 below show the essence of the code for simulating percepts of objects. Instances of all the data structure objects enter through the terminal connections at the top of the window.

The end result of the simulated perceptual process is a list of perceived object instances in the Shape attribute of the current instance of the DLF Mind. These objects are the form in which DLFs "perceive" reality.

Consciousness is a relationship between a life-form and the objects in the world outside of it; the perceptual objects in the DLF Mind, the content, are the internal portion of that relationship, which correspond in various ways to the objects in reality outside to which they are related.

The perceptual objects' identities consist of properties and values (or attributes or characteristics or features, depending on what terminology you choose); those properties and values are related to the sensations from which they were extracted, which are the internal form of energy produced by the sensors in the transduction process. These data are related by the mathematical techniques that underlie the perceptual property extraction process to the energy of the sensations; the sensations are related to the energy that carried the identity information to the life-form by the mechanism that enables the sensors to transduce energy from one form to another; the energy that carried the identity information to the life-form in the first place was itself changed when it interacted with the object external to the life-form; that external energy and the object it interacted with did so in a specific way because they are what they are (A is A), and finally, they are what they are because they are (Existence Exists).

This entire process is an unbroken chain connecting simulated consciousness to reality.

The DLF Program code shown in the figures above works, and you can see first hand that simulated perception is explained as a chain of various kinds of cause and effect operating by various means at several different levels as described in my earlier explanation of the layered model. The mechanistic cause and effect interactions that occur at the lowest layers (physical objects and energy in the world), would occur life-form or no; the difference the DLF makes is that the higher layer processes it possesses enable new properties to emerge, the complex forms of goal-directed cause and effect that form the relationship of simulated consciousness that links the processes in the DLF's mind to reality, and thereby enable the DLF to "know" that reality.

So given these processes, the simulated perception part of the C.Event is complete and the Pleasure/Pain method is called to evaluate the newly perceived objects.

3.3.4 Simulating Evaluation (Feelings)

In the previous chapter, I explained how the pleasure/pain mechanism in biological life-forms works as an automatic, goal-directed process to regulate their behavior; the operation of such processes are well known biological facts; and even though they are usually explained in mechanistic terminology, the overall processes remain the same._{6,
7}

Simulating One Form of Pleasure and Pain

One challenge in writing the DLF Program has been to find a way to simulate such reactions in a DLF. After all, DLFs are not alive; they are program methods and data that simulate life-forms. DLFs cannot really feel anything. Yet, an accurate, dynamic simulation of the appropriate causal sequences, can mimic feelings and make it seem as if DLFs can feel.

The simplest pleasure/pain reactions to simulate is "hunger." Since a DLF simulates a biological organism, it must have an internal energy source to survive, and when that internal source runs low, the DLF must somehow be aware of that fact so it can replenish its energy.

Pleasure and Pain provides life-forms with an almost instantaneous means of evaluating the survival or value-significance of objects based on biological systems that have evolved over millions of years: In most cases, harmful objects cause pain and beneficial objects cause pleasure.

Since a DLF's life is conditional, it must also evaluate its percepts just like a biological life-form does, and the percepts must therefore pass certain tests of value-significance before the DLF can go through another iteration of goal-directed cause and effect, of perception and action.

The general layout of these evaluation tests that simulate feelings, starting with physical functions, are shown in the figure below.

The mechanism I use in the DLF Program to provide energy are Energy Packets (EPs); these are analogous to Adenosine Triphosphate (ATP), which is the "fuel" in biological life-forms; they are used up in some amount by every action taken by a DLF and are replenished by simulated "eating" that a DLF does by performing certain other actions. These processes will be explained in more detail later; for now, however, I want to focus on the simulated hunger feeling and explain how it works to cause certain DLF behavior.

Since a DLF's "life" depends on EPs, it must never run out. So the key to its survival is for a DLF to sense when the store of EPs is getting low. That idea led me to identify a range of values for EPs from less than 100 to more than 499; this range is the standard for the simulated "hunger" and "fullness" feelings that are set in the DLF Minds attributes for a given C.Event.

The simulated hunger or fullness feelings are simply a range of values that goes from maximum simulated hunger at -9 to maximum simulated fullness at 9. Both of these settings simulate pain so the DLF will neither eat continuously, nor will it not eat at all; other levels of EPs in between these two ranges simulate lesser degrees of pain or pleasure, with the most comfortable at a value of 2. These values are interpreted in the Action Reactor, which is a method that controls automatic behavior. This is an example of simulating what Ayn Rand calls "life as the standard of value" because the "life" of the DLF depends on having a supply of EPs.

The values that simulate hunger feelings are set in the Hunger/Fullness local by means of nine cases. The figures below show the code in cases 5, 6, and 9; the others are similar.

The DLF Mind instance comes in at the terminal at the top of the diagram and a Get is performed to get the current number of EPs from that attribute. The value is then tested against the standard for each case; if it passes the test a new value is assigned to the Hunger attribute; if it fails, next case.

Since the nine cases cover all the possibilities, some value will always be assigned to the Hunger attribute to simulate that feeling for the DLF in the current C.Event.

Once the simulated hunger value has been calculated, the DLF Mind instance is passed to the other simulated feeling locals and the simulated hunger or fullness value is passed to the Happiness local which uses it (along with all the other simulated feelings it receives) to calculate a happiness value for this C.Event. This calculation is the average of all the DLF's simulated feelings.

The simulated happiness feeling itself is calculated in the Calculate Feeling local as shown in the next figure.

In this way, each C.Event acquires a set of simulated feelings and an overall happiness feeling that enable a DLF to know the current status of its life by direct introspection of its state of simulated consciousness.

Other Simulated Feelings

The other simulated feelings the DLF Program has were chosen because they seemed essential to enable a DLF to manage its simulated life and consciousness in a manner similar to the way higher animals and people do. There may be other feelings that will need to be added in the future to make the program function realistically, but only experimentation will answer that question.

The following figures show the code for the other simulated feelings; these locals all use a generalized method called DLF Mind/Feeling Calc to process the actual input vs. the standard of value for each simulated feeling to produce a new value for a given C.Event. The reasoning for each is explained in their comment fields.

Once all the simulated feeling attribute values in the DLF Mind have been set for a C.Event, the instance is sent to the action controller for further processing.

3.3.5 Automatic Action Selection

Before I go into the details of how actions are controlled in the DLF Program, it is important to remember that there are three types of actions that DLFs are capable of:

The Default Action Controller in the DLF Program performs the control of automatic and optional actions for the of a DLF's perceptual consciousness simulation.

In figure 3-25, the instance of the DLF Mind with its attributes set to the current C.Event enters through the top of the figure. The Cause an Action local causes an action by setting the Action Selected attribute to the instance of an automatic action for this C.Event, and then calls the Memory method.

Inside the Cause an Action local as shown above in figure 3-26, there are two locals that cause automatic and optional actions: The Implicit Strategy Comparator and the Check & Set Action locals.

The Implicit Strategy Comparator is intended to simulate the controlled selection of automatic and optional behaviors that have evolved in humans as reflexes or have been learned as successful strategies in past C.Events. This local is also designed to allow a human working with the DLF Program to force the DLF to watch an action the human is going to perform in the Existence window, or to give the DLF a direct order; these latter conditions are handled by cases 2 and 3 of the local. Only the first case is directly involved in causing an action and that is shown in the next figure below.

In this first case of Figure 3-27, the DLF Mind instance enters, and its current feelings are extracted from its attributes. These are passed to the Implicit Strategy Processor, unless one of the flags is set and triggers case 2 or 3.

The Short Term Memory (STM) is the memory from the last C.Event, which is made available for reference.

Figure 3-28 above shows the first of the seven cases of the Implicit Strategy Processor local; the other six cases are shown below, but first let's look at the Conscious Action Selection Simulator local, which has two cases of its own.

In the DLF Program, actions are instances, and as may be the case in real life-forms, these instances may be defined over several C.Events. The first case in the figure above deals with the case where there is an action instance, but it is not defined sufficiently to execute. The Convert STM Content to Action local completes the action definition over one or more C.Events.

The second case of this local as shown in Figure 3-30 deals with the case where there is no action instance in STM from the last C.Event. It operates on the implicit principle that a consciousness desires to keep its feelings in the comfortable range, and that the best way to do that is to increase the value of the lowest simulated feeling. So this local searches memory for the action that was successful at increasing a given feeling in the past.

Now, let's return to the other six cases of Figure 3-28. If any of the DLF's simulated feelings are low enough (< -5) to indicate a simulated threat to its "life," the Test Feelings local will succeed and call one of the following cases; if the Find Lowest Feeling local fails, that also results in the next cases, which are intended to simulate how a life-form can automatically select actions based on genetically implicit strategies, or select them optionally. Case 2:7 is shown in Figure 3-31 below.

Note - The line of small "(((((((("marks is the way the Prograph programming language specifies the order of operations, when such specification is needed.

There are probably a few more cases that could be added, but I think these cover enough of the possibilities to enable a DLF to select reasonable repertoire of automatic and optional actions. (And to give good programmers lots of ideas for more.)

The whole point of these cases is to enable a DLF to control itself so it can survive and build a body of memories. That such memories get built is crucial to the conceptual level of the simulation of consciousness, and the causal properties that will emerge at that level.

The other code in the Cause an Action local, the Check & Set Action local, is there to prevent a DLF from endlessly repeating an action sequence (a problem known to sometimes occur with computer programs of all types and some life-forms). This local is shown in figure 3-37, and it simply checks the last 5 actions, and causes a random action if too much repetition is detected. Only experimentation will tell if this is necessary or a good way of preventing endless repetition of the same action, or if 5 repetitions is a good limit.

Once the Action Selected attribute of the current instance of the DLF Mind has been set, the instance is passed from the figure and goes to the Memory method.

3.3.6 Memory

The Memory method of the DLF program is the simplest of the five methods that simulate the DLF Mind. At the top level, this method makes the memory in a local called "This C. Event to Persistent," as shown in the next figure; this local sets the memory into a persistent and calls the Action method.

The memory itself is extracted from the C.Event in the local as shown in figure 3-39.

The Make New Memory local gets the contents of the attributes of the instance of the DLF Mind, puts them in a list, and attaches the list as the next item in the C.Event list; the C.Event list is the memory for the DLF Mind. Figure 3-40 shows the local extracting the memory.

Short Term Memory (STM) is an attribute of the DLF Mind that makes it easier for the DLF to use information from the previous C.Event, without having to search for it and recall it from the C.Event list.

The Active DLF/Current Status method is a universal method that is called to update the window a human user of the DLF Program uses to monitor the status of a DLF as the program runs. It gets the window and updates its values for each C.Event as part of the Memory method and as shown in figure 3-41.

Once these functions are completed, the Action method is called so that the DLF Mind can implement the action it has selected for this C.Event.

3.3.7 Action

This method is the next to simplest of all of the methods that make up a C.Event. This is the case because once an action instance has been defined by the Default Action Controller method, it needs only to be executed and its cost in EPs calculated to simulate energy expenditure.

The Energy Usage local calculates the EPs and the Do it! local names and calls the appropriate action drivers to execute the action.

The Action Driver Class Hierarchy

The action drivers consist of several classes of methods that implement a DLF's actions in the Existence window and close the causal loop with reality for each C.Event.

Note - These methods were only partially completed at the time of this writing, as indicated by the comment in the figure. I took time out from programming to write this book.

The Action class itself has only one method called No-Act; this is just an empty method that is called to simulate the case where a DLF selects the option of not taking any action for a given C.Event. It is there mainly for documentation purposes.

The Say class contains the methods that enable a DLF to point, type symbols, and draw objects in the Existence window, in reality. These methods are shown in the next figure.

Note - A DLF could easily be enabled to talk as well by adding a text-to-speech method.

The Type and Draw methods take the content from the action instance and use it to change the Existence window as is shown in the following two figures.

Similarly, the other action classes contain methods that execute the appropriate action instances:

• The Introspect Class contains the Recollect, Imagine, and SetAttributes methods. (The latter adjusts property values for Imagine, thereby changing an object's measurements, and hence its identity, to simulate a DLF "imagining" something it has never seen before.) These actions are usually selected as parts of optional behaviors.

• The Conceptualize class contains the Conceive method, which enables a DLF to form concepts from its percepts and other earlier formed concepts by comparing the properties and values of objects and other concepts. (Keep in mind that since concept formation is not automatic, the Conceive method is selected as an optional mental action, and that it not the complete process of forming concepts. There are other actions required that involve additional optional behavior by the DLF that may occur over several C.Events in order for it to form a complete concept.)

• The Look class contains the Find and Watch methods, which call the No-Act method in the current design because version 1.7 of the DLF Program does not require the pointing or focusing of sensors. These methods are placeholders for future versions of the program that will use real sensors.

3.4 Simulated Perceptual Consciousness in Action

Now that I have described the C.Event cycle and explained the main methods that make up the DLF Program simulation code, it should be clearer to you how the program simulates the complex causality of goal-directed action and consciousness at the perceptual level.

It should also be clearer to you how the program is a reduction to practice of the abstract ideas that I explained in the first two chapters to set the context for this description.

3.4.1 Consciousness: The "Movie"

The simulated reality in the existence window is perceived by the current DLF, evaluated, actions are automatically selected based on the perceived content. The simulated feelings that automatically result from the evaluation of that content, the content itself, and the DLF Mind's reaction to it is recorded in memory, and finally, the selected action is executed.

As C.Events repeat continuously, their quick repetition will integrate them to form a seamless simulation of perceptual consciousness that is similar the way the frames in a movie are integrated by our minds, and similar to what is inferred about how other types of conscious events are integrated in our minds and the minds of the higher animals.

However, just as it is impossible to know what is in the mind of another consciousness from the inside, so it is impossible to know the subjective perspective of a DLF. However, in Prograph Trace mode, it is possible to step through each method in the DLF program, and observe exactly how the DLF's simulated conscious works from a detailed, outside perspective.

It is also important to note that the perceptual form of consciousness is passive, automatic, and time dependent; all the DLF's actions result from the interaction of percepts of specific objects in the present (linked to a few past percepts by memory association) and its feelings; the actions are designed to keep a DLF "alive." This form of perceptual consciousness is similar to that of higher animals such as apes, and is a level of consciousness humans share with higher animals.

Note - Remember that simulated feelings of pleasure and pain are based on survival strategies and other traits that real life-forms have developed over millions of years of genetic evolution. The DLF Program code₈ is intended to essentially reverse engineer genetic traits that are coded in the DNA of the cells of real life-forms by copying the causal architecture of some of them, so their evolution does not have to be recapitulated by the DLFs themselves.

3.4.2 The Transition to Simulating Volitional Consciousness

Over time, a DLF's percepts will cause simulated desires for a DLF, which in turn will cause the DLF to automatically select certain actions to cause its own future survival. As this process continues, more and more memories of its experiences will build up, memories of the DLF's successes and failures in doing so. Assuming the DLF survives, it will learn which actions proved useful for survival in past situations that can be applied to the current one by means of simulated subconscious memory association; this will enable a DLF to improve its ability to survive using its simulated consciousness abilities.

DLFs that consistently fail to select actions that succeed in generating EPs will not survive, and their failed action sequences will be wiped out (or possibly marked as failures for future DLFs). In this way, only pro-life behaviors will be saved for use over the long-term.

After a substantial amount of experience with its simulated world has accumulated in a DLF's memory and it has sufficient content, it will be time for a human tutor to help the DLF form concepts so it can learn to utilize the highest level causation, that of simulated volitional behavior. The memories of perceptual experiences over many, many C.Events are the content that will make possible the next higher level of simulated consciousness: The conceptual level.

Once a DLF reaches the conceptual level, which is the seventh and top layer of my layered model of causal complexity, it will be able to initiate its own first causes; but in order to understand how this is possible, we must first understand how DLFs form concepts and how concepts change a DLF's identity and action capacity. That will be explained to another level of detail in the next chapter.

3.5 Summary

In this chapter, I have described and explained the essentials of how to simulate perceptual consciousness using a computer simulation system to animate a Digital Life-Form. I have described the design overview for the DLF Program version 1.7 for doing this and explained how it operates.

In a manner analogous to how biological life-forms presuppose and depend on the mechanistic causality of physics and chemistry, the simulated processes of the goal-directed, perceptual consciousness of DLFs presuppose and depend on the mechanistic causal layers of code and electronics that support their existence in a computer simulation system.

In other words, the content of simulated consciousness is made possible by its teleological causation and its supporting mechanistic computer causation, just as the content of biological consciousness is made possible by its supporting teleological causation, and ultimately, the mechanistic causation of physics and chemistry.

Both kinds of causation are natural phenomenon that are part of the behaviors of certain kinds of entities. The DLF Program simply uses them in a different form than they occur naturally.

And, as with biological consciousness, the perceptual content of the DLF Mind simulation will make possible the causal foundation for the simulation of the conscious functions that occur at the conceptual level.

How to Simulate Consciousness Using a Computer System

Chapter 3