In neuroscience plasticity signifies the brains capacity for livelong adaptation and ongoing structural change. The brain is thus an organ that finds itself in a process of permanent becoming.

Any structural change in the brain is related to learning or un-learning skills or habits. Unlearning a habit or skill is more difficult than learning a new skill. As any learning process modifies the structure of your brain to some degree it also modifies the way you perceive and act in the world. In that sense learning is mind-expanding process.
A relatively easy self-experiment in modifying your own brain structure is to learn juggling. Juggling is a motor skill that requires learning to coordinate


David Hockney, still from “The Jugglers, June 24th 2012,” 2012. © David Hockney. Image courtesy Hockney Pictures and Pace Gallery.

 

Transient structural changes caused by juggling exercises. The changes are marked yellow and are superimposed on a normalized T1-image. (From Driemeyer et al)

your left hand and right hand movement and to link perceptual events, seeing the balls, with motor the actions of throwing and catching the balls.

It has been shown in several studies (Driemeyer et al,Boyke et al) that during the acquisition of this new motor skill certain areas of the brain, such as the hippocampus show a significant increase in gray matter.

From the beginning of the seminar we want to work on modifying our own brain structure, you should thus all come up with a new skill to learn, it could be juggling, table football or any other new skill you always wanted to learn. As part of the seminar you should find a way of documenting your learning process.

 

Overview — semester plan

31.10.13 neuroscience of plasticity, historical overview


drawings of the cells of the retina by anatomist Santiago Ramón y Cajal

In 1906 Santiago Ramón y Cajal was awarded the nobel prize for physiology and medicine together with Camillo Golgi. Both were rewarded for their substantial findings and histological analysis of nervous cell tissues. Golgi had invented the Golgi-method a silver staining technique that renders visible about 10% of the cells.


examples of golgi stained tissue from a commercial provider of golgi preparations

Santiago Ramón y Cajal had refined the golgi staining method and concluded from his observations that nerves are cells, seperate entities that have endings and physically separated. In contrast Camillo Golgi was in favor of the reticular theory, claiming that the nerves were not separate but rather a huge fully connected rhizomatic structure.

[caption width="213" caption=" Camillo Golgi in his laboratory."]

We substitute instead a vocabulary suited to a fluid organic system with certain thermodynamic properties. Another example is the localist versus distributed representation debate. The localist position is best illustrated with the grandmother cell concept, which is the idea that whenever you see your grandmother one specific nervous cell becomes active. This idea has recently gained some experimental support from single cell recordings in human subjects, and is also referred to as the Jennifer Aniston cell. In contrast to this localist view, (information is stored in cell that can be localized) is the idea of distributed representation, that claims that viewing your grandmother or Jennifer Aniston activates a distributed activation pattern of assemblies of neural structure.
Another important breakthrough in understanding the function of nervous networks was the experiment from Otto Loewi in 1921 that proved that nervous cells

[caption width="210" caption="Loewis experiment,S = stimulus in the vagus,D = contractions of heart D,R = contractions of heart R "]

but the next day he could not read his notes. The next night he had the same dream again, this time he directly stood up and went to his lab to perform the experiment (from Wikipedia). This anecdote is not only curious but also links to an important factor on learning which is sleep. There is a recent study by Wagner et. al. that showed significant effect on how sleep is related to sudden insights. It has been also shown that sleep is important for consolidating memory see (Diekelmann & Born) for a review. The Effect of memory consolidation during sleep can be modulated by boosting slow oscillations during sleep (Marshall et. al.).

In 1949 Donald O. Hebb published his ground breaking book The Organisation of Behavior which marked a departure from the dominant behaviorism linking the nervous system to behavior. The main postulate of the book (quote from Wikipedia) Let us assume that the persistence or repetition of a reverberatory activity (or “trace”) tends to induce lasting cellular changes that add to its stability.… When an axon of cell A is near enough to excite a cell B and repeatedly or persistently takes part in firing it, some growth process or metabolic change takes place in one or both cells such that A’s efficiency, as one of the cells firing B, is increased can be paraphrased with fire together — wire together.

Wilder Penfield was a neurosurgeon who worked at the same university as Donald

