CS 420/527 — Biologically Inspired Computation
NetLogo Simulation

General Totalistic 1D Cellular Automaton

This page was automatically generated by NetLogo 5.0beta2. Questions, problems? Contact feedback@ccl.northwestern.edu.

The applet requires Java 5 or higher. Java must be enabled in your browser settings. Mac users must have Mac OS X 10.4 or higher. Windows and Linux users may obtain the latest Java from Sun's Java site. If the display appear cut off with Firefox, then try another browser (Safari works).

view/download model file: CA 1D General Totalistic.nlogo

WHAT IS IT?

This program is a one-dimensional totalistic cellular automata. In a totalistic CA, the value of the next cell state is determined by the sum of the current cell and its neighbors, not by the values of each individual neighbor. The model allows you to explore the behavior of random totalistic CAs.

This model is intended for the more sophisticated users who are already familiar with basic 1D CA’s. If you are exploring CA for the first time, we suggest you first look at one of the simpler CA models such as CA 1D Rule 30.

HOW IT WORKS

Each cell may have one of several colors with the values 0 to STATES - 1. The next state of a cell is determined by taking the sum value of the center and the neighbors on each side (as determined by RADIUS). This sum is used as an index into a state-transition table, the “rule,” which defines the new state of that cell.

HOW TO USE IT

STATES: Defines the number of states of each cell.
RADIUS: Defines the radius on both sides of a cell used to define its new state.

SET RANDOM SEED: By setting the random seed you can repeat experiments.
RANDOM RULE: Generates a random transition rule, with all states being equally likely. The rule is displayed below (RULE CODE, which shows the new state for each neighborhood total), and its ENTROPY and LAMBDA parameters are computed.
ENTER RULE: This allows you to enter a rule as a list of state values.
QUIESCENCE: If this is turned on (the usual case), then the quiescent (0) state will be forced to map into the quiescent state. If it is not set, then the quiescent state is permitted to map into any state.
DECIMATE: Zeros one of the non-zero entries in the rule, thus causing that neighborhood sum to map into the quiescent state.

SETUP SINGLE: Sets up a single color-two cell centered in the top row.
SETUP RANDOM: Sets up cells of uniformly random colors across the top row.
INPUT INITIAL STATE: Sets up cells of specified state values/colors near center of top row.
AUTO-CONTINUE?: Automatically continue the CA from the top once it reaches the bottom row.
GO: Run the CA. If GO is clicked again after a run, the run continues from the top.

START TEST: Clears the output area, creates a random rule, and generates a random initial state for a decimation run.
RUN TEST: Equivalent to GO, i.e., runs the CA as above. It is possible to reset the initial state (e.g., randomly or to specified values) and RUN TEST again.
CLASSIFY & DECIMATE: Based on the test run, the user types in a string descibing the behavior (e.g., “IV” or “II (long transient)”). The classification, parameters (lambda etc.), and the rule are written in the output area. The rule is automatically decimated and the initial state randomized in preparation for another RUN TEST. At the end of a decimation run (when the rule is all zeros), the output area can be copied and pasted into a text file when running under NetLogo (but not as an applet). Note that you will be alternating between RUN TEST and CLASSIFY & DECIMATE.

OPEN RECORD-FILE: Open a file to receive the record of a decimation run (exactly the same information displayed in the output area, described above). You are requested to enter a filename or path. Note that you will have to have write access to directory from which this program is running or to the path. The alternative is to copy and past from the Output area, as described above.
CLOSE RECORD-FILE: Close the record-file and write it to disk. If you open a record-file then a previously opened record-file will be closed automatically. Note, however, that if you quit the program without closing the record file, you will lose the file’s contents!

THINGS TO NOTICE

How does the complexity of the multicolor totalistic CA differ from the two-color CA? (see the CA 1D Elementary model)

Do most rules lead to constantly repeating patterns, nesting, randomness, or more complex behavior (Wolfram Class IV)? What does this tell you about the nature of complexity?

THINGS TO TRY

Observe the behavior of a rule under different initial conditions (single point or random initial state). Do different random initial states affect its qualitative behavior.

Start with a random rule and observe its behavior. Then decimate the rule, pick a new random initial state, and observe again. Continue progressively decimating the rule and look for changes in behavior (e.g., different Wolfram classes). Note if qualitative changes of behavior happen at particular values of the LAMBDA or ENTROPY parameters.

Do this decimation experiment with a number of random rules to see if you can determine which parameter best predicts the CAs qualitative behavior.

