Emergence of behavior through software

[Lynn H. Maxson]

I have to thank Jecel Assumpcao for clarifying some issues about 
emergent and non-deterministic behavior in software.  I did not 
set up the two-question pair to Fare as trick questions.  I use 
"consistent" as the qualifying term to determine whether the 
results conformed to the embedded logic of the software or not.

If they (the results) did, then regardless of anyone's ability to 
fathom or predict them, the software executed as instructed and 
thus brought nothing "extra" or "special" to the process.  In 
short it did nothing on its own "volition".

If they did not conform, then we have to account for (1) the means 
through which it achieved "take off", the ability to fly on its 
own, and (2) why given this "independence" it would choose (as 
clearly it has the choice) to continue to pursue the "original" 
purpose and not determine to pursue a different one as part of its 
"nonconformist" behavior.

Fare despite his cybernetic leanings will not grant the software 
any choice other than pursuit of the original purpose.  He will 
allow it to improve upon its internal logic, but this raises now a 
larger issue.  How does software on its own organize itself 
internally to "develop", "recognize", and "construct" higher level 
of abstractions from the only thing it can execute: the machine 
instruction set.

You see, how do we bridge this gap from externally set, 
instruction-conforming behavior to internally set, 
instruction-conforming behavior?  What initiates the internally 
set behavior from the externally set?  If we disallow passing it 
to it somehow as a form of inheritance, which we must disallow in 
order for its "new" behavior to be its "own", then we are left 
with the issue of "spontaneous generation", something occurring on 
its own independent of the current consistent execution.

You see it cannot occur through meta^n-programming regardless of 
levels.  That presupposes that we have some ability to encode a 
"triggering" event in the execution which will spawn the necessary 
spontaneous generation.  We do not.  What we have is the machine 
instruction set, the only thing that the software can direct the 
machine to execute.  

The only direction it can offer is that externally set by its 
authors.  The authors may or may not know (predict) the results.  
They may or may not take or have the time necessary to retrace the 
executed logic.  But what they do know (something that the 
non-intelligent software cannot) is that whatever results is 
consistent with the encoded logic.

Truth is that Fare knows this as well.  He knows that there are no 
triggering events not present in nor otherwise determined 
inconsistent with the embedded logic of the software.  It can't 
happen, because in von Neumann architecture any such occurrence is 
an "error", something to be fixed.  Contrary to his statement that 
no one can know completely the internal logic of the machine, I 
began my career being trained to know just that.  If it failed, if 
the results differed from the expected result of a machine 
instruction execution, the embedded IPO (input-process-output) 
logic of a machine instruction, my job was to diagnose and repair.

Spontaneous generation then in a von Neumann machine is an error, 
again something to be fixed.  The hardware does not support it 
except as an error.  There is no means in software translated into 
machine instructions to make this possible.

Fare in acceding that software retains its "purpose" throughout 
knows this.  He also knows that regardless of our ability to 
predict or fathom software-produced results it has nothing to do 
with the results consistency with the encoded logic.  We may be 
surprised.  The non-intelligent software lacks this altogether.

This is true for AI systems whether rule-based or neural-net.  
Neural-net implemented in software is rule-based.  Rule-based 
software systems created by humans may reflect the result of human 
"intelligence" (determining the set of rules), but neither the 
input, the process, nor the output (result) do more than "reflect" 
but not "absorb", that intelligence.  In an of themselves absent 
of an "observer" they cannot produce information.  For information 
implies meaning.  Meaning does not exist in data or software.  
Meaning, if it exists at all, does so only in the observer.

Are the results consistent with the embedded logic of the software 
regardless of our ability to fully predict or fathom them?  If the 
answer is yes, then we do not differ in terms of causes and 
effects.  If the answer is no, then what spontaneous generation 
does not occur in error?  If it does occur, how does it still stay 
within the "purpose" encoded in the software?

If we can all agree on results consistent with the embedded 
software logic, then we can ignore considering inconsistency.  
That leaves us then free to differ in our degree of individual 
wonderment relative to what "we" have "created" through software.  
Therein we can expect that in terms of wonder some are less or 
more so than others.  If that's the only thing which separates us, 
then we can return to the main Tunes list.<g>