This is a crude simulation of neurons. The objective is to refine it until I get something that more plausibly reflects reality -and perhaps even results in some sort of limited thought or learning.

The background displays the local activation in any given area. When a neuron fires, it deposits positive (or potentially negative) activation near the synapse points on the canvas. The background is constantly smoothed so that the activation values are spread out. This allows the values to fade, and it also creates a gradient that dendrites can detect and follow to be able to seek out new connections.

Dendrites seek out areas of higher activation values. There are currently only four for each neuron, but there is room for addition of more.

Axons are not currently drawn, but you can see where they are when the neuron fires; you'll see faint dots appear and fade.'Like the dendrites, there are 4 axons and it could be possible to add more and not have to re-code the while project. Currently, axons do not seek out dendrites.

Neurons are currently randomly created and placed on the canvas. The body of each neuron is represented with a colored dot. I have experimented a little with neuron mobility, however, the issue right now is that the neuron's own synapses guide it away from it's own activations when it fires. The leads to all the neurons moving mostly in one direction. Each neuron has an internal clock that prevents it from firing for a short period after firing. This helps prevent neurons from connecting to themselves in infinite activation loops.

What's left to do: So far the framework is in place to do what I think needs done. However, the specific conditions to trigger the various responses need to be identified and coded. One way to identify the right conditions is to ask the right questions. Here are a few questions to start out:

• How do dendrites and axons determine which connections to form? Clearly, a neuron cannot just try to greedily connect to any activation source. Answering this will help to decide if new dendrites or axons need to be created.
• How does a neuron determine that it needs to have an inhibitory response? This may be related to the prevention of infinite activation loops, and, in general as a logical NOT operator.
• When should new neurons be created?

Interactivity: I do plan to add some controls so that people can play around with it and do their own experiments. Then I hope to get feedback, which will help me improve it.

Flow Graph Overview

1. Initialization Process

   • Start ➔
     • Load Page ➔
     • Call restart function ➔
       • Set nueronCount and clock values from user input.
       • Initialize canvas and context (ctx).
       • Create an empty list nodes to store neurons.
       • Randomly Generate Neurons ➔
         • Loop to create neurons using makeNeuron at random positions.
       • Setup Event Listeners ➔
         • Enable users to add new neurons by clicking on the canvas.
       • Start Timers ➔
         • Use setInterval to regularly call go (main update loop) and dataIn (periodic input of data).

2. Neuron Creation (makeNeuron)

   • Input ➔ Coordinates (x, y) where neuron is to be placed.
   • Define Axons and Dendrites
     • Create arrays representing axon and dendrite positions relative to the neuron.
     • Set Initial Values ➔ val = 0
   • Output ➔ Return a neuron object { val, ax, dn, x, y }.

3. Periodic Data Input (dataIn function)

   • Check Flip-Flop State ➔ Determines data pattern (alternating input pattern).
   • Draw Activation Blobs
     • Use drawBlob to input activation values at specific points on the intensity map.
   • Flip State ➔ Switch flipflop state for the next cycle.

4. Main Update Loop (go function)

   • Call drawPotential
     • Update neuron positions based on their environment.
     • Calculate and adjust neuron activation based on input from axons and dendrites.
     • Move neurons based on gradients using functions like moveBy.
   • Apply Visual Effects
     • Blur ➔ Call blur to smooth the intensity map.
     • Render ➔ Draw neurons and activation gradients onto the canvas.

5. Neuron Activation and Movement (drawPotential function)

   • Loop Through All Neurons (nodes)
     • Assess Neuron Position
       • Move Neurons ➔ Adjust position based on space values using sign, moveBy, and gradient functions.
     • Calculate Activation (getWeights)
       • Check Threshold ➔ If activation exceeds threshold, neuron "fires":
         • Send signals through axons (set activation values).
         • Reset neuron value.
         • Reduce activation around the neuron with decreaseBy.
     • Adjust Axons and Dendrites
       • Axons ➔ Move towards lower activation areas using goToLower.
       • Dendrites ➔ Move towards higher activation areas using goToHigher.
     • Clean Activation Around Neurons
       • Call cleanArea ➔ Reset local activation to default values.

6. Canvas Rendering (render function)

   • Draw Activation Gradient
     • Generate ImageData ➔ Use activationGradiant to translate intensity values into color gradients.
     • Draw Neurons
       • Loop Through nodes ➔ Draw connections (axons, dendrites) and neuron bodies using color codes to indicate active or resting states.

7. Adjust Environment Interaction (utility.js)

   • Helper Functions
     • put, drawBlob, decreaseBy ➔ Manipulate activation values in the intensityMap.
     • Gradient Functions ➔ Move to higher or lower activation areas using sign, goToHigher, goToLower.
   • Intensity Manipulation
     • Blur (blur function) ➔ Smooth activation values to simulate diffusion.
     • Control Activation Spread ➔ Functions to adjust local gradients around neurons.

Dall-E's attempt to draw flow chart of code