[caption width="137" caption="The homunculus rendered into a figure with the proportions corresponding to the size of the nervous representation "]

O. Hebb at Mc. Gill University in Montreal. He had developed a surgery to treat patient with severe epilepsy, by locally destroying nerve tissue. The operations were conducted by opening the skull and only under local anesthesia, the patients were awake during the operation. By locally stimulating the nerve tissue he could map regions of neural tissue to motor function. Based on these mappings the cortical homunculus was constructed.

[caption width="256" caption=" Eric Kandel with an aplysia "]

07.11.13 growth processes


roots, Roman Kirschner


simulation of a growth process, click to start,press ‘r’ to reset, ‘s’ to stop

Growth is fundamental part of plasticity, for example, as we have seen in the juggling study, the brain regions associated with the learning task grow during the period of learning to shrink afterwards. In this session we look at crystalline growth processes. Although the mechanisms in neural growth are quite

figure from Gordon Pasks paper on growth

different from crystalline growth they share one fundamental aspect, which is that the growth process may alter behavior and in turn alter the growth process itself. This analogy had first been examined by Gordon Pask in his works on chemical computing. In Physical Analogues to the Growth of a Concept he proposes a crystal process that he takes as example for a self-building system that illustrates growth. Within the seminar we re-enact this experiment using silver-nitrate dissolved in ammonia and water, because the growth of silver structures as a result of electrolysis happens very fast and can be observed in real-time. We focus on one aspect that is sketched in Pasks paper in figure 6: the effect of competition and bifurcation during the growth of silver-threads when there are multiple attracting anodes. He argues that if initially point X is more attractive than Y, the thread will grow in direction of X and that if at some moment in time Y is made equally attractive the thread might bifurcate and split into two branches. If after this bifurcation, the initial parameters for X and Y are re-established, the behavior of the system will now be very different, because it has already formed a thread towards Y. He argues that the behavior after bifurcation can not be predicted from the observations of the system before the bifurcation. From this observation he concludes (quote) Thus an observer would say that the assemblage learned and modified its behavior, or looking inside the system, that it built up a structure adapted to dealing with an otherwise insoluble ambiguity in its surroundings.


hands-on experiments with an arduino controlled growth process using silver-nitrate

14.11.13 guest: Hubert Dinse on Controlling plasticity and learning


co-activation of the finger and test device for assessing tactile acuity

Hubert Dinse heads the neural plasticity lab at the institute for neural computation in bochum. Hubert Dinse is a world leading researcher on the topic

Hubert Dinse

of neural plasticity. With his group at the neural plasticity lab he has discovered how to trigger learning and structural brain reorganization through passive stimulation protocols. They have also developed advanced methods for measuring behavioral improvement, in for example tactile acuity. Combining these methods with brain imaging technologies such as functional magnetic resonance imaging and electroencephalography (EEG) they could show that, for example, extended training of a musical instrument, wearing a cast or even meditation all drive structural changes of the brain.

21.11.13 models and algorithms of growth


screenshot from the german television program Spass am Dienstag

zinified version of the storing input example, click to start

Programming is a skill and like any other skill programming can be learned. We will use the study of algorithms of growth to learn programming basics. As programming environment we will use processing. Processing provides a very good documentation and many examples and tutorials. My favorite processing example is called Storing Input. The code is very minimalistic and the result reminds me of zini, a character that was starred in the german television program Spass am Dienstag.

/**
 * Storing Input. 
 * 
 * Move the mouse across the screen to change the position
 * of the circles. The positions of the mouse are recorded
 * into an array and played back every frame. Between each
 * frame, the newest value are added to the end of each array
 * and the oldest value is deleted. 
 */
 
int num = 60;
float mx[] = new float[num];
float my[] = new float[num];

void setup() {
  size(640, 360);
  noStroke();
  fill(255, 153); 
}

void draw() {
  background(51); 
  
  // Cycle through the array, using a different entry on each frame. 
  // Using modulo (%) like this is faster than moving all the values over.
  int which = frameCount % num;
  mx[which] = mouseX;
  my[which] = mouseY;
  
  for (int i = 0; i < num; i++) {
    // which+1 is the smallest (the oldest in the array)
    int index = (which+1 + i) % num;
    ellipse(mx[index], my[index], i, i);
  }
}