Explore the effects of different numbers of states and different neighborhood sizes on the CA’s qualitative behavior. What conditions seem to be necessary for complex (Class IV) behavior to emerge?

EXTENDING THE MODEL

Try making a two-dimensional cellular automaton. The neighborhood could be the eight cells around it, or just the cardinal cells (the cells to the right, left, above, and below).

RELATED MODELS

Life - an example of a two-dimensional cellular automaton
CA 1D Rule 30 - the basic rule 30 model
CA 1D Rule 30 Turtle - the basic rule 30 model implemented using turtles
CA 1D Rule 90 - the basic rule 90 model
CA 1D Rule 250 - the basic rule 250 model
CA 1D Elementary - a simple one-dimensional 2-state cellular automata model
CA 1D Totalistic - a simple one-dimensional 3-state, unit-radius CA model
CA Continuous - a totalistic continuous-valued cellular automata with thousands of states

CREDITS AND REFERENCES

Thanks to Ethan Bakshy for his help with this model.

The first cellular automaton was conceived by John Von Neumann in the late 1940’s for his analysis of machine reproduction under the suggestion of Stanislaw M. Ulam. It was later completed and documented by Arthur W. Burks in the 1960’s. Other two-dimensional cellular automata, and particularly the game of “Life,” were explored by John Conway in the 1970’s. Many others have since researched CA’s. In the late 1970’s and 1980’s Chris Langton, Tom Toffoli and Stephen Wolfram did some notable research. Wolfram classified all 256 one-dimensional two-state single-neighbor cellular automata. In his recent book, “A New Kind of Science,” Wolfram presents many examples of cellular automata and argues for their fundamental importance in doing science.

PROCEDURES

globals [
  current-row              ;; current row of display
  gone?                    ;; indicates a run has already been completed
  state-colors             ;; colors corresponding to state values
  max-total                ;; max total of states of cell and its neighbors
  num-rules                ;; number of rule entries = max=total + 1
  width                    ;; neighborhood size = 2 * radius + 1
  rule                     ;; transition rule table
  non-quiescent-indices    ;; list of indices of non-quiescent transitions
  config-table             ;; table of num of configs for each width and total
  pascal-triangle          ;; Pascal's triangle for computing binomial coefficients
  multiplicity             ;; num of configs for a given total
  num-virt-rules           ;; number of virtual rules (for equiv non-totalistic CA)
  lambda                   ;; Langton lambda of equiv non-totalistic CA
  entropy                  ;; entropy of equiv non-totalistic CA
  lambda-T                 ;; Langton lambda of totalistic CA
  entropy-T                ;; entropy of totalistic CA
  kappa                    ;; extended index of complexity
  kappa-R                  ;; relative extended index of complexity
  record-file-open?        ;; set if record file being created
]

patches-own [value]

to startup
  set gone? false
  set record-file-open? false
end

;; setup single cell of color-one in the top center row
to setup-single
  setup
  ask patches with [pycor = current-row]
    [ set pcolor item 0 state-colors
      set value 0 ]
;  set ([value] of patch 0 current-row) 1
  ask patch 0 current-row [set value 1]
;  set ([pcolor] of patch 0 current-row) item 1 state-colors
  ask patch 0 current-row [set pcolor item 1 state-colors]
end

;; setup cells of random distribution across the top row
to setup-random
  setup
  ask patches with [pycor = current-row]
  [ set value random states
    set pcolor item value state-colors
  ]
end

;; setup cells to spcified state colors near center of top row
to setup-specified
  setup
  ask patches with [pycor = current-row]
    [ set pcolor item 0 state-colors
      set value 0 ]
  let initials read-from-string user-input (word "Enter list of numbers in range 0 to " (states - 1))
  if not empty? filter [? >= states or ? < 0] initials
   [ output-show (word "Bad states not in range 0 to "
      (states - 1) ": " (filter [? >= states or ? < 0] initials))
     stop
   ]
  let offset length initials / 2
  foreach n-values (length initials) [?]
   [ ;set ([value] of patch (? - offset) current-row) item ? initials
     ;set ([pcolor] of patch (? - offset) current-row) item (item ? initials) state-colors
     ask patch (? - offset) current-row
       [ set value item ? initials
         set pcolor item (item ? initials) state-colors ]
   ]
end

to setup
  set state-colors [ black violet blue green yellow orange red turquoise brown magenta ]
  cp ct
  set current-row max-pycor  ;; set current row to top position
  set gone? false
end

