Trevor Batten:
     Some Notes on the Works in the FAMOUS PEOPLE Series:


I.                           "TURING"

            A Simple (One Dimensional) Totally Interactive Turing Machine

                   Conceived and Programmed by Trevor Batten

                                Amsterdam 1997


   i. The Conceptual Basis:

     How does one express the buddha nature of Buddha or the chameleon nature
     of the Chameleon?

     What is the nature of the machine that can be all machines?
     And how does one define a simulation of the universal simulator?

           -As Artistic Portrait?
           -As Post-Modern Self-referential Joke?
           -As Simulated Mental Landscape?
           -As Visual Tour of Turing?
           -As Monument to Conceptual Elegance?
           -As Example of Interactivity?
           -As Demonstration of Autonomy?
           -As Numeralogical Laboratory?
           -As Philosophical Expression of Non-Linear Causality?
           -As Symbolic Statement?
           -As Pedagogical Tool?
           -As Entropy Defying Game?
           -As Weaver of Patterns?

     Perhaps it is all of these things -or none!

   ii. The Technical Basis:

     Technically "TURING" consists of one or more conceptual machines moving
     through the memory space and Reading, Modifying and (Re)Writing the Symbols
     found there which may be interpreted as Colour, Process or Control Data.

     In practice it is a menu controlled single user system which visually
     documents (as far as possible) its own (internal) operation

     Perhaps one day it will be possible for everyone to explore the system
     at home via the net. In the meantime you will need "TURING" installed
     on an Amiga computer with monitor and mouse to experience and decide for


   i. The Basic System:

        "TURING" basically consists of

            -Two Conceptual Components:
                 -a row of memory locations containing symbols
                 -a movable READ/WRITE 'head' modifying the stored symbols
                  (by duplicating this we create a number of parallel machines)

            -Two sets of Rules:
                 -a set of Rules determining the position of the 'head'
                 -a set of Rules determining the modification of the Symbols

            -A Visual Representation showing memory and rules

  ii. The Control Parameters:

        The Basic System can be controlled by the following nine menu blocks
        referring to:

                -The Project itself      (restarts and exit)
                -The number of States    (the symbol set)
                -The Start   Rule        (the initial condition)
                -The Move    Rule        (positioning READ/WRITE 'head')
                -The Process Rule        (the transformation rule)
                -The number of Machines  (number of READ/WRITE 'heads')
                -Memory and Visual Space (on exceeding limits)
                -Automatic Modification  (of specified rules)
                -Interaction             (between machine and visual image)

 iii. The Menus:

     0.    Project
              Restart      : Restarts process from top of page
              Newstart     : Recalculates key values, clears screen and restarts
              info         : Writes the title section of this text to screen
              intro        : Writes the introduction of this text to screen
              instructions : Writes this section of this text to screen
              EXIT         : Exits Program and returns to System

     I.   Cols
              (2-16)       : Sets required number of colours
                             (i.e. maximum number of states per machine)

     II.  Start
              (0-15)       : Sets initial states to chosen value
              mod          : Sets initial states to cyclic pattern
              rnd          : Sets initial states to random pattern

    III.  Move
              step + -     : Steps right if found state is even, else left
              step - +     : Steps left  if found state is even, else right
              rand-step    : Generates left/right step look-up table
              aut-pmst     : Local states determine move rule (rules 1 to 2)
              aut-step     : Local states determine move rule (rules 1 to 3)
              jump + -     :* Jumps right if found state is even, else left
              jump - +     :* Jumps left  if found state is even, else right
              rand-jump    :* Generates left/right jump look-up table
              aut-pmju     :* Local states determine move rule (rules 6 to 7)
              aut-jump     :* Local states determine move rule (rules 6 to 8)
              aut-all      :* Local states determine move rule (all rules)

                 * Value of Neighbour opposite to direction of movement
                   determines size of jump.

     IV.  Func.
              add  n       :% Adds machine number to present value
              invert       :% Complements present value and Adds machine number
              sub  n       :% Subtracts machine number from present value
              rand.1       :% Generates transformation Look-up table
              aut.maths 1  :% Local states determine rule (rules 1 to 3)
              aut. 1       :% Local states determine rule (rules 1 to 4)
              inv.add  n   :# Current position Neighbours added
              inv.mult n   :# Current position Neighbours multiplied
              inv.sub  n   :# Current position Neighbours subtracted
              rand.2       :# Generates transformation Look-up table
              aut.maths 2  :# Local states determine rule (rules 7 to 9)
              aut. 2       :# Local states determine rule (rules 7 to 10)
              aut.maths all:$ Local states determine rule (all math rules)
              aut.all      :$ Local states determine rule (all rules)

                 % Single input function
                 # Double input function
                 $ Mixed  input function

     V.   Machs.
              (1-9)        : Sets number of machines

    VI.   SPACE
              H-Loop V-Loop: "TURING" memory continuous loop, also image looped
              H-Boun V-Loop: "TURING" memory bounce limits,    but image looped
              H-Loop V-Boun: "TURING" memory continous loop,  but image bounced
              H-Boun V-Boun: "TURING" memory bounce limits,  also image bounced

                 i.e.  Loop   = Jump to opposite end on reaching limits
                       Bounce = Change of direction  on reaching limits

                 Note: "TURING" is one-dimensional (i.e. a single line) machine
                                Documenting memory changes on subsequent rows
                                creates illusion of two-dimensional image.

                       -Memory space is functional
                       -Visual space is cosmetic (except in 'True Int' mode)

   VII.   AutMods
              No   moveMod : Movement Rule is not modified by memory bounce
              Self moveMod : Current  Movement Rule is modified by memory bounce
              All  moveMod : Complete Movement Rule is modified by memory bounce
              funMod% No   : Function Rule is not modified
              funMod% Yes  : Function Rule is modified if memory is unchanged

                       Current  Movement Rule = Rule for Current (colour) value
                       Complete Movement Rule = Rule for Complete matrix

                 Note: Only Rules concerning current machine can be modified

              Non Int.     : "TURING" functions normally
              Vis. Int1    : Output is added to screen image with limited colour
              Vis. Int2    : Output is added to screen image with maximum colour
              True Int     : "TURING" interacts with screen image


               "TURING" is a menu operated single user digital laboratory
               which visually documents its own internal operation.

               Conceptual, technical and operating principles are internally
               available via the menu system.

               In principle "TURING" should run on any AMIGA computer
               equipped with monitor and mouse. A keyboard is not required.

               For presentation purposes a table (with mouse pad) plus
               a chair are sufficient additions to the computer.

               The artist is not able to provide equipment for presentation

               A VHS demonstration video tape is available. Other formats
               may be possible after agreement with the artist.