To simulate the crystalline growth process with a processing sketch we program an algorithm that is called diffusion limited aggregation (dla). The basic principle of dla is to simulate a diffusion process of particles, that form into a cluster when they hit an aggregate. The aggregate is initialized with a single seed. The diffusion process of the particles is simulated with a random walk.
The following sketch creates 50 particles that do a random walk and it illustrates nicely how the random walk of all particles leads to a diffusion. The area in which the particles are allowed to move is unlimited, ultimately the particles diffuse into the void.


click to start, type ‘s’ to stop and ‘r’ to reset

int numberOfParticles = 50;
int particleSize=20;
Particle[] particles = new Particle[numberOfParticles]; 
void setup()
{
  size(584, 180);
  for (int i=0;i < numberOfParticles; i++)
  {
    particles[i] = new Particle(particleSize,particleSize,color(random(255), random(255), random(255)), width/2, height/2);
  } 
}
void draw()
{
  background(100);
  for (int i=0;i < numberOfParticles; i++)
  {
    particles[i].move();
    particles[i].draw();
  }
}

class Particle
{
  float x,y;
  color c;
  int particleSizeX,particleSizeY;
  Particle(int particleSizeX,int particleSizeY,color c,float x_pos, float y_pos)
  {
    x=x_pos;
    y=y_pos;
    this.c=c;
    this.particleSizeX=particleSizeX;
    this.particleSizeY=particleSizeY;
  }
  void draw()
  {
    stroke(c);
    fill(c);
    ellipse((int)(x),int(y),particleSizeX,particleSizeY);
  }
  void move()
  {
      x += random(-sqrt(2*particleSizeX),sqrt(2*particleSizeY));   
      y +=  random(-sqrt(2*particleSizeX),sqrt(2*particleSizeY));     
  }
}

In order to make the sketch more readable the particle movement and drawing functions are encapsulated in a class called Particle. This class has three functions:

  • the constructor that is used for the setup of the class, which takes as parameters the size in x and y direction, the color and the initial x and y position of the particle.
  • the move function, this is the core function that creates the random move by computing a random movement in x and y direction that is added to the particles current position.
  • the draw function, to paint a circle at the current position of the particle.

The second part of the dla algorithm is the building up of a cluster, which is actually the crystalline like structure, also refered to as aggregation. Usually a single seeding point is defined and when a particle in its random motion hits the seeding point it builds an aggregate with the seeding point by sticking at the location where it did hit the point. Whenever a another particle hits the aggregate it also sticks to it. To keep track of whether a particle hits the aggregate and to keep track of the growing structure we need a second element which is an occupancy grid. For the sake of simplicity we define a two dimensional rectangular grid, although others are possible (more dimension, hexagonal shape).


click into a gridpoint to check if neighboring pixels are occupied

float fcenterX;
float fcenterY;
Grid grid;
int particleSize=40;
void setup()
{
  size(584, 240);
  fcenterX=width/2;
  fcenterY=height/2;
  grid = new Grid(particleSize, particleSize);
  grid.setOccupied((int)fcenterX, (int) fcenterY);
  background(100);
  fill(255);
  stroke(255);
}
void draw()
{
  background(100);
  grid.draw();
}

void mouseReleased() { 
  if (!grid.alone(mouseX, mouseY))
  {
    grid.occupancyMap[grid.findGridPointIndex(mouseX, mouseY)]=true;
  }
  loop();
}

void mousePressed() {
  noLoop();
  if ((!grid.alone(mouseX, mouseY))&&(!grid.occupied(mouseX, mouseY)))
  { 
    grid.drawGridCell(mouseX, mouseY, color(255, 0, 0));
  }
}

