Creatures 3 SV Rules
 

Creatures3 

 Opcodes (1st byte)

stop: ends calculation for current lobe/tract rule

blank: sets specified neuron or dendrite variable to 0.  Blanking the accumulator seems to have no effect (accumulator value does not change), nor can chemical tokens be blanked.

store in: write current accumulator value in specified neuron or dendrite variable.  (note: chemicals appear to be read-only; cannot write data to them)

load from: load accumulator with value from specified neuron or dendrite variable, chemical, or other specified value (e.g. zero, random)

if {=,<>,>,<,>=,<=}: compare accumulator against the specified variable or other value.  If compare is true, execute next opcode; if compare is false, skip next opcode.

if {zero,non-zero,positive,negative,non-negative,non-positive}: compare specified neuron or dendrite variable or other specified value against keyword (e.g. zero, non-zero, etc).  If compare is true, execute next opcode, else skip it.

add: add operand/token to accumulator; store sum in accumulator.

subtract: subtract operand/token from accumulator, store difference in accumulator.

subtract from: subtract accumulator from operand/token, store difference in accumulator

multiply by:  multiply accumulator by operand/token, store product in accumulator.  Operand can be (int) value or variable.

divide by: divide accumulator by operand/token, store quotient in the accumulatore.  Operand/token can be (int) value or variable.

divide into

minimum with

maximum with

set tend rate: see tend to

tend to: if  operand/token is 0: 

                      a(1) = a(0) * (1 - tend rate) where a(0) is value of

                      accumulator before this operation and a(1) is value

                      of accumulator after this operation.  

           if operand/token is 1:

                      a(1) = a(0) * (1 + tend rate) where a(0) is value of

                      accumulator before this operation and a(1) is value

                      of accumulator after this operation. 

           if operand/token is non-{0,1}:

                      a(1) = a(0) + ( tend rate * ( tend to - a(0) ) ) 

                      a(1) approaches the "tend to" value by an amount

                      proportional to the difference between the two, 

                      multiplied by "tend rate"

load negation of

load abs of

get distance to

flip around

no operation

register as spare

bound in [0,1]

bound in [-1,1]

add and store in

tend to, store in

Nominal Threshold

Leakage Rate: multiplier used to set value of neuron Input

Rest State: multiplier used to set value of neuron Input

Input Gain Hi Lo: multiplier used to set value of neuron Input

Persistence: drives neuron State to equal neuron Input value;

            S(1) = S(0) + ( (1-Persistence) * (I(0) - S(0)) )

Signal Noise: add a random value between 0 and operand/token to neuron State then store sum in neuron State.  This seems to be applied prior to Persistence calculation.

Winner Takes All

Short Term Relax Rate

Long Term Relax Rate

store abs in

stop if zero

stop if non-zero

if zero goto

if nonzero goto

div by, add to neuron input

mult by, add to neuron input

goto line

stop if {<,>,<=,>=}

Reward Threshold

Reward Rate

Use Reward With

Punish Threshold

Punish Rate

Use Punish With

Preserve Neuron SV

Restore Neuron SV

Preserve Spare Neuron Var

Restore Spare Neuron Var

if negative goto

if positive goto