II.                          "GOEDEL"

             A Series of Audio-Visual Computer Installations conceived
             and programmed by Trevor Batten, Amsterdam 1997.

   The Concept:

     GOEDEL refers to the potential creation of paradoxical results which
     may be generated through introspective interpretation. By introspectively
     generating visible form from empty space "Goedel" becomes a model of,
     and a metaphor for, the creative process. The way in which the automata
     reinterpret the results of their actions to generate new variations of
     behavior is considered to be a visual generalization of the Goedel
     paradox exhibited by formal systems when interpreted as statements
     regarding themselves. In the domain of logic the Goedelian paradox
     undermines the very principles upon which our logical systems are based.
     In the visual domain the introspective interpretation becomes a creative
     principle capable of generating a self modifying series of visual images
     reminiscent of classical non-western cultures.

   The Work:

               The series is also concerned with different constraints on
               the variation in control data (i.e. behaviour).

               The individual titles in the current series are:

                       GOEDEL-VTa             GOEDEL-VVa
                       GOEDEL-VTb             GOEDEL-VVb
                       GOEDEL-VTc             GOEDEL-VVc

         VT indicates: Variable Timer        (i.e. Conditional Variation)
         VV indicates: Variable Variable     (i.e. Free        Variation)

      a,b,c indicates: Degrees of freedom    (i.e. Variation in Visual Form)

II.                          "THATCHER"

             An Audio-Visual Computer Installation conceived and programmed
             by Trevor Batten, Amsterdam 1998.

    "THATCHER" is just one of those silly things that just happen without
    one really thinking about it.

    It (she?) started life as a preliminary study to draw some simple
    geometrical figures as a basis for some wild idea about representing
    multi-dimensional space on a grid composed of such figures.

    These basic figures involved variation in the radial and colour
    increments and the number of steps used to plot a circle-based figure.

    Because I am rather fascinated by feedback -including the re-use of
    data from the image, the data inputs in the original experiment were soon
    modified to be derived from the image memory (also as a convenient source
    of test data).

    The results were fascinating and fitted in perfectly with my earlier
    experiments involving image-driven sound machines. All that was needed
    was a library of frequencies, a simple sound generating system and a
    set of assignments relating image data to sound control data.


    A sound machine that reads and writes it's own score!

    The rest must explain itself!

    The geometrical grid figures were never made.

    "THATCHER" is part of the "FAMOUS PEOPLE" series of (sound)
    performance/installations all of which run on an Amiga computer.
    Sound and Image are simultaneously produced in a continuous real-time
    process. Due to a random start, each performance is unique -even though
    the rest of the process is completely deterministic.

    Presentation, simply involves running the program on an Amiga computer.
    The (video) image can be projected or shown on a monitor.
    Use of an external amplifier and speaker is recommended for optimal
    sound performance.

                                                      Trevor Batten
                                                  Amsterdam, March 1998