//class to manage an occupancy grid   
class Grid {
  int cellWidth, cellHeight;  //width and heigth of a single grid cell
  boolean [] occupancyMap; //linear vector that keeps track wether a cell is occupied or not
  int array_size;
  int grid_width;
  int grid_height;
  Grid(int cellWidth, int cellHeight)
  {
    this.cellWidth=cellWidth;
    this.cellHeight=cellHeight;
    //size of the linear array 
    array_size = round(width/cellWidth * height/cellHeight);
    //full width of the grid in screen coordinates
    grid_width= round(width/cellWidth);
    //full height of the grid in screen coordinates
    grid_height= round(height/cellHeight);
    print(grid_width);
    //initialize occupancymap
    occupancyMap = new boolean[array_size];
    for (int i=0;i<array_size;i++)
    {
      occupancyMap[i]=false;
    }
  }
  //returns the coordinates in the grid from screen coordinates 
  int findGridPointIndex(int x, int y)
  {
    int x_grid=(int)(x/cellWidth);
    int y_grid=(int)(y/cellHeight);
    return (y_grid * grid_width + x_grid);
  }
  //draws a grid cell given at the screen coordinates 
  void drawGridCell(int x, int y, color c)
  {
    int x_grid=(int)(x/cellWidth);
    int y_grid=(int)(y/cellHeight);
    stroke(c);
    fill(c);
    rect(x_grid*cellWidth, y_grid*cellHeight, cellWidth, cellHeight);
  }
  //finds the cell center x grid coordinate given the screen x coordinate 
  int findGridCellCenterX(int x)
  {
    int x_grid=(int)(x/cellWidth);
    return x_grid*cellWidth+round(cellWidth/2.);
  }
  //finds the cell center y grid coordinate given the screen y coordinate 
  int findGridCellCenterY(int y)
  {
    int y_grid=(int)(y/cellHeight);
    return y_grid*cellHeight+(int)(cellHeight/2.);
  }
  //checks if cell is already occupied
  boolean occupied(int x, int y) 
  {     
    int cx = (int)(x/cellWidth); 
    int cy = (int)(y/cellHeight);
    cy *= grid_width;     
    return occupancyMap[cx+cy];
  }
  void setOccupied(int x,int y)
  {
    occupancyMap[findGridPointIndex(x, y)]=true;
  }
  // returns true if no neighboring pixels  
  boolean alone(int x, int y) 
  {     
    int cx = (int)(x/cellWidth); 
    int cy = (int)(y/cellHeight);
    // get positions   
    int left_of_x = cx-1;     
    int rigt_of_x = cx+1;     
    int top_of_y = cy-1;     
    int bottom_of_y = cy+1;   
    //checks that index is not out of bounds or on the border
    if (cx < 0 || cx >= grid_width || left_of_x < 0 || left_of_x >grid_width || rigt_of_x <= 0 || rigt_of_x >= grid_width || 
      cy < 0 || cy >= grid_height || top_of_y < 0 || top_of_y >=grid_height || bottom_of_y <= 0 || bottom_of_y >=grid_height) 
    {
      return true;
    }    
    // pre multiply the ys     
    cy *= grid_width;     
    bottom_of_y *= grid_width;     
    top_of_y *= grid_width;   
    // N, W, E, S    
    if (occupancyMap[cx + top_of_y] ||  occupancyMap[left_of_x + cy] || 
      occupancyMap[rigt_of_x + cy] ||  occupancyMap[cx + bottom_of_y]) 
    {
      return false;
    }
    // NW, NE, SW, SE    
    if (occupancyMap[left_of_x + top_of_y] ||  occupancyMap[left_of_x + bottom_of_y] ||  
      occupancyMap[rigt_of_x + top_of_y] ||  occupancyMap[rigt_of_x + bottom_of_y]) 
    {
      return false;
    }      
    return true;
  }

  void draw()
  {
    fill(150);
    stroke(150);
    strokeWeight(2);
    for (int x = 0; x< grid_width; x++)
      for (int y = 0;y< grid_height; y++)
      {
        fill((occupancyMap[y * grid_width + x]?1:0)*150+100);
        rect(x*cellWidth, y*cellHeight, cellWidth, cellHeight);
      }
  }
}


With the particle class and the grid class at hand constructing the dla is now straightforward.


click to start, type ‘s’ to stop and ‘r’ to reset