* Not very good at spelling.

What might be missing?

* The following is only AI's opinion. Some details are bassed on the way Artificaial neural networks function, so, may not be applicable. Other details may already be implemented in an indirect way. The AI may not have noticed the implications of my methods.

1. Complex Synaptic Connections

• Synaptic Weight Adjustment
  • Currently, your simulation processes simple activations, but real neurons adjust the strength of their synaptic connections based on activity (a concept called synaptic plasticity). Implement mechanisms like:
    • Hebbian Learning ("cells that fire together, wire together")
    • Long-Term Potentiation (LTP) and Long-Term Depression (LTD)
    • Adjust synaptic weights based on past activity, allowing the network to learn and adapt over time.
• Excitatory and Inhibitory Synapses
  • Real neurons use a balance of excitatory (increasing the chance of firing) and inhibitory (decreasing the chance of firing) inputs. Introducing inhibitory connections can lead to more nuanced and controlled behaviors.

2. Refractory Periods and Spike Timing

• Refractory Period
  • After firing, real neurons have a refractory period during which they cannot fire again. Adding this would prevent continuous firing and mimic natural neuron behavior.
• Spike-Timing Dependent Plasticity (STDP)
  • Implementing timing-dependent adjustments to synaptic strength can create more realistic dynamics. Neurons adjust synaptic weights based on the precise timing of spikes relative to each other, which is crucial for learning in biological systems.

3. Neurotransmitter Release and Diffusion

• Chemical Transmission Mechanism
  • Instead of just electrical signals, real neurons communicate by releasing neurotransmitters (chemical messengers) across synapses. You can introduce a concept of "chemical packets" that diffuse across a synaptic gap and initiate the activation in the next neuron.
• Variety of Neurotransmitters
  • Different neurotransmitters can have varying effects, some being excitatory (e.g., glutamate) and others inhibitory (e.g., GABA). Adding different neurotransmitters would allow for more diverse behaviors.

4. Membrane Potential Dynamics

• Action Potential Simulation
  • Real neurons generate action potentials (spikes) when the membrane potential reaches a certain threshold. Simulating the buildup of membrane potential, with depolarization and repolarization phases, would make the model more realistic.
  • Voltage-Gated Ion Channels: Add mechanisms where ion channels open or close based on the neuron’s membrane potential, controlling when the neuron can fire.
• Leak Channels and Resting Potential
  • Incorporate mechanisms that maintain a stable resting potential and leak channels that allow small, continuous ion flow, helping maintain the neuron's baseline state.

5. More Sophisticated Dendritic Processing

• Dendritic Spikes and Local Processing
  • Real neurons can process information locally within the dendrites, generating small, local spikes that do not always lead to full neuron firing. You could add processing units on dendrites that react to inputs independently, adding complexity to the neuron’s response.
• Branching Dendritic Trees
  • Expand the dendritic structure to include branching trees that can receive inputs from multiple locations, each affecting the neuron’s overall behavior.

6. Neuron Types and Differentiation

• Diverse Neuron Types
  • Real neural networks consist of different types of neurons (e.g., pyramidal cells, interneurons) with varying properties. Introducing multiple neuron types in your simulation, each with distinct functions, firing patterns, and connections, can make it more lifelike.
• Specialized Neural Circuits
  • Create groups of neurons that form circuits with specific tasks (e.g., sensory processing, pattern recognition, inhibitory loops) to simulate more complex, brain-like behavior.

7. Learning Mechanisms and Feedback Loops

• Reinforcement Learning
  • Implement reward-based learning where certain connections get strengthened when desired outcomes are achieved, similar to how the brain adapts through reward and feedback.
• Backpropagation or Similar Learning Mechanisms
  • Allow the network to optimize itself over time by adjusting synaptic weights using principles akin to backpropagation found in artificial neural networks, but more biologically plausible methods like SpikeProp or Hebbian learning.

8. Temporal Dynamics

• Spike-Rate Coding vs. Temporal Coding
  • Your current simulation likely relies on activation levels to determine behavior. Real neurons also use the timing and rate of spikes to encode information. Adding variability in spike timing and patterns (temporal coding) could improve the simulation.
• Oscillatory Behavior
  • Real neural networks exhibit oscillations (e.g., theta waves, gamma waves) that play a role in information processing and coordination across brain regions. Introducing such rhythmic activity could provide more synchronized, realistic behaviors.

9. Energy Constraints and Metabolism

• Energy Use and Efficiency
  • Real neurons are energy-constrained, meaning they try to operate efficiently. Incorporate a form of energy expenditure and recovery, influencing how often a neuron can fire. This could add layers of realism, especially when simulating prolonged activity or fatigue effects.

10. Noise and Stochasticity

• Random Fluctuations
  • Biological neurons are influenced by random fluctuations and noise in their environment. Introducing some stochastic behavior in firing patterns can create a more realistic and dynamic simulation.
• Random Synaptic Variability
  • Allow for small variations in synaptic strength and response times to simulate natural biological variation.