চিন্তন: The thought particle

Given an absolute reductionist approach to consciousness, what does it ultimately boil down to?

Our species has finally reached that juncture in evolution where we can sit down and begin to contemplate on the matter of contemplation itself. We know a little about ourselves. We known something about the physical world. A little meta analysis regarding the workings of our mind wont be out of place.

Of all things, we are the first species to have created, of our own, a rudimentary form of intelligence in the form of information processing machines. While some might argue that computers might not really be that different from the mixer grinder or the washing machine, similar argument applies to any life forms.

Let me emphasize by what I mean by that statement; a very common bottleneck in programming a computer is to get stuck in an ‘infinite loop’, such as:

while (0 < 1)
{
 print "this program never ends
        since there is nothing to prevent 0 being less than 1"
}

(I am using Java for demonstration purposes only; a similar program could be written with any programming language, or pseudocode)

It is because of this reason that all loops need a condition, such that after a finite number of traversals of the loop, the condition is broken and the loop exits

x = 0;
while (x < 10)
{
 print x; // Prints 0, 1, 2 to 9 in succession, stops when x is 10
 x = x + 1;
}

Imagine, if you will, how your friend at the next cubicle would react to such a problem. Except maybe Sisyphus, humans are not generally interested in futile loops of labor. After a few iterations of the loop, your friend will eventually give up the task — which is worth noting, because it’s one of the things that make us ‘living organisms’. In the absence of the ‘safety mechanisms’ against infinite loops, the whole of our processing power would be taken down by the continued iterations of a single loop, just as a computer would succumb. An infinite loop, handled a free reign over the brain, would eventually consume the whole of it and their would be no processing power left for such menial functions such as breathing and heartbeats. Yes, math can kill you.

A celebrated work of science fiction, the anthology ‘I, Robot’ by Isaac Asimov remains a source of inspiration for how artificial intelligence might actually be modeled — someday. In one of the stories, ‘Runaround’, a robot is shown to be trapped in an infinite loop. Robots are, in the Asimov world, bound by tight rules which prohibit them (1) to harm humans, and obligate them (2) to obey humans and (3) to protect itself except when in conflict with rule (1) or (2). That is, self sacrifice in the interest of the safety of a human, or simply to obey him, is ‘acceptable’ robotic behavior. However, the rules are implemented quantitatively, with a probability associated with both ‘probability of self damage’ and ‘probability of damage to a nearby human’. Near a potentially toxic dump of selenium, the robot calculated both the values to be exactly ‘half’ (50%) and could neither move forward or away from the mine. [1]

“You see how it works, don’t you? There’s some sort of danger centering at the selenium pool. It increases as he approaches, and at a certain distance from it the Rule 3 potential, unusually high to start with, exactly balances the Rule 2 potential, unusually low to start with.”

Donovan rose to his feet in excitement. “And it strikes an equilibrium. I see. Rule 3 drives him back and Rule 2 drives him forward-”

“So he follows a circle around the selenium pool, staying on the locus of all points of potential equilibrium. And unless we do something about it, he’ll stay on that circle forever, giving us the good old runaround.” Then, more thoughtfully: “And that, by the way, is what makes him drunk.”

The underlying theme being that, a machine ‘does what it is taught’; the instruction set may be complex, but a human can still sit down and anticipate every move of a machine (i.e. machines are deterministic systems), given sufficient thought.

Are living creatures deterministic to any degree, that is, given all its state variables in a given state Sn, can we predict its next state Sn+1 ? The crux of the question lies in the word ‘all’, as it is near impossible to list all the variables that determine the state of a creature. But empirical evidence suggests that the ‘does what it is taught to’ principle applies not only to machines but also, to some degree, living creatures. [2]

When the time comes for egg laying, the wasp Sphex builds a burrow for the purpose and seeks out a cricket which she stings in such a way as to paralyze but not kill it. She drags the cricket into the burrow, lays her eggs alongside, closes the burrow, then flies away, never to return. In due course, the eggs hatch and the wasp grubs feed off the paralyzed cricket, which has not decayed, having been kept in the wasp equivalent of a deepfreeze. To the human mind, such an elaborately organized and seemingly purposeful routine conveys a convincing flavor or logic and thoughtfulness-until more details are examined. For example. the wasp’s routine is to bring the paralyzed cricket to the burrow, leave it on the threshold, go inside to see that all is well, emerge, and then drag the cricket in. If the cricket is moved a few inches away while the wasp is inside making her preliminary inspection, the wasp, on emerging from the burrow. will bring the cricket back to the threshold, but not inside, and will then repeat the preparatory procedure of entering the burrow to see that everything is all right. If again the cricket is removed a few inches while the wasp is inside, once again she will move the cricket up to the threshold and reenter the burrow for a final check. The wasp never thinks of pulling the cricket straight in. On one occasion this procedure was repeated forty times, always with the same result.