to random-full-table ;; compute random transition rule table
  set width 2 * radius + 1
  set max-total width * (states - 1)
  set num-rules max-total + 1
  set rule n-values num-rules [ random states ]
  set non-quiescent-indices n-values num-rules [?]
  if quiescence
   [ set rule replace-item 0 rule 0 ;; if quiesence is set, quiescent state remains so
     set non-quiescent-indices but-first non-quiescent-indices ] 
  compute-rule-parameters
end

to specify-rule
  set width 2 * radius + 1
  set max-total width * (states - 1)
  set num-rules max-total + 1
  let input-rule read-from-string
    user-input (word "Enter list of " num-rules " numbers in range 0 to " (states - 1))
  if length input-rule != num-rules or not empty? filter [? >= states or ? < 0] input-rule
   [ output-show "Incorrect rule table."
     stop
   ]
  set rule input-rule
  set non-quiescent-indices filter [item ? rule > 0] (n-values num-rules [?])
  compute-rule-parameters
end

to decimate ;; zero (make quiescent) one non-quiescent transition
  if empty? non-quiescent-indices [ stop ]
  let victim random length non-quiescent-indices
  set rule replace-item (item victim non-quiescent-indices) rule 0
  set non-quiescent-indices remove-item victim non-quiescent-indices
  compute-rule-parameters
end

to compute-rule-parameters ;; compute lambda and entropy parameters for a rule
  let quiescent-states length filter [? = 0] rule
  set lambda-T 1 - (quiescent-states / num-rules)
  let freqs n-values states [ count-total ? ]
;; Either of the following is correct, but the 2nd is more efficient  
;  set entropy-T 0 - sum map [ plgp (? / num-rules) ] freqs
  set entropy-T (log num-rules 2) - (sum map [ plgp ? ] freqs) / num-rules
  
;; The following computes lambda and entropy for corrsponding
;; "ordinary" (non-totalistic) rule table (the "virtual" rule).
  compute-multiplicity-table
  set num-virt-rules states ^ width
  set quiescent-states sum 
    map [ ifelse-value ((item ? rule) = 0) [item ? multiplicity] [0] ]
      n-values num-rules [?]
  set lambda 1 - (quiescent-states / num-virt-rules)
  set freqs n-values states [ count-configs-total ? ]
  set entropy (log num-virt-rules 2) - (sum map [ plgp ? ] freqs) / num-virt-rules
  
;; The following computes the index of complexity as the number of state changes
;; between contiguous rule table entries.
  set kappa sum (map [ ifelse-value (?1 != ?2) [1] [0] ] (but-first rule) (but-last rule))
  set kappa-R kappa / states
end

to-report count-total [n] ;; count number of rules leading to state n
  report length filter [? = n] rule
end

to-report count-configs-total [n] ;; count number of virtual rules leading to state n
  report sum 
    map [ ifelse-value ((item ? rule) = n) [item ? multiplicity] [0] ]
      n-values num-rules [?]
end

to-report plgp [p] ;; compute p lg p correctly if p=0
  ifelse p = 0
    [ report 0 ]
    [ report p * log p 2 ]
end

to compute-multiplicity-table  ;; compute table of number of nbd configs for a given total
  ;; item n (item i config-table) is the number for total n and width i+1
  compute-Pascal-triangle (max-total + width - 1)
  set config-table (list n-values num-rules [ ifelse-value (? < states) [1] [0] ])
  foreach n-values (width - 1) [1 + ?]
    [ set config-table lput (config-row ?) config-table ]
  set multiplicity item (width - 1) config-table
;  set multiplicity n-values num-rules [ configs-for-total ? ]
end

to-report configs-for-total [n]
  report (C (width + n - 1) n) -
    reduce [?1 + ?2] n-values width
      [ (C width (? + 1)) * (C (width + n - (? + 1) * states - 1) (width - 1)) ]
end

to-report config-row [i] ;; compute row i (1..width-1) of config-table
  report fput 1 n-values max-total [ configs-for i (? + 1) ]
end

to-report configs-for [i n] ;; compute number of configs of width i+1 for total n
  let prev-row item (i - 1) config-table
  report ifelse-value (n <= i)
   [ C (i + n) n ]
   [ sum (ifelse-value (n - states + 1 >= 0)
       [ sublist prev-row (n - states + 1) (n + 1) ]
       [ sublist prev-row 0 (n + 1) ])
   ]
end

to-report C [n r] ;; binomial coefficient C (n, r) from Pascal's triangle
  ifelse n >= r
   [ report item r (item n pascal-triangle) ]
   [ report 0 ]