float fcenterX;
float fcenterY;
int numberOfParticles = 160;
int particleSize=10;
Particle[] particles = new Particle[numberOfParticles]; 
Grid grid;
void setup()
{
  size(584, 360);
  fcenterX=width/2;
  fcenterY=height/2;
  grid = new Grid(particleSize, particleSize);
  grid.occupancyMap[grid.findGridPointIndex((int)fcenterX, (int) fcenterY)]=true;
  for (int i=0;i < numberOfParticles;i++)
  {
    particles[i] = new Particle(particleSize,particleSize,color(random(255), random(255), random(255)), random(0,width), random(0,height));
  } 
  background(100);
  fill(255);
  stroke(255);
  ellipse((int)fcenterX, (int)fcenterY, 10, 10);
}
void draw()
{
  background(100);
  //grid.draw();
  for (int i=0;i < numberOfParticles;i++)
  {
    if (grid.alone((int)particles[i].x, (int)particles[i].y))
    {
      particles[i].move();
    }
    else
     {
       grid.occupancyMap[grid.findGridPointIndex((int) particles[i].x,  (int) particles[i].y)]=true;
       particles[i].x= grid.findGridCellCenterX((int) particles[i].x);
       particles[i].y= grid.findGridCellCenterY((int) particles[i].y);
     }
    particles[i].draw();
  }
}

class Grid {
  int colSize, rowSize;  
  boolean [] occupancyMap;
  int array_size;
  int grid_width;
  int grid_height;
  Grid(int colSize, int rowSize)
  {
    this.colSize=colSize;
    this.rowSize=rowSize;
    array_size = round(width/colSize * height/rowSize);
    grid_width= round(width/colSize);
    grid_height= round(height/rowSize);
    occupancyMap = new boolean[array_size];
    for (int i=0;i < array_size;i++)
    {
      occupancyMap[i]=false;
    }
  }
  int findGridPointIndex(int x, int y)
  {
    int x_grid=(int)(x/colSize);
    int y_grid=(int)(y/rowSize);
    return (y_grid * grid_width + x_grid);
  }
  void drawGridPoint(int x, int y)
  {
    int x_grid=(int)(x/colSize);
    int y_grid=(int)(y/rowSize);
    stroke(100,50);
    fill(100,50);
    rect(x_grid*colSize, y_grid*rowSize, colSize, rowSize);
  }
  int findGridCellCenterX(int x)
  {
    int x_grid=(int)(x/colSize);
    return x_grid*colSize+round(colSize/2.);
  }
  int findGridCellCenterY(int y)
  {
    int y_grid=(int)(y/rowSize);
    return y_grid*rowSize+(int)(rowSize/2.);
  }
  // returns true if no neighboring pixels  
  boolean alone(int x, int y) 
  {     
    int cx = (int)(x/colSize); 
    int cy = (int)(y/rowSize);
    // get positions   
    int lx = cx-1;     
    int rx = cx+1;     
    int ty = cy-1;     
    int by = cy+1;     
    //checks that index is not out of bounds or just on the borders
     if (cx <= 0 || cx >= grid_width || lx <= 0 || lx >= grid_width || rx <= 0 
     || rx >= grid_width || cy <= 0 || cy >= grid_height || ty <= 0 || ty >= grid_height || by <= 0 
     || by >= grid_height) 
    {
      return true;
    }    
    // pre multiply the ys     
    cy *= grid_width;     
    by *= grid_width;     
    ty *= grid_width;        
    // N, W, E, S    
    if (occupancyMap[cx + ty] ||  occupancyMap[lx + cy] || occupancyMap[rx + cy] ||  occupancyMap[cx + by]) 
    {
      return false;       
    }
    // NW, NE, SW, SE    
    if (occupancyMap[lx + ty] ||  occupancyMap[lx + by] ||  occupancyMap[rx + ty] ||  occupancyMap[rx + by]) 
    {
      return false;      
    }      
    return true;
  }

  void draw()
  {
    fill(150,100);
    stroke(150,100);
    for (int x=0;x < grid_width;x++)
      for (int y=0;y < grid_height;y++)
      {
        fill((occupancyMap[y * grid_width + x]?1:0)*255+100);
        rect(x*colSize, y*rowSize, colSize, rowSize);
      }
  }
}