— Dean Wooldridge, Mechanical man

When you look for it, similar behavior is not rare in our kind. Of course, our dominant cortex allows us to rationalise after a while, and ‘giving up’ is a uniquely cerebral characteristic. No other class of organisms, but those bestowed with a big brain, can anticipate fruitless labor. A bacterium will flagellate towards a chemoattractant for the duration of its brief lifetime, without ever giving a second thought. We, however, will not persist that long; in fact — we give up quite early in the chase. (‘Death of starvation’ is a uniquely vertebrate trait, it seems).

The second argument contrived in favor of the machines is purely physical. Bodily functions, reflexes and metabolism can all be replicated in vitro, sometimes in a better manner than the original. With advent of nanoparticles, the lower limit to the size of thinking machines has been breached. Nothing prevents us now from building an artificial neuron which is more stable, robust, energy efficient and faster than those in our brains.

Except of course, that enigma of ‘conscious thought’. Lets roll.

Levels of abstraction: machines and organisms

A digital computer, or Von Neumann machine, is made of three things — a processor, some memory and connecting cables. (By ‘memory’ I mean random access memory, or the short term memory of a machine. Storage memory comes under peripherals, and is no part of the core machine.)

The fundamental premise of information processing by a machine is to apply a function f(x) to the elements of a set X and produce a resultant function g(x). In a Von Neumann machine, both the function definition f(x) and the set X are stored in the memory as binary instructions. There is no inherent discriminant between instruction and data. The situation is similar to organisation of information in the genome, which too, makes no distinction between ‘data’ (i.e. the actual amino acid sequences stores in exons) and ‘instruction’ (when and how to make it — the introns).

How the processor carries out the instruction set is remarkably intuitive. It goes on stepping over byte after byte, and carries out whatever instructions are therein. Unless specifically instructed to jump back and forth to other locations in the memory, the processor will traverse the entire RAM at a single go.

The Von Neumann machine is made of wires and circuits, which operate in binary. A wire either does or does not have a current. It is a state machine, whose two states are, respectively, denoted by 1 and 0. Notice that the two numerals are used as symbols here; we could have easily used “up”/”down” or “on”/”off”. That we use ‘0’ and ‘1’ is a matter of notational convenience. It has got nothing whatsoever with the numbers zero and one per se.

Thus, the simple instruction of ‘store the value 2 in the location 0x001c’ might be coded in the single byte ‘01101001’. This is machine language, the successor to punched cards. In the very early days of computing, there were people who actually hand coded machine language. While it sounds utterly fantastic, it is not such a good idea as it sounds. Operating on such a low level of abstraction prohibits creative thought. The whole of your mental energy is expended in Boolean algebra, and writing trivial programs become a matter of uninspiring labor. The situation is similar if you had to carry out all of your bodily funcions by conscious will: i.e. how much amylase to release after gulping thta pancake, how many red cells to make today. From a theoretical perspective, such an exercise is possible, but we must be thankful to our autonomic and endocrine systems that we do not have to micro manage such low level details (and can thus instead concentrate on writing this essay).

The pattern followed by our neurons is not too different. A neuron is the combination of many state machines, each of which might be called a synapse. At a given moment, a synapse is either discharging or not, states which can similarly be denoted by 1 and 0. Of course, synapses are not ‘all or none’ machines, thus there would be intermediate states, pre synaptic and post synaptic inhibitors, lateral inhibitors, EPSPs and IPSPs, all of which will sum towards a fractional state of a synapse, a real number between between 0 and 1. But it can be quantified, nevertheless. Synaptic potentials are the lowest level ‘machine language’ or our nervous system.

Now, it is as difficult to add 2 plus 2 with machine language, as it is to express the same thought with synaptic potentials. It is possible, no doubt, but the herculean effort taken would overcome any realistic cost benefit ratio, and evolution to intelligent organisms would not have progressed if our brains did not develop any higher levels of abstraction than synaptic potentials. Indeed, developing higher levels of abstraction is the defining trait of intelligence. [3]

One way in which this gap enters Artificial Intelligence is well illustrated by the progress in knowledge about how to program a computer to play good chess. It used to be thought-in the 1950’s and on into the 1960’s-that the trick to making a machine play well was to make the machine look further ahead into the branching network of possible sequences of play than any chess master can. However, as this goal gradually became attained, the level of computer chess did not have any sudden spurt, and surpass human experts. In fact, a human expert can quite soundly and confidently trounce the best chess programs of this day.