end

to compute-Pascal-triangle [max-n] ;; compute binomial coefficients by Pascal's triangle
  ; C (n, r) = item r (item n pascal-triangle), for n, r = 0..max-n
  set pascal-triangle (list fput 1 n-values max-n [0])
  foreach n-values max-n [1 + ?]
    [ set pascal-triangle lput (pascal-row ?) pascal-triangle ]
end

to-report pascal-row [n] ;; compute new row of Pascal's triangle from preceding row
  let prev-row item (n - 1) pascal-triangle
  report fput 1 (map [?1 + ?2] (but-last prev-row) (but-first prev-row))
end

to setup-continue
  if not gone? [stop]

  let value-list []
  set value-list map [[value] of ?] sort patches with [pycor = current-row]  ;; copy cell states from the current row to a list
  cp ct
  set current-row max-pycor  ;; reset current row to top
  ask patches with [ pycor = current-row ]
  [
    set value item (pxcor + max-pxcor) value-list  ;; copy states from list to top row
    set pcolor value-to-color value
  ]
  set gone? false
end

to go
  if current-row = min-pycor  ;; if we hit the bottom row
  [
    ifelse auto-continue?  ;; continue
    [
      set gone? true
      display    ;; ensure full view gets drawn before we clear it
      setup-continue
    ]
    [
      ifelse gone?
        [ setup-continue ]       ;; a run has already been completed, so continue with another
        [ set gone? true stop ]  ;; otherwise stop
    ]
  ]
  ask patches with [pycor = current-row]
    [ do-rule ]
  set current-row (current-row - 1)
end

to do-rule  ;; patch procedure
  let next-patch patch-at 0 -1
  let total 0
  let mypxcor pxcor
  ;; set the next state of the cell based on total of neighboring state
;  set (value-of next-patch)
;    item
;    (sum values-from patches with [ pycor = current-row and (abs (pxcor - mypxcor) <= radius) ] [value])
;    rule
  foreach n-values width [?]
   [ set total total + [value] of patch-at (? - radius) 0
   ]
  ;set ([value] of next-patch) item total rule
  ;; paint the next cell based on the new value
  ;set [pcolor] of next-patch (value-to-color [value] of next-patch)
  ask next-patch
   [ set value item total rule
     set pcolor value-to-color value ]
end

to-report value-to-color [v]  ;; convert cell value to color
  report item v state-colors
end

to open-record-file
  if record-file-open? [ file-close set record-file-open? false ]
  file-open user-input "Enter file name or path"
  set record-file-open? true
  setup-random
end

to close-record-file
  if record-file-open? [ file-close ]
  set record-file-open? false
end

to classify
  let class user-input "Enter class"
  if record-file-open?
   [ file-write class
     file-print (list lambda lambda-T entropy entropy-T kappa kappa-R rule)
   ]
  output-write class
  output-print (list lambda lambda-T entropy entropy-T kappa kappa-R rule)
  decimate
  setup-random
end

; Modified 2007-07-30 by Bruce MacLennan from CA 1D Totalistic by Uri Wilensky,
; which bears the following copyright:
;
; *** NetLogo 3.1.4 Model Copyright Notice ***
;
; This model was created as part of the projects:
; PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN
; CLASSROOMS and/or INTEGRATED SIMULATION AND MODELING ENVIRONMENT.
; The project gratefully acknowledges the support of the
; National Science Foundation (REPP & ROLE programs) --
; grant numbers REC #9814682 and REC-0126227.
;
; Copyright 2002 by Uri Wilensky.  All rights reserved.
;
; Permission to use, modify or redistribute this model is hereby granted,
; provided that both of the following requirements are followed:
; a) this copyright notice is included.
; b) this model will not be redistributed for profit without permission
;    from Uri Wilensky.
; Contact Uri Wilensky for appropriate licenses for redistribution for
; profit.
;
; To refer to this model in academic publications, please use:
; Wilensky, U. (2002).  NetLogo CA 1D Totalistic model.
; http://ccl.northwestern.edu/netlogo/models/CA1DTotalistic.
; Center for Connected Learning and Computer-Based Modeling,
; Northwestern University, Evanston, IL.
;
; In other publications, please use:
; Copyright 2002 Uri Wilensky.  All rights reserved.
; See http://ccl.northwestern.edu/netlogo/models/CA1DTotalistic
; for terms of use.
;
; *** End of NetLogo 3.1.4 Model Copyright Notice ***