\documentclass[letterpaper]{article}
usepackage{iccm}
\usepackage{curves}
\usepackage{times}
\usepackage{helvet}
\usepackage{courier}
\begin{document}

\title {Counting with Neurons: Rule Application with Nets of Fatiguing 
        Leaky Integrate and Fire Neurons}
%\author {\\
\author {\bf {Christian R. Huyck (c.huyck@mdx.ac.uk) and 
              Roman V. Belavkin (r.belavkin@mdx.ac.uk)} \\
Middlesex University, London NW4 4BT, UK
} 

\maketitle

\begin{abstract} 
This paper shows a system that performs simple symbolic processing.
The system is based entirely on fatiguing Leaky Integrate and Fire
neurons, a coarse model of neurons.  Following Hebb, the symbols are
encoded by neurons that form Cell Assemblies.  Additionally simple
rules of the form $if X \rightarrow X+1$ are encoded by Cell
Assemblies, and this symbolic computation is performed.  Finally, a
more complex rule $while X < F \rightarrow X = X+1$ is encoded using
variable binding via a compensatory learning rule.  This rule performs
the symbolic computation of counting entirely subsymbolically. 
The binding can be erased and reused via spontaneous neural activation.
Unlike the symbolic parallel, the counting rule fails at times when humans 
might fail.
\end{abstract}
\section {Introduction} 

Neurons have inspired a range of connectionist models including 
multi-layer perceptrons, self-organising maps, and Hopfield nets.  These
connectionist models are useful for a range of tasks, but they make
simplifications that may invalidate them as neural models.  For example,
most multi-layer perceptron (MLP) systems learn by the supervised algorithm
of error back propagation, while neural learning is unsupervised.  
One work, \cite {Wiles}, manages to count with a recurrent MLP network,
though it is not clear how this dynamical systems model relates to
neural processing.

There is a wide range of models of neurons, but they are usually used
to model neural behavior and are rarely used for higher cognitive
tasks.  This paper describes a system based on model neurons that
simulates a simple symbolic processing task.

There are a range of cognitive architectures based around rules
(e.g. ACT--R \cite{Anderson}, SOAR \cite {Laird}, and EPIC \cite
{Kieras}).  These have proven quite successful in modelling
psychological data and for applications. 

An alternative approach to the rule based model is a neural model.
Neural models are more accurate descriptions of biological neurons
than other connectionist models. It is unclear how or even if
cognition is implemented by rules.  It is however clear that cognition
can be achieved by neurons.  The unanswered question is how cognition
is generated by neurons.

The scientific community has a sound if incomplete understanding of
the function of biological neurons, but there is much less 
known about how they work together.  This is at least partially due to
the difficulty of inspecting a large number of neurons in a functioning
animal.  Scanning techniques, such as fMRI, are too coarse to view
individual neural behavior.  So computational modelling is a good method
to explore large numbers of neurons working together.  

While there have been advances in implementing ACT--R in a connectionist
system \cite {Anderson}, it is not clear how it would be implemented
in a neural system.  In particular, it is not clear how the connections
between the neurons could be learned.  

There is a long-standing neurally based psychological theory.  Hebb
proposed Cell Assemblies (CAs) as the basis of human thought over 50
years ago \cite {Hebb}.  There has been little large scale
modelling of CA using neurons.  While it is relatively well
understood how to categorise inputs using CAs and other attractor
networks, it is not clear how more sophisticated processing can be
done.  For instance, it is not well understood how symbolic
processing can be implemented with CAs.

In this paper we describe a neural system that simulates a form 
of symbolic processing.  Simple arithmetic is a common symbolic task.  
The simulations first implement a series of simple rules that
perform an add one calculation.  This requires rules that only 
use Input CAs that represent constants.  These simple rules are then 
used as a basis for a second series of simulations that count.
This counting makes use of variable binding.

The simulations are based on fatiguing Leaky Integrate and Fire (LIF)
neurons, a reasonable model of biological neurons.  These simulations
show a neural implementation of two sorts of rules.  Simple rules
involving primitives are used to add.  A complex rule using variable
binding is used along with the simple rules to count.  Later bindings
are affected by earlier bindings and may lead to problems in counting
that might be exhibited by a human.

The paper initially gives a background of work on CAs.  There is
then a description of the simple rules, followed by a description of
the system that counts.  These sections are written for the uninitiated
neural modeller and are followed by a section that specifies details
of the model.  The paper concludes with a discussion.


%Connectionist systems, such as Multi-Layer Perceptrons trained with
%the backpropagation algorithm, have been able to model some data, but
%less than ACT \cite {Anderson2}.  

\section {Background}
Hebb proposed CAs as the basis of human thought \cite {Hebb}, and
there has been a long history of work based around CAs
(e.g. \cite{Sakurai,Palm}).  The basic idea is that concepts are
represented by groups of neurons, called CAs, that have high mutual
synaptic strength.  If enough of these neurons fire, a cascade of
neuronal firing causes the reverberating circuit to remain active;
this is called CA ignition.  After the stimulus ceases, the circuit
can still remain active via this reverberating activity.

There are a wide range of benefits of the CA model.  Perhaps the most
powerful benefit over rule based models is symbol grounding \cite
{Fodor}; symbols can be learned from the environment and thus have a
basis.

Hebb's main argument for this type of model was figure-ground
separation.  CAs are ignited for particular items in the environment
(figures) making them more salient, and these salient figures can then
be separated from the background.  

A third advantage is that CAs give a neurally based explanation for
long and short-term memory.  A short-term memory is the ignition and
persistence of a CA; as long as the activity persists the memory is
active.  Long-term memories happen when the CA is formed via synaptic
weight adjustment.

A CA is an attractor state; most configuration of neural activations
never occur.  Instead, when neurons are activated, particular neural
activation patterns are preferred. These patterns or states are called
attractor states.  A CA is an attractor state.  So, a network of
fatiguing LIF neurons is an attractor net.  There has been significant
work with attractor nets such as Hopfield nets \cite {Hopfield}, and
these attractor nets have been used to model the brain \cite {Amit}.

Attractor nets, and thus nets of fatiguing LIF neurons, are good
at categorisation.  An initial state is given to the network, and
it settles into a stable state that represents the category of 
the initial input.  

Unfortunately, there has been little work with getting attractor nets
to do more than categorise.  A notable recent exception has a CA
based system being used for robots that have visual and textual input
\cite {Knoblauch}.

While there has been a long history of CA-based models that account
for psychological phenomena, there has been little work in developing
large scale neural simulations of CA activity.  These systems are
based on idealised models of CA behavior.  A good example of such a
model is the TRACE system \cite {Kaplan}.  Another model shows how a
letter matching task might be done \cite {Dalenoort}.

The system described below can be thought of as a bridge from older
idealised CA models for psychological tasks to neural processing models
of CAs.  The neural models are capable of learning symbols based
on environmental stimulus \cite {Braitenberg,Huyck2,Palm,Sakurai}.

\section {Simple Rules} 

It may not be clear to those who commonly develop software using
rules, but there are different types of rules.  In this section, a
system that implements several simple rules of the form $if 1+2
\rightarrow 3$ is presented.  In the next section an extension that
counts is presented.  The simulations use fatiguing LIF neurons.
There has been considerable interest in LIF neurons (e.g. \cite {Tal}),
though comparatively little work has made use of fatigue.  The model
we use is a relatively simple model of neurons, but to a large degree
it is biologically plausible.

The simulation sections are written for the neural model novice.
Details of the model and simulations are provided in the section 
entitled Details of the Model.  

In the simple rule simulation, there are four networks used in the
process of rule application, called the Input, Internal, Rule and Done
nets.  Each contains neurons (between 200 and 2600), and these neurons
form CAs (between 1 and 13).  Figure \ref {Fig1} represents the
relationships between these networks.  Arrows represent excitatory
activation and forks represent inhibition.

The general flow of control of the simulation is: 
\begin {enumerate}

\item {The Input net is activated from the environment igniting CAs in it.}
\item {The Input net passes activation onto the parallel Internal net,
igniting parallel Internal CAs; the Internal net is used to store
later internal state.  }
\item {The Internal CAs send activation along to the Rule net; a Rule
CA ignites if the Internal net has the antecedent (if) CAs active. }
\item {The ignited rule CA sends activation to the consequent (then)
Internal CA, suppresses the antecedent CAs, and sends activation to the
Done network.}
\item {The Done network has one CA that suppresses the Input and Rule nets.}
\item {The consequent Internal CA also suppresses the Rule CA that ignited it.}
\item {The result of the interactions is that the consequent CA is left
running, the Done CA is left running, and all other CAs are turned
off.}
\end {enumerate}

\begin{figure}
\begin{picture}(150,150)(-25,00) 
%the -25 pushes in right centering it a bit

%input box
\put(0,110){\line(1,0){100}}
\put(0,110){\line(0,1){30}}
\put(100,140){\line(-1,0){100}}
\put(100,140){\line(0,-1){30}}
\put(2,130){\texttt{{\bf Input}}}
\put(2,120){\texttt{{\bf Network}}}

%internal box
\put(0,60){\line(1,0){100}}
\put(0,60){\line(0,1){30}}
\put(100,90){\line(-1,0){100}}
\put(100,90){\line(0,-1){30}}
\put(2,80){\texttt{{\bf Internal}}}
\put(2,70){\texttt{{\bf Network}}}

%rules box
\put(0,10){\line(1,0){100}}
\put(0,10){\line(0,1){30}}
\put(100,40){\line(-1,0){100}}
\put(100,40){\line(0,-1){30}}
\put(2,30){\texttt{{\bf Rules}}}
\put(2,20){\texttt{{\bf Network}}}

%done box
\put(120,60){\line(1,0){50}}
\put(120,60){\line(0,1){30}}
\put(170,90){\line(-1,0){50}}
\put(170,90){\line(0,-1){30}}
\put(122,80){\texttt{{\bf Done}}}
\put(122,70){\texttt{{\bf Network}}}

%input to internal
\put(55,110){\vector(0,-1){20}}

%internal to rule
\put(20,60){\line(0,-1){17}}
\put(20,35){\arc(5,5,30){90}}
\put(35,60){\vector(0,-1){20}}

%rule to internal 
\put(80,40){\line(0,1){17}}
\put(80,65){\arc(-5,-5,30){90}}
%\put(80,50){\line(1,1){10}}
%\put(80,50){\line(-1,1){10}}
\put(65,40){\vector(0,1){20}}

%done to input
\put(140,90){\line(-1,1){37}}
\put(96,127){\arc(5,-5,30){90}}

%done to rules
\put(140,60){\line(-1,-1){37}}
\put(96,22){\arc(5,-5,30){90}}

\end{picture}
\caption{Simple Rule Topology }\label{Fig1}
\end {figure}

There are 13 CAs in the Input network, 13 in the Internal network,
10 in the Rule network, and one in the Done network.  The Input and
Internal CAs correspond to the numbers $1$ to $12$ and the $+$ sign.
The 10 rules correspond to $if 1+2 \rightarrow 3$ through $if 1+11
\rightarrow 12$.  

For example, neurons in the $1$, $2$, and $+$ Input CAs are externally
activated. This causes a cascade of activation within these CAs leading
to many neurons firing in each step.  After 10 steps, external activation
is removed. If the Internal net were isolated, those CAs would continue
to run indefinitely.  Activation is passed from the Input $1$, $2$, and $+$ 
CAs to the $1$, $2$, and $+$ Internal CAs causing them to ignite.  
In turn activation is passed from the ignited Internal CAs to the Rule
net.  Since the $1$, and $+$ CAs are active and they are antecedents of
all of the rules, all of the rules receive some activation.  Inhibitory 
connections between the Rule CAs causes the rules to compete.  As the
$if 1+2 \rightarrow 3$ rule is the only one with three antecedents active, 
it receives more activation than other rules and wins the competition and
it ignites.

When the $if 1+2 \rightarrow 3$ CA ignites, it sends activation to the
$3$ Internal CA and also inhibits the Internal $1$, $2$, and $+$ CAs.
More or less simultaneously, the done CA ignites and the $3$
Internal CA ignites.  Next, the Done CA turns off the Input $1$, $2$,
and $+$ CAs, while the Internal $3$ CA inhibits the Internal $2$ CA.
The combination of fatigue in its own neurons, loss of activation from
the Input net, and suppression from the Internal $3$ and Rule CA causes
the $1$, $2$, and $+$ Internal CAs to shut down.  Finally, the inhibition
from the Internal $3$ and Done CAs causes the $if 1+2 \rightarrow 3$ 
Rule CA to shut down.  

Figure \ref {Fig2} shows this process. It shows the number of neurons
firing per cycle for the described CAs.  Note that some neurons in the 
second rule fire, but the CA is suppressed by the first rule when it 
ignites.

\begin{figure}
\input{fig2a.tex}
\vspace{-0.25 in}
\input{fig2b.tex}
\vspace{-0.25 in}
\input{fig2c.tex}
\vspace{-0.25 in}
\input{fig2d.tex}
\caption{Neural Activity in different networks for $1+2 \rightarrow 3$ } \label{Fig2}
\end {figure}


\section {Counting using Rules with Variable Binding} 

The simple rules are used as the basis of a more complex system that
counts from one variable to another.  For example, the system may 
count from 3 to 6, and the same system can be reused to count
again from 4 to 9.  

The simple rule topology is augmented with three new nets, Bind,
Finish, and Reset.  This topology is shown in Figure \ref {Fig3}. The
line between the Bind and Internal networks represents learned
connections in both directions.  The simple rule architecture from
Figure \ref {Fig1} forms the core of this topology. As with Figure
\ref {Fig1}, arrows represent excitation and forks inhibition.

\begin{figure}
\begin{picture}(150,150)(-50,00) 
%the -25 pushes in right centering it a bit

%input box
\put(50,110){\line(1,0){50}}
\put(50,110){\line(0,1){30}}
\put(100,140){\line(-1,0){50}}
\put(100,140){\line(0,-1){30}}
\put(52,130){\texttt{{\bf Input}}}
\put(52,120){\texttt{{\bf Network}}}

%internal box
\put(50,60){\line(1,0){50}}
\put(50,60){\line(0,1){30}}
\put(100,90){\line(-1,0){50}}
\put(100,90){\line(0,-1){30}}
\put(52,80){\texttt{{\bf Internal}}}
\put(52,70){\texttt{{\bf Network}}}

%rules box
\put(50,10){\line(1,0){50}}
\put(50,10){\line(0,1){30}}
\put(100,40){\line(-1,0){50}}
\put(100,40){\line(0,-1){30}}
\put(52,30){\texttt{{\bf Rules}}}
\put(52,20){\texttt{{\bf Network}}}

%done box
\put(120,60){\line(1,0){50}}
\put(120,60){\line(0,1){30}}
\put(170,90){\line(-1,0){50}}
\put(170,90){\line(0,-1){30}}
\put(122,80){\texttt{{\bf Done}}}
\put(122,70){\texttt{{\bf Network}}}

%input to internal
\put(70,110){\vector(0,-1){20}}

%internal to rule
\put(60,60){\line(0,-1){17}}
\put(60,35){\arc(5,5,30){90}}
\put(70,60){\vector(0,-1){20}}

%rule to internal 
\put(90,40){\line(0,1){17}}
\put(90,65){\arc(-5,-5,30){90}}
%\put(80,50){\line(1,1){10}}
%\put(80,50){\line(-1,1){10}}
\put(80,40){\vector(0,1){20}}

%done to input
\put(140,90){\line(-1,1){37}}
\put(96,127){\arc(5,-5,30){90}}

%done to rules
\put(140,60){\line(-1,-1){37}}
\put(96,22){\arc(5,-5,30){90}}

%bind box
\put(-20,110){\line(1,0){50}}
\put(-20,110){\line(0,1){30}}
\put(30,140){\line(-1,0){50}}
\put(30,140){\line(0,-1){30}}
\put(-18,130){\texttt{{\bf Bind}}}
\put(-18,120){\texttt{{\bf Network}}}

%finish box
\put(-20,60){\line(1,0){50}}
\put(-20,60){\line(0,1){30}}
\put(30,90){\line(-1,0){50}}
\put(30,90){\line(0,-1){30}}
\put(-18,80){\texttt{{\bf Finish}}}
\put(-18,70){\texttt{{\bf Network}}}

%reset box
\put(-20,10){\line(1,0){50}}
\put(-20,10){\line(0,1){30}}
\put(30,40){\line(-1,0){50}}
\put(30,40){\line(0,-1){30}}
\put(-18,30){\texttt{{\bf Reset}}}
\put(-18,20){\texttt{{\bf Network}}}

%bind to finish
\put(0,110){\vector(0,-1){20}}

%finish to bind
\put(10,90){\vector(0,1){20}}

%finish to reset
\put(5,60){\line(0,-1){17}}
\put(5,35){\arc(5,5,30){90}}

%bind to internal
\put(30,110){\line(1,-1){20}}

%reset to internal
\put(30,40){\vector(1,1){20}}

\end{picture}
\caption{Topology of the Counting System}\label{Fig3}
\end {figure}



Initially, the final value is remembered by the system by
presenting it to the Input network, and stimulating the Finish CA.  
Later this value is erased by spontaneous activation.

When counting starts, the initial value is presented to the Input Network
and the Reset CA is stimulated.  Both Reset and Finish nets have one
CA each.  The Reset CA sends activation to the Internal $1$ and $+$ CAs
causing them to ignite.  The ignited Internal CAs activate rules, which 
turn off the Internal $1$ and $+$ CAs, and ignite the subsequent CA.
The reset net is still on, so the Internal $1$ and $+$ CAs come on again
and the process is repeated until the final Internal CA is ignited.

The initial presentation of the Finish CA causes the Bind CA to
ignite.  The Bind CA has connections to and from the Finish CA and the
Internal network.  The only part of the system that learns is the Bind
network and the connections to and from the Internal and Finish
networks.  As the Bind CA is now active it learns becoming associated
with the final Internal CA. This learning is unsupervised and is 
based on neural co-firing. So, when the final Internal CA comes on,
the Bind CA and thus the Finish CA comes on.

The Finish CA has strong inhibitory connections to the Reset CA in
addition to connections to the Bind CA.  So when the Finish CA ignites,
it shuts down the Reset CA, and the process stops.  

After this process, the binding is partially erased to enable the
system to count again.  This is done by spontaneous activation in the
Internal and Bind Networks.  The Bind network has two components
with an equal number of neurons.  The Bind CA and another component
that does not actually reverberate and is thus not a CA.  This extra 
component acts as a synaptic strength sink.  

Our simulations use a form of Hebbian learning called compensatory learning
\cite {Huyck2}.  As with all Hebbian learning, excitatory
synapses are strengthened when the neurons they connect fire simultaneously.
An anti-Hebbian learning rule is also used so that the excitatory 
synapses are weakened if only the presynaptic neuron fires without the
postsynaptic neuron firing.  The compensatory learning rule forces the
total synaptic strength of a neuron toward a predefined constant value.
There are parallel rules for inhibitory neurons so that co-firing inhibitory
synapses are reduced toward zero becoming less inhibitory.

During spontaneous activation, a neuron in the bound Internal CA may
fire while a neuron in the Bind CA it is connected to does not. This
weakens that connection.  Additionally, the bound Internal neuron may
be connected to a neuron in the other part of the Bind network.  If
this neuron also fires, it will remove synaptic strength that may be
used for a new binding.  Spontaneous neural firing is a property of 
biological neurons \cite {Bevan,Abeles}.  Related work with fatiguing
LIF neurons indicates that spontaneous neural activation has useful
properties for CA systems \cite {Huyck} and can be used for variable
binding \cite {Huyck-VB}.

For example the system counts from 3 to 6.  Initially, Finish and the
Input 6 CA are externally stimulated causing the input 6, internal 6,
Finish and Bind CAs to ignite.  As Bind and Internal 6 CA neurons are
frequently co-active, the synaptic strength between them is increased.

After binding, the system starts by activating the Internal $3$, and
the Reset CA.  Reset activates the Internal $1$ and $+$ CAs igniting
them.  This in turn activates the $if 1+3 \rightarrow 4$ Rule CA, and
as in the prior section the Internal $4$ CA comes on.  Again as in the
prior section, Done comes on, the Input layer is shut down, the Rule CA
is shut down and the Internal $1$, $3$, and $+$ CAs are shutdown.

The Reset CA again ignites the Internal $+$ and $1$ CAs leading to
the rule igniting followed by the Internal $5$ CA igniting.  This
process repeats itself until the Internal $6$ CA comes on.  As this is
bound to the Bind CA and the Bind CA activates the Finish CA, they
both come on.  The Finish CA suppresses the Reset CA turning it off.
The process then ceases. 

Figure \ref {Fig4} shows an example of neural activity.  It shows the
neurons firing per cycle in the 3 to 6 Internal CAs during counting from 3
to 6. Activity in the  $1$ and $+$ CAs are not shown.

\begin{figure}
\input{fig4.tex}
\caption{Selected Activity in the Count System Counting from 3 to 6}\label{Fig4}
\end {figure}

The binding is then erased by spontaneous activation. The system can
then be reused for further counting for example from 4 to 9. This
process usually succeeds, but interestingly, it fails occasionally by
stopping at 6.  This is sensible because the system stops an earlier
binding that should have been erased.  This shows a typical error
subjects manifest during various symbolic tasks.

\section {Details of the Neural and Network Model} 
\label {sec-Details}

The basis of the model is fatiguing LIF neurons.  Neurons collect
activation from other neurons via synaptic connections.  If the neuron
does not fire some of that activation leaks away.  Equation 1
describes the activation of a neuron $i$ at time $t$ if it does not
fire at time $t-1$.

$A_{i_t} = {{A_{i_{t-1}}}\over d} + \sum_{j \in V_i} w_{ji}, 0 < d < 1$
\hfill (1)

\noindent The amount of leak is $d$.  $V_i$ is the set of all neurons
that have connections to $i$ and fire at time $t-1$.  The weight, or
synaptic strength, of the connection from neuron $j$ to neuron $i$ is
$w_{ji}$.

Neurons also fatigue so that the more steps they fire the more
difficult it becomes for them to fire.  This is modelled by increasing
the activation threshold $\theta$ if a neuron fires as described by Equation 2.

$\theta_t = \theta_{t-1} + F_c$  \hfill (2)

\noindent In Equation 2 the threshold $\theta$ at time {\it t} is set
to the threshold at time {\it t-1} + the fatigue constant $F_c$. If
the neuron does not fire, the threshold is reduced toward the base
resting level as in Equation 3. 

$\theta_t = \theta_{t-1} - F_r$ \hfill (3)

\noindent The threshold is reduced by the fatigue recovery constant
$F_r$ though it never becomes less than $\theta$.  So a neuron fires
if it has more activity than the threshold plus accumulated fatigue.
If it fires, it loses all activity.

In this system, neurons may be inhibitory or excitatory, but they obey
Dale's principle \cite {Eccles} so that a neuron cannot have both
inhibitory and excitatory synapses leading from it.  The ratio is
usually 80/20 excitatory/inhibitory as in the mammalian cortex \cite
{Braitenberg}.

The fatiguing LIF parameters are described in Table 1.  The first
major difference between nets is that the Done network is largely
inhibitory because it is used to suppress other networks.  The Bind
network has a larger threshold and a slightly larger leak factor to
make it more tolerant to input noise.

\begin {table} [ht]
\begin{center}
\begin {tabular}{c | c  c c c c }
Network& $\theta$ & $d$ & $F_c$ & $F_r$  & Inhibition  \\
\hline
Input    & 4 & 1.5 & 1.0 & 2.0  & 20\%\\
Internal & 4 & 1.5 & 1.0 & 2.0  & 20\%\\
Rules    & 4 & 1.5 & 1.0 & 2.0  & 20\%\\
Done     & 4 & 1.5 & 1.0 & 2.0  & 80\%\\
Finish   & 4 & 1.5 & 2.0 & 2.0  & 20\%\\
Bind     & 6 & 2.0 & 2.0 & 2.0  & 20\%\\
Reset    & 4 & 1.5 & 2.0 & 2.0  & 20\%\\
\end {tabular}
\\
\vspace {0.1 in}
Table 1: Fatiguing LIF Parameters by Network
\end {center}
\end {table}


Synaptic weights are modified by a compensatory Hebbian learning rule
described by Equations 4 and 5 (see \cite{Huyck2}).  Equation 4 is applied when neurons
$i$ and $j$ fire in the same cycle.  Equation 5 is an anti-Hebbian
rule applied when the presynaptic neuron $i$ fires and the
post-synaptic neuron $j$ does not.

$\Delta^+ w_{ij} = (1 - w_{ij}) * R * 5^{(W_B-W_i)}$ \hfill (4) 

$\Delta^- w_{ij} = (w_{ij}) * -R * 5^{(W_i-W_B)}$ \hfill  (5)

\noindent The learning rate is a constant $R$ (0.1 in these
simulations), and the first two terms of both rules are the standard
correlatory learning rules.  The compensatory modifier is the last
term.  $W_B$ is a constant which represents the average total synaptic
strength of the pre-synaptic neuron, and $W_i$ is the current total
synaptic strength. This modifier forces the total synaptic weight of a
neuron toward $W_B$.

Synaptic weights for most nets and connections between nets are
calculated before hand.  The only case where they are learned is
within the Binding network, between the Binding and Finish
networks, and between the Binding and Internal networks. The target
synaptic weight, $W_B$, for the Bind network is 30, for the
Finish network is 35, and for the Internal
network is 15.

\begin {table} [ht]
\begin{center}
\begin {tabular}{c | c  c c c c }
&  CAs & Synapses & Inter-CA & Intra-CA    \\
\hline
Input    & 13 & 150 & 1.0\dag/-0.01  & 0.01/-0.12\\
Internal & 13 & 150 & 1.0\dag/-0.01  & 0.01/-0.12\\
Rules    & 10 & 150 & 1.2\dag/-0.01  & 0.01/-4.0\\
Done     & 1  & 150 & 1.0\dag/-0.01  & none\\
Finish   & 1  & 30  & 1.0\dag/-0.01  & none\\
Bind     & 1\ddag & 50 & learned & learned  \\
Reset    & 1  & 30  & 1.0\dag/-0.01  & none\\
\end {tabular}
\\
\vspace {0.1 in}
Table 2: Topology within Nets
\end {center}
\end {table}

The topology within nets can be described by Table 2.  All CAs consist
of 200 neurons and they are orthogonal, no neuron is in two CAs.  The
Input net has 13 CAs and thus 2600 neurons.  Each neuron has 150
synapses to other neurons in the net.  These neurons are connected
randomly, though a neuron cannot connect to itself.  The weights are
predetermined, so a neuron in a CA has a connection to another neuron
in the same CA with weight 1
if it is an excitatory neuron or -0.01 if it is inhibitory.
Connections to other neurons outside the CA have a 0.01 or -0.12
weight.  There are two caveats within this table.  The Inter-CA
connections marked by \dag have an weight of this number.  The 1.0
number (e.g. Input) is calculated by 1.5 - a random number between 0
and 1, and the 1.2 number in Rules is 1.7 minus a random number
between 0 and 1.  The second caveat, as described in the section on
counting and denoted by \ddag, is that the Bind net has one CA, but also
has an additional 200 neurons that never form a CA; these extra neurons
act as activation sinks during unbinding.

Table 3 describes the number of synapses per neuron from
one net to another.  The presynaptic net is in the column,
and the postsynaptic net the row.  So, each Input neuron has
50 connections to the Internal network.  All of these
are randomly assigned. The connections within a net are marked
by * and are described in table 2.

\begin {table} [ht]
\begin{center}
\begin {tabular}{c | c  c c c c c c}
&  Input & Int. & Rules & Done & F & B & R    \\
\hline
Input    & * & 50 &   &   &    &   &    \\
Internal &   & *  &20 &   &    &10 &    \\
Rules    &   & 60 & * &10 &    &   &    \\
Done     &100&    &30 & * &    &   &    \\
Finish   &   &    &50 &   & *  &15 & 50 \\
Bind     &   & 15 &   &   & 15 & * &    \\
Reset    &   & 50 &   &   &    &   &  * \\
\end {tabular}
\\
\vspace {0.1 in}
Table 3: Topology between Nets
\end {center}
\end {table}

The weights of these connections are set in all cases except between
Internal and Finish and Bind.  Input to Internal weights are 2.0 minus
a random number if they are parallel, and 0.1 if not; inhibitory
connections are -0.1. Internal to Rules have 0.36/-0.01 and 0.01/3.6
weights.  Rules to Internal stimulating weights are 2.8/0.01,
suppressing weights are 0.01/-4.0, and neutral weights are 0.01/-0.01.
Rules to Done are 0.4/-0.1, Done to Input are 0.01/-1.0, and Done to
Rules are 0.01/-0.5. Finish to Reset are 0.01/-1.0, and Finish to
Rules are 0.01/-4.0.  Reset to Internal weights are 0.5/-0.1 to the
Internal $+$ and $1$ CAs, 0.01/-0.01 otherwise.

Initially some training is needed to put the Finish, Bind, and
Internal learnable weights to a good position.  This is done by an
initial 400 cycles of spontaneous activation to the bind net.  This is
followed by alternating presentations of Finish and Bind instances
with instances of the non-Bind neurons.  In each case 50 neurons are
selected at random from the patterns and receive external activation.
They are presented for 10 cycles, and then the system is allowed to
run for 40 more cycles.  The fatigue and activity are then reset.
This continues for a total of 1600 cycles. So, by the 2000th cycle
Finish and Bind are CAs that are to some extent connected.

Binding occurs by presenting 50 neurons of the Input CA to be bound,
and 50 of the Finish CA's are externally stimulated for 10 cycles.  This
is then allowed to run for a further 190 cycles.  By this time,
the Internal CA is bound to the Bind CA, and thus to the Finish CA.

Unbinding is achieved by 1200 cycles of spontaneous activation of the
Bind and Internal networks.  During spontaneous activation each neuron
has a one percent chance of firing.

The system is by no means perfect, but it works in principle.  We ran
the system with 50 different nets, each time counting from 3 to 6,
then from 4 to 9 to show that binding can be erased and reused.  74\%
of the time it correctly counted from 3 to 6.  On the second test,
50\% of the time it counted from 4 to 9; 28\% of the time it stopped 
prematurely at 6 showing that the binding was not properly erased; 22\% of
the time it ended somewhere else.

\section {Conclusion and Discussion} 

Clearly this is a very simple cognitive model of counting.  Also the
model is not matched to psychological data, and timing is described
only by cycles.

What is interesting is that a neural model does the symbolic counting
task at all.  Moreover, from a cognitive modelling perspective, it
exhibits some similarities to human symbolic processing: it fails
sensibly when counting stops at a prior binding that should have been
erased.

Another interesting result is this shows a neural reason for
classifying rules.  Rules using only constants are different from
those using variables.  Simple rules are based on constants and are of
the form $if c_1 c_2 \dots c_n \rightarrow c_m c_{m+1} \dots c_p$ and
these only require the proper sort of excitatory and inhibitory links.
The counting rule is more complex and could be described by $while X <
F \rightarrow X = X+1$. The $X = X + 1$ portion is handled by the
simple rules, but the $F$ portion requires binding.

Of course there is a long way to go to have a complete neurally based
cognitive model of this phenomena and even further to have a solid
cognitive model.  A relatively simple expansion of the system could
enable it to learn new simple rules like $if 3+2 \rightarrow 5$ This
would require a process of adding beyond one, but would then allow the
system to cache results it had processed earlier.  This would be
similar to chunking \cite {Laird}

There are more complex modifications that could improve the model.  It
could be tied to psychological data; timing could be modelled by
attaching a time, say 10 ms, to a cycle; system parameters could be
modified to correspond to failure rates in counting.  More rapid
binding could be done by using short-term synaptic changes instead of
long-term changes.  Spontaneous activation could be used all the time
instead of just during binding activities.  A sensory system could be
devised and the system could actually learn numbers by learning to
count items in the environment.  This would provide a much sounder
grounding to the numerical concepts.

While these modifications seem tenable, we have no idea how the
connections between nets (aside for Input to Internal) could be
learned.  There could be another topology that did the same
task, but again we have no sound idea how this topology could be
learned.  The simple rules described above encode a sequence.  There
has been some work on learning sequences with neurons, and this
provides some guidance for learning other processes.  This work
highlights the need for a better understanding of the mechanisms
required to learn symbolic processing tasks with neural systems.

A neural system develops, in the long-term, by a change in synaptic
strength.  This self-organisation should enable the system to learn
tasks and not have them simply programmed. There have been advances in 
understanding how a neural system can learn to categorise, but we are not 
aware of a sound 
theory that specifies the boundaries of what is learned and 
when.  Perhaps the development of such a theory will shed
light on learning more complex processes such as counting.


\bibliographystyle{apalike}
\bibliography{count.bib}

\end {document}