The reason for this had actually been in print for many years. In the 1940’s, the Dutch psychologist Adriaan de Groot made studies of how chess novices and chess masters perceive a chess situation. Put in their starkest terms, his results imply that chess masters perceive the distribution of pieces in chunks. There is a higher-level description of the board than the straightforward “white pawn on K5, black rook on Q6” type of description, and the master somehow produces such a mental image of the board. This was proven by the high speed with which a master could reproduce an actual position taken from a game, compared with the novice’s plodding reconstruction of the position, after both of them had had five-second glances at the board. Highly revealing was the fact that masters’ mistakes involved placing whole groups of pieces in the wrong place, which left the game strategically almost the same, but to a novice’s eyes, not at all the same. The clincher was to do the same experiment but with pieces ran- domly assigned to the squares on the board, instead of copied from actual games. The masters were found to be simply no better than the novices in reconstructing such random boards.

The conclusion is that in normal chess play, certain types of situation recur-certain patterns-and it is to those high-level patterns that the master is sensitive. He thinks on a different level from the novice; his set of concepts is different. Nearly everyone is surprised to find out that in actual play, a master rarely looks ahead any further than a novice does-and moreover, a master usually examines only a handful of possible moves! The trick is that his mode of perceiving the board is like a filter: he literally does not see bad moves when he looks at a chess situation-no more than chess amateurs see illegal moves when they look at a chess situation. Anyone who has played even a little chess has organized his perception so that diagonal rook-moves, forward captures by pawns, and so forth, are never brought to mind. Similarly, master-level players have built up higher levels of organization in the way they see the board; consequently, to them, bad moves are as unlikely to come to mind as illegal moves are to most people.

This might be called implicit pruning of the giant branching tree of possibilities. By contrast, explicit pruning would involve thinking of a move, and after super- ficial examination, deciding not to pursue examining it any further. The distinction can apply just as well to other intellectual activities- for instance, doing mathematics. A gifted mathematician doesn’t usually think up and tryout all sorts of false pathways to the desired theorem, as less gifted people might do; rather, he just “smells” the promising paths, and takes them immediately. Computer chess programs which rely’on looking ahead have not been taught to think on a higher level; the strategy has just been to use brute force look-ahead, hoping to crush all types of opposition. But it has not worked. Perhaps someday, a look-ahead program with enough brute force will indeed overcome the best human players-but that will be a small intellectual gain, compared to the revelation that intelligence depends crucially on the ability to create high-level descriptions of complex arrays, such as chess boards, television screens, printed pages, or paintings.

— Douglas R HofstadterGodel Escher Bach

In the Von Neumann machine, the next level of abstraction is known as the ‘assembly language’, which is a minimal set of human readable instructions, such as ‘mov’, which puts a value into a memory slot, and ‘push’/ ‘pop’ for input/output onto a stack of memory. A comparable abstraction in our brain might be the whole neuron, as the summation of input/ output of all its synapses. But even this instruction set is also quite low level, and present day neurology does not necessarily speak in terms of individual neurons, but of ganglia, areas, long tracts and short fascicles. This highest level of abstraction is represented by modern programming languages, which are quite human readable and — with a little effort — comprehensible by everybody. The following shows a code snippet in C and its corresponding translation to assembly language.

x = 3; /* Set x to 3 */
x = x+4; /* Now x is 7 */

This translates to the assembly as

push   %rbp                // Push one slot down in the memory stack
mov    %rsp,%rbp           // Clear space in memory stack for an integer, i.e. 4 bytes
movl   $0x3,-0x4(%rbp)     // Put the value 3 in the stack, which will occupy 4 bytes
addl   $0x4,-0x4(%rbp)     // Add 4 to that location, still occupies 4 bytes
pop    %rbp                // Pop the result out of the memory stack
retq                       // End

Note that while writing in a ‘higher level’ language such as C, we don’t have to bother about memory stacks and clearing space. Such mundane details are taken care of by the translator (‘assembler’), so that we can write simple algebraic expressions and expect it to work. The scenario is similar to adding 3 and 4 in our brain. We are not specifically aware exactly where in our brain is the calculation going on, but the answer comes up anyway. The ‘assembler’ in our brain recruits individual neurons to the task, and returns with a result. The details of the implementation remains hidden to us.