class Particle
{
  float x,y;
  color c;
  int particleSizeX,particleSizeY;
  Particle(int particleSizeX,int particleSizeY,color c,float x_pos, float y_pos)
  {
    x=x_pos;
    y=y_pos;
    this.c=c;
    this.particleSizeX=particleSizeX;
    this.particleSizeY=particleSizeY;
  }
  void draw()
  {
    stroke(c,150);
    fill(c,150);
    ellipse((int)(x),int(y),particleSizeX-2,particleSizeY-2);
  }
  void move()
  {
      x += random(-sqrt(2*particleSizeX),sqrt(2*particleSizeX));   
      y +=  random(-sqrt(2*particleSizeX),sqrt(2*particleSizeX));     
  }
}

A modified version that recycles particles, with a dipole: two sources where the particles are released.


click to start, this panel shows a process with variation of source distribution. initially source X delivers 86% and source Y 14% of particles, after some time both deliver 50% and then switch back to 86% and 14%


click to start, source distribution is constantly 86% on X and 14% on Y.

5.12.13 sensory deprivation the dark and the bright side


Donald Ewen Cameron


John Cunningham Lilly.

the dark side: controlling other peoples mind

While during the cold war the Russian secret service (KGB) employes claim they were reading dostojewski in order to understand and manipulate the human psyche, the american secret service feared the russians had developed advanced technology to manipulate human memories and methods to program human behavior. Out of these fears and imaginations (check for example the mandchurian candidate) the CIA developed their own program to manipulate memory and behavior called MKUltra. In the early fifties the CIA contacted Donald O. Hebb to inquire about whether it was possible that american soldiers that had been prisoners of war in Korea had been brainwashed.
Based on his postulate that nervous cells that fire together wire together Hebb imagined that taking away sensory stimulation could disrupt this process strongly. To test his hypothesis he did an experiment with volunteers, graduate students from Mc Gill University in Montreal. Only after 24 hours students reported hallucinations and discomfort. Donald O. Hebb stopped the experiments and concluded that sensory deprivation could be seen as a sort of torture. However Donald Ewen Cameron a colleague from Hebb at Mc Gill University continued experiments on sensory deprivation in collaboration with the CIA. Scientifically he was obsessed by the idea that he could heal people from psychic problems such as depression or schizophrenia by resetting people, which would mean to erase their old memories and traits of behavior and inscribing new behaviors and memories. Basically all these experiments were ethically beyond anything acceptable, instead of healing he was clearly torturing his patients combining sensory deprivation, deprivation from sleep, medical induced sleep and electroshock therapy. He referred to his own work as brain washing canadian style. This article shows how difficult it is to judge what is going on at a time. While in retrospect there is consent that Camerons experiments were torture, some of his patients have been compensated through official trials. The difficulty to judge persists. Electroshock therapy has changed its name to electroconvulsive therapy and is still applied today in cases of severe depression. It has changed insofar that the shock is elicited under anesthesia, however it has still large side-effects especially on memory. A recent meta study showed that there is no evidence for real effects of electroconvulsive therapy beyond a placebo effect. On the other hand there are reports explaining the effectiveness of electroconvulsive therapy.
Camerons experiments however being part of the MKUltra program did feed into the development of torture techniques. In here book the shock doctrine naomi klein reconstructs how these findings were turned into a torture manual with aim of producing a shock in the victim of torture. Based on this analysis she develops the hypothesis that the very same method of producing a shock were applied to whole countries in order to establish neo-liberalist economic structures.

cultural references

As strange as it may seem, there is a direct link from the CIA’s secret program MKUltra to some important cultural phenomena. Ken Kesey, for example, took part as volunteer in the MKUltra LSD experiments. Having experienced the mind-expanding properties of lsd he became a true psychedelic evangelist driving through the us with flower painted bus in company of the merry pranksters, organizing parties called acid tests, ultimately triggering what is referred to as the psychedelic era. Ken Kesey is also the author of the famous novel One Flew Over the Cuckoo’s Nest that has as subject the circumstances in psychiatric institutions in the early fifties and especially the application of electroconvulsive therapy against the will of the patients.
Another character from that era is Robert C. Hunter, one of the founders of the Grateful Dead. He took part in the lsd experiments in the MKUltra program.
In his movie the net the german artist lutz dambeck explores this connection between the cia program, the psychedelic counter culture and another figure who was involved in the MkUltra program Ted Kaczynski, also known as the unabomber.