It is only these successive levels of abstraction that allow us to think in any rational manner. Our eyes send us gigabytes of details every second, but the ‘assembler’ filters this flood of information and gathers it in usable ‘chunks’. Without this subconscious operation in the backend, the world would be too full of detail and too overwhelming for our senses. When looking at a cheetah, the entire processing power would be expended on unraveling the intricate colors of each pixel in its stripes, and we would become cat food even before our brains had time to comprehend what hit us. But fortunately, the brain does not work that way.

This is a brick road as seen by our eyes. Every intricate detail of very blade of grass is captured. The eye does not miss anything — for the same reason as the ‘initial print’ or ‘negative’ of a photograph must be of the highest quality (akin to a camera raw).

But to walk down the road, you don’t need so much. You need an outline of the bricks, and location of major potholes, if any. So this is what your motor cortex gets to work with.

What has happened in between is an ‘edge detection’ transformation, carried out by a bundle in the occipital cortex. [4] This enables you to carry on walking without giving a second thought to the act, and even provides the mental leisure to ponder over such outworldly curioities such as assembly languages and levels of abstraction.

But what is that very basic rudiment of thought, the fundamental particle of consciousness then? Can it be modeled? The biological ‘synapse’ in this case, seems the right candidate, but even a synapse is too complex and has multiple state variables associated with it. [5] Thus we must model something much simpler, without state, just as fundamental particles of matter are ultimately, without mass. Let’s call this model ‘Chinton’ footnote:[A word borrowed from the rich Sanskrit dialect of Sanjay Chakrabarty)

Assumptions

We assume a model with

1. an ability to carry out first class functions, i.e. return y given a rule f(x)
2. only two chunks of memory
3. no faculties for arithmetic; we have to teach this thing the first four operations
4. no faculties of high order logic; ‘chinton’ is akin to a single synapse and has no idea what ‘if’ ‘then’ ‘else’ ‘and’ ‘or’ ‘not’ means; thus we can not use such programming facilities. In essence, we will be writing in synaptic ‘assembly’ language with only functions at our disposal

Formal proposition

Given no limiting physical constraints, the successive levels of abstraction of an organism can be conceived of first class functions in its entirety.

Explanations

limiting physical constraints

We would really not concern ourselves with the hardware of Chinton; it could be virus, a paramecium, or a piece of software; really the physical stuff does not matter. For this exercise, we would assume only minimal physical requirements, which are conveniently addressed by a computer. Such would also apply to any receptors we will use. While talking about photoreceptors, it won’t matter whether we use vitamin A, chlorophyll or selenium. As long as light generates a voltage in the stuff, it is sufficient for our purpose.

organism

We limit ourselves to design the software of an organism; such an ‘organism’ may be non existent, or too simplistic to survive evolution. Nevertheless, we will strive to impart unto it a rudimentary information processing and learning capability.

first class functions

Given two sets A and B, if there is such a rule f between each element of A (denoted by x), such that the rule, when applied to x, always yields an element y of set B, then we write y = f(x) : A ⇨ B. By defintion, a first class function

• can return another function g(x)
• is immutable, i.e. has no side effects other than returning a value; (this is in contrast to a procedure, like “print hello”, which has a discernible side effect of printing out ‘hello)
• can be passed as an argument/ parameter to another function

For notational convenience, we’ll denote functions with a terminal `()’, which denotes the argument/ parameter list. chunks of memory:: Given a list of names, the limit to human short term memory is seven items plus minus two. Of course, when asked about a person in the list, we can fetch a whole blob of data from our storage memory, but our RAM is limited to very short numbers (as everyone reading a lengthy and complex novel has known). At a given moment, Chinton is limited only to two chunks of memory. Of course, when required it can expand any one of those two chunks into two further two chunks, but only at the expense of the first (details of the implementation will follow).

The construction of working memory

It is obvious that with only two chunks (or slots) of memory to work with, we don’t have the physical luxury of storage. We are faced in a similar situation as an individual neuron, which on its own has only minimal RAM. However, in a paper in 1960 — John McCarthy proposed the revolutionary idea that working memory can be constructed out of pure recursive functions [6], and promulgated the language LISP. The idea was translated to a much more ‘modern’ orgramming language, Javascript, by Steve Losh in 2013 [7]. We will follow this line of reasoning in developing Chinton.

The first thing, of course, is to give Chinton the idea of a set. We define a function called empty_set which will, obviously, return two empty memory chunks.

empty_set = function(question)
{
 return question(null, null); // Returns a function called question with two blank elements
}

Next, we need a way to append elements to the set. For Chinton, a set is made of two chunks of memory, ‘head’ and ‘tail’, and we design the append function in such a way so that it returns not an ‘object’, but a ‘function’ which returns, depending on how you ask, the ‘head’ or ‘tail’ of the original set.

apppend = function(el, set) // Append el to the beginning of set
{
 return function(question) // The append function returns another function with an argument question
 {
  return question(el, list); // The innermost function to be returned
 }
}
head = function(set) // Returns the first element of a set
{
 return set(function(h, t)
 {
  return h;
 }
}
tail = function(set) // Returns the rest of the set, i.e. the second memory chunk
{
 return set(function(h, t)
 {
  return t;
 }
}

The convoluted logic of the whole thing is revealed when we finally instruct to make a set

A = append(1, empty_list);

Which returns a function (ref the definition of ‘append’) and stores it in A

A = function(question)
{
 return question(el, list);
}

A world of verbs, sans nouns

As you see, the append function has created a set out of seemingly nothing! No chunks of memory (at least, not yet on display) has yet been used! It has only returned a function which, when asked, can give a head and tail of the set. This is adequate for the purpose of Chinton. This is where we shift from a memory/ hardware based approach to a functional approach to a set. A set need not exist as a physical, explicit list, but can exist solely as a function which knows its head and tail — when asked.

This idea has proved to be eearly powerful, and has found resonance in ideas propounded by John Wheeler: that oranisms, and in fact physical systems, including the entire universe, is not material at all, but made of information, i.e. a set of questions and answers (‘it from bit’). [8]. But we’ll steer clear of the metaphysical for now, and stick to the code.

Now when the function head(A) is called (i.e. it is formally ‘asked’), what is actually being done is you are calling a function upon a function (remember the set A is actually a function). The return value of head will be

A(function(h,t)
{
 return h;
}

Next the function A is called with question being another function which, when given two chunks, returns the first one

function(h, t)
{
 return h
}

Now see the inside of A; this function is the question. It is applied to

return question(el, list)

Thus el is returned, which is the ‘head’ of the set A. Similar logic can be extended to the ‘tail’ function. Thus we have constructed a set with two chunks of memory. It is to be noted that all operations on this set is recursive.

A = append(1, empty_list) // [1]
    A = append(1, A)          // [1, 1]
    A = append(1, A)          // [1, 1, 1]
    head(A);                  // 1
    tail(A);                  // [1, 1]
    head(tail(A));            // 1

Also remember that the use of the symbol ‘1’ does not imply that Chinton has a sense of numbers. It is a placeholder, like the symbol ‘empty_list’. The actual material used to construct memory might vary between systems.

One final note: we need to define a function if. We don’t expect this seedling of a life to make complex decisions. The implementation of if is thus very simple, it checks whether a set is empty or not.

if = function(set)
{
 return head(set) // A headless set is an empty set; if there is a head, 1 is returned, otherwise empty_set
}

Here is how the if function is implemented in assembly language. For a C code like this

x=3;
if (x==3)
 x=4;

The corresponding assembly code is essentially a jump instruction to the processor depending on whether the return value of the last ‘if’ function was a 1 or an empty_set.

push   %rbp
mov    %rsp,%rbp
movl   $0x3,-0x4(%rbp)
cmpl   $0x3,-0x4(%rbp)  // Compare if 3 is the stores value, store the result in memory stack
jne    18+0x18          // Jump to the end of program depending on the result of last compare statement
movl   $0x4,-0x4(%rbp)
pop    %rbp
retq

With this code backbone and nothing else, one can build a surprising number of stuff: logic gates, arithmetic operators, text parsing, neural networks. For a detailed exposition of the code, refer to the mind-bending article by Steve Losh. [7]

1. Asimov, Isaac. I Robot. New York (1950); Gnome Press

2. Mechanical Man: The Physical Basis of Intelligent Life, Dean E. Wooldridge. New York: McGraw-Hill Book Co., 1968

3. Hofstadter D R. Godel Escher Bach. New York(1979) Basic Books

4. Edge detection. Charles F. Stevens. Proceedings of the National Academy of Sciences Jan 2015, 112 (3) 875–880; DOI: 10.1073/pnas.1422673112

5. https://web.njit.edu/~horacio/Math451H/download/ErmentroutTerman_Chapter7.pdf

6. McCarthy J. Recursive functions of symbolic expressions and their computation by machine (part I). Communications of the ACM. 1960

7. https://stevelosh.com/blog/2013/03/list-out-of-lambda/

8. Glattfelder J.B. (2019) A Universe Built of Information. In: Information — Consciousness — Reality. The Frontiers Collection. Springer, Cham. https://doi.org/10.1007/978-3-030-03633-1_13