An important book not related to the MKultra program but to the use of electroconvulsive therapy is the book Zen and the Art of Motorcycle Maintenance. In this book the author Robert M. Pirsig explores the metaphysics of quality and tries bring together what refers to as the romantic american counter culture movement and the classic academic scientific approach.

the bright side: floating with your own mind

John Cunningham Lilly
Neuroscientist & Psychonaut
a short report from Katharina Mayer.
John C. Lilly worked on

  • Sensory deprivation/Isolation Tank
  • Dolphins language and communication
  • States of consciousness, Beliefs and Reality
  • “Human Biocomputer”

a biographical sketch

  • 1942 Studies in neurophysiology, graduated medical doctor
  • Personal principle: “My body is my laboratory”
  • 1950’s National Institute of Health (NIMH)/Neurologic Diseases Electromagnetic brain stimulation without damage of the brain › Lilly Wave location of brains pain and pleasure centres
  • 1954 Sensory deprivation › Isolation Tank
    Brain activity independent of stimuli from the outside world
  • 1960’s leaving NIMH because of militaries interest of using the isolation tank
    for manipulative purposes. Started out with his research on Dolphin language and communication and therefore set up the Research Institute on St. Thomas in the Virgin Islands
  • 1970’s contact with the eastern meditation techniques, yoga etc.
  • Live long research on the depth of the mind, interspecies communication

The Isolation Tank

  • Experiment: complete isolation of the brain from all sensory stimuli
  • Results: Profound states of physical relaxation and parallel mind activation
    like colourful images, memories, waking dreams and new levels of consciousness
  • Brainwave transformation from Beta/Alpha to Theta waves.
    Theta waves occur when falling asleep and waking up. With the isolation tank one is able to be in that state without loosing consciousness.
  • Mind works as an inner projection screen: projection as a way of getting to know and to chance your personality as well as a dwell of creativity, problem solving, learning etc. States of Consciousness
    • fusion with universal mind, union with god, beeing one of the creators of energy of the void source of consciousness, energy, light and love, astral travel, clairvoyance
      blissful state, reception of divine grace, cosmic energy, heightened body awareness being in love, being in a positive LSD energy state
    • all needed programs are in the unconscious of the biocomputer, operating smoothly, self lost in in pleasurable activities
      neutral state for absorption, transmission and reception of new ideas, data and programs, doing teaching and learning
    • awareness only present in one own’s pain, unable to work
      fear, pain guilt in extreme, meaninglessness
      no hope of escape, lasting eternally even if it’s only a few seconds

“In the province of the mind, what one believes to be true is true or becomes true – within certain limits – to be found experientially and experimentally.
These limits are further beliefs to be transcended. In the mind, there are no limits.”
John. C. Lilly, Programming the Human Biocomputer p. 19
Source: John C. Lilly: Programming the Human Biocomputer, The Steersman, Center of the Cyclone

12.12.13 excursion floating


a floating tank

1. Qvm Antrag Pilotprojekt Floating

Literatur – Referenzen

28.11.13 models and algorithms of self organizing maps


one dimensional self organizing map that maps itself onto a circle, press ‘r’ to reset

05.12.13 process based art


metronomic irregularity I, Eva Hesse 1966.

16.01.14 philosophy: Catherine Malabou’s What to do with our brains?

06.02.14

literature references

Driemeyer J, Boyke J, Gaser C, Büchel C, May A (2008) Changes in Gray Matter Induced by Learning—Revisited. PLoS ONE 3(7) link
Boyke, J., Driemeyer, J., Gaser, C., Büchel, C., & May, A. (2008). Training-induced brain structure changes in the elderly. The Journal of neuroscience, 28(28), 7031-7035. link