Part III: Computational Neuroscience | Chapter 1

Computational Models of Neurons

Integrate-and-fire neurons, the Hodgkin-Huxley model, cable theory, and network-level dynamics

From Biophysics to Computation

Computational neuroscience seeks mathematical descriptions of neural activity at multiple levels of abstraction. At one extreme, the Hodgkin-Huxley (HH) model captures the biophysical mechanisms of action potential generation with ionic channel kinetics. At the other, integrate-and-fire models strip neurons to their computational essence: summing inputs and firing when a threshold is crossed.

Between these extremes lie cable theory (describing signal propagation in dendrites), reduced models (Izhikevich, AdEx), and network models that capture emergent dynamics of interacting populations. Each level of description answers different questions and enables different insights.

1. Integrate-and-Fire Models

The leaky integrate-and-fire (LIF) neuron, introduced by Lapicque (1907), is the workhorse of computational neuroscience. It models the neuron as an RC circuit that integrates synaptic currents, firing an action potential when the membrane potential reaches threshold.

Derivation 1: LIF Neuron Dynamics and Firing Rate

The membrane potential $V(t)$ obeys:

$$\tau_m \frac{dV}{dt} = -(V - V_{\text{rest}}) + R_m I(t)$$

where $\tau_m = R_m C_m$ is the membrane time constant. When $V$ reaches threshold $V_{\text{th}}$, a spike is emitted and $V$ resets to $V_{\text{reset}}$. For constant current $I_0$, the voltage trajectory between spikes is:

$$V(t) = V_{\text{rest}} + R_m I_0 \left(1 - e^{-t/\tau_m}\right)$$

The interspike interval is the time to reach threshold from reset:

$$T_{\text{ISI}} = \tau_m \ln\left(\frac{R_m I_0 - V_{\text{reset}} + V_{\text{rest}}}{R_m I_0 - V_{\text{th}} + V_{\text{rest}}}\right)$$

The firing rate is $f = 1/T_{\text{ISI}}$, which exists only when$R_m I_0 > V_{\text{th}} - V_{\text{rest}}$ (suprathreshold). The f-I curve starts at zero and increases as $f \sim I_0$ for large currents, producing the characteristic concave shape observed in many neurons.

2. The Hodgkin-Huxley Model

The Hodgkin-Huxley model (1952) describes action potential generation through voltage-dependent sodium and potassium conductances. This biophysical model, developed from voltage-clamp experiments on the squid giant axon, earned Hodgkin and Huxley the Nobel Prize in 1963 and remains the gold standard for detailed neural modeling.

Derivation 2: HH Equations and Gating Variables

The membrane current equation is:

$$C_m \frac{dV}{dt} = -\bar{g}_{\text{Na}} m^3 h (V - E_{\text{Na}}) - \bar{g}_{\text{K}} n^4 (V - E_{\text{K}}) - g_L (V - E_L) + I_{\text{ext}}$$

The gating variables $m, h, n$ follow first-order kinetics:

$$\frac{dx}{dt} = \alpha_x(V)(1 - x) - \beta_x(V) x = \frac{x_\infty(V) - x}{\tau_x(V)}$$

where $x_\infty(V) = \alpha_x / (\alpha_x + \beta_x)$ and$\tau_x(V) = 1 / (\alpha_x + \beta_x)$. The action potential emerges from:

Fast Na$^+$ activation ($m$): rapid depolarization ($\tau_m \sim 0.1$ ms)
Slow Na$^+$ inactivation ($h$): terminates the upstroke ($\tau_h \sim 1$ ms)
Slow K$^+$ activation ($n$): repolarization ($\tau_n \sim 1$ ms)

The threshold for spike initiation occurs at a saddle-node bifurcation where the V-nullcline and n-nullcline intersect, typically near $V \approx -55$ mV. The refractory period arises from slow recovery of $h$ and $n$ after a spike.

3. Cable Theory

Dendrites are not isopotential — they are extended structures where signals propagate with attenuation. Cable theory, developed by Rall (1959), applies transmission line equations to describe how synaptic potentials spread along dendrites.

Derivation 3: The Cable Equation and Electrotonic Length

For a cylindrical dendrite with membrane resistance $r_m$ (per unit length), axial resistance $r_a$, and membrane capacitance $c_m$:

$$\lambda^2 \frac{\partial^2 V}{\partial x^2} = \tau_m \frac{\partial V}{\partial t} + V$$

where $\lambda = \sqrt{r_m / r_a}$ is the space constant and $\tau_m = r_m c_m$is the time constant. The steady-state solution for a point current injection at$x = 0$ in an infinite cable is:

$$V(x) = V_0 \, e^{-|x|/\lambda}$$

The electrotonic length $L = \ell / \lambda$ (where $\ell$ is physical length) determines how effectively distal synapses influence the soma. For a finite cable of electrotonic length $L$ with sealed ends, the input resistance is:

$$R_{\text{in}} = \frac{r_a \lambda}{\tanh(L)}$$

Typical cortical dendrites have $\lambda \approx 0.5\text{--}1$ mm and $L \approx 1\text{--}2$, meaning distal synapses are significantly attenuated (by a factor of $e^{-L}$). This attenuation can be counteracted by active dendritic conductances (NMDA spikes, Ca$^{2+}$ spikes), which are critical for dendritic computation.

4. Network Models

Networks of neurons exhibit emergent dynamics that cannot be predicted from single-neuron properties alone. The Wilson-Cowan model (1972) describes the mean-field dynamics of excitatory and inhibitory populations, capturing phenomena such as oscillations, bistability, and pattern formation.

Derivation 4: Wilson-Cowan Mean-Field Equations

The population firing rates of excitatory ($E$) and inhibitory ($I$) populations evolve as:

$$\tau_E \frac{dE}{dt} = -E + S_E(w_{EE} E - w_{EI} I + I_E^{\text{ext}})$$

$$\tau_I \frac{dI}{dt} = -I + S_I(w_{IE} E - w_{II} I + I_I^{\text{ext}})$$

where $S(x) = 1/(1 + e^{-a(x-\theta)})$ is the population transfer function. The system exhibits oscillations when the E-I loop has sufficient gain. Linearizing around the fixed point $(E^*, I^*)$:

$$\mathbf{J} = \begin{pmatrix} (-1 + w_{EE} S_E')/\tau_E & -w_{EI} S_E'/\tau_E \\ w_{IE} S_I'/\tau_I & (-1 - w_{II} S_I')/\tau_I \end{pmatrix}$$

Oscillations occur when the eigenvalues of $\mathbf{J}$ have imaginary parts, requiring $\text{tr}(\mathbf{J})^2 < 4\det(\mathbf{J})$. The oscillation frequency is $\omega = \sqrt{\det(\mathbf{J}) - (\text{tr}(\mathbf{J})/2)^2}$. This E-I balance mechanism generates gamma oscillations (30–80 Hz) observed in cortex.

Derivation 5: Balanced Networks and Irregular Firing

Van Vreeswijk and Sompolinsky (1996) showed that networks with strong excitation and inhibition self-organize into a balanced state. For a network of $N_E$ excitatory and $N_I$ inhibitory neurons, the mean input to an excitatory neuron is:

$$\mu_E = \sqrt{K}(J_{EE} r_E - J_{EI} r_I) + I_{\text{ext}}$$

where $K$ is the number of connections per neuron and $J$ are coupling strengths scaled as $J \sim 1/\sqrt{K}$. In the balanced state, excitation and inhibition nearly cancel: $\mu_E \sim O(1)$ despite each being $O(\sqrt{K})$. The input fluctuations drive firing:

$$\sigma_E^2 = K(J_{EE}^2 r_E + J_{EI}^2 r_I)$$

This produces irregular, Poisson-like firing ($\text{CV}_{\text{ISI}} \approx 1$) matching cortical recordings. The balanced state is self-organizing: if excitation increases, inhibition adjusts to restore balance, providing a mechanism for robust cortical operation.

5. Historical Development

• 1907: Lapicque introduces the integrate-and-fire model, the first mathematical neuron model.
• 1952: Hodgkin and Huxley publish their ionic conductance model of the squid giant axon (Nobel Prize, 1963).
• 1959: Rall develops cable theory for dendrites, enabling analysis of synaptic integration in complex morphologies.
• 1972: Wilson and Cowan derive mean-field equations for excitatory-inhibitory neural populations.
• 1996: Van Vreeswijk and Sompolinsky discover the balanced state in random networks, explaining cortical irregularity.
• 2003: Izhikevich introduces a two-variable neuron model that reproduces all known firing patterns with minimal computation.
• 2005: Brette and Gerstner develop the adaptive exponential integrate-and-fire (AdEx) model, balancing efficiency and biophysical accuracy.

6. Applications

Neuromorphic Computing

LIF and AdEx models are implemented in neuromorphic chips (Intel Loihi, SpiNNaker) for energy-efficient AI. Spiking neural networks based on these models achieve competitive performance with orders-of-magnitude lower power consumption.

Drug Discovery

HH-type models of specific ion channels enable virtual screening of ion channel modulators. Cardiac and neural channel models predict drug effects on action potential shape and arrhythmia risk.

Brain Simulation

Large-scale network simulations (Human Brain Project, Allen Institute) use multi-scale models from detailed HH neurons to mean-field approximations, simulating millions of neurons to understand brain-wide dynamics.

Epilepsy Modeling

Wilson-Cowan and neural field models predict seizure dynamics and propagation patterns. Patient-specific models guide surgical planning for drug-resistant epilepsy.

7. Computational Exploration

Computational Models: LIF, Hodgkin-Huxley, Cable Theory, and Networks

Python

script.py326 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

print("=" * 72)
print("COMPUTATIONAL MODELS: LIF, HODGKIN-HUXLEY, CABLE, AND NETWORKS")
print("=" * 72)

np.random.seed(42)

# --------------------------------------------------
# 1. LEAKY INTEGRATE-AND-FIRE NEURON
# --------------------------------------------------
print()
print("1. LEAKY INTEGRATE-AND-FIRE (LIF) NEURON")
print("-" * 55)

tau_m = 20.0  # ms
V_rest = -70.0  # mV
V_th = -55.0  # mV
V_reset = -75.0  # mV
R_m = 10.0  # MOhm
dt = 0.1  # ms
T_sim = 500.0  # ms
n_steps = int(T_sim / dt)

I_ext = 2.0  # nA
V = np.zeros(n_steps)
V[0] = V_rest
spike_times = []

for i in range(n_steps - 1):
    dV = (-(V[i] - V_rest) + R_m * I_ext) / tau_m
    V[i+1] = V[i] + dt * dV
    if V[i+1] >= V_th:
        spike_times.append(i * dt)
        V[i+1] = V_reset

n_spikes = len(spike_times)
if n_spikes > 1:
    isis = np.diff(spike_times)
    freq = 1000.0 / np.mean(isis)
else:
    freq = 0.0

# Theoretical firing rate
if R_m * I_ext > (V_th - V_rest):
    T_isi_theory = tau_m * np.log((R_m*I_ext - V_reset + V_rest) / (R_m*I_ext - V_th + V_rest))
    freq_theory = 1000.0 / T_isi_theory
else:
    freq_theory = 0.0

print("  tau_m = {} ms, V_th = {} mV, V_rest = {} mV".format(tau_m, V_th, V_rest))
print("  I_ext = {} nA, R_m = {} MOhm".format(I_ext, R_m))
print("  Spikes: {}, Measured freq: {:.1f} Hz".format(n_spikes, freq))
print("  Theoretical freq: {:.1f} Hz".format(freq_theory))

# F-I curve
I_range = np.linspace(0, 5, 50)
fi_curve = []
for I_val in I_range:
    if R_m * I_val > (V_th - V_rest):
        T_isi = tau_m * np.log((R_m*I_val - V_reset + V_rest) / (R_m*I_val - V_th + V_rest))
        fi_curve.append(1000.0 / T_isi)
    else:
        fi_curve.append(0.0)

# --------------------------------------------------
# 2. HODGKIN-HUXLEY MODEL
# --------------------------------------------------
print()
print("2. HODGKIN-HUXLEY MODEL")
print("-" * 55)

C_m_hh = 1.0  # uF/cm^2
g_Na = 120.0; g_K = 36.0; g_L = 0.3
E_Na = 50.0; E_K = -77.0; E_L = -54.4

def alpha_m(V): return 0.1 * (V + 40) / (1 - np.exp(-(V + 40) / 10)) if abs(V + 40) > 1e-7 else 1.0
def beta_m(V): return 4.0 * np.exp(-(V + 65) / 18)
def alpha_h(V): return 0.07 * np.exp(-(V + 65) / 20)
def beta_h(V): return 1.0 / (1 + np.exp(-(V + 35) / 10))
def alpha_n(V): return 0.01 * (V + 55) / (1 - np.exp(-(V + 55) / 10)) if abs(V + 55) > 1e-7 else 0.1
def beta_n(V): return 0.125 * np.exp(-(V + 65) / 80)

dt_hh = 0.01  # ms
T_hh = 50.0
n_hh = int(T_hh / dt_hh)
V_hh = np.zeros(n_hh)
m_hh = np.zeros(n_hh)
h_hh = np.zeros(n_hh)
n_hh_var = np.zeros(n_hh)

V_hh[0] = -65.0
m_hh[0] = alpha_m(-65) / (alpha_m(-65) + beta_m(-65))
h_hh[0] = alpha_h(-65) / (alpha_h(-65) + beta_h(-65))
n_hh_var[0] = alpha_n(-65) / (alpha_n(-65) + beta_n(-65))

I_hh = 10.0  # uA/cm^2

for i in range(n_hh - 1):
    v = V_hh[i]
    am, bm = alpha_m(v), beta_m(v)
    ah, bh = alpha_h(v), beta_h(v)
    an, bn = alpha_n(v), beta_n(v)

m_hh[i+1] = m_hh[i] + dt_hh * (am * (1-m_hh[i]) - bm * m_hh[i])
    h_hh[i+1] = h_hh[i] + dt_hh * (ah * (1-h_hh[i]) - bh * h_hh[i])
    n_hh_var[i+1] = n_hh_var[i] + dt_hh * (an * (1-n_hh_var[i]) - bn * n_hh_var[i])

I_Na = g_Na * m_hh[i]**3 * h_hh[i] * (v - E_Na)
    I_K = g_K * n_hh_var[i]**4 * (v - E_K)
    I_L = g_L * (v - E_L)

V_hh[i+1] = v + dt_hh * (I_hh - I_Na - I_K - I_L) / C_m_hh

peak_v = np.max(V_hh)
trough_v = np.min(V_hh)
print("  g_Na = {}, g_K = {}, g_L = {}".format(g_Na, g_K, g_L))
print("  I_ext = {} uA/cm^2".format(I_hh))
print("  AP peak: {:.1f} mV, trough: {:.1f} mV".format(peak_v, trough_v))
print("  Amplitude: {:.1f} mV".format(peak_v - trough_v))

# --------------------------------------------------
# 3. CABLE EQUATION (Passive Dendrite)
# --------------------------------------------------
print()
print("3. PASSIVE CABLE (Dendritic Signal Propagation)")
print("-" * 55)

lambda_cable = 0.5  # mm
tau_cable = 10.0  # ms
L_dendrite = 2.0  # mm
dx_cable = 0.01  # mm
n_x = int(L_dendrite / dx_cable) + 1
x_cable = np.linspace(0, L_dendrite, n_x)

# Steady-state response to current injection at x=0
V_cable_ss = np.exp(-x_cable / lambda_cable)

# Attenuation at different distances
distances = [0, 0.25, 0.5, 1.0, 1.5, 2.0]
print("  Lambda = {} mm, Dendrite length = {} mm".format(lambda_cable, L_dendrite))
print("  Electrotonic length L = {:.1f}".format(L_dendrite / lambda_cable))
print()
print("  {:>8s}  {:>12s}  {:>10s}".format("Dist(mm)", "Attenuation", "% of soma"))
for d in distances:
    atten = np.exp(-d / lambda_cable)
    print("  {:8.2f}  {:12.4f}  {:10.1f}".format(d, atten, atten * 100))

# --------------------------------------------------
# 4. WILSON-COWAN E-I NETWORK
# --------------------------------------------------
print()
print("4. WILSON-COWAN E-I NETWORK DYNAMICS")
print("-" * 55)

tau_E = 10.0; tau_I = 10.0  # ms
w_ee = 12.0; w_ei = 4.0; w_ie = 13.0; w_ii = 2.0
theta_e = 3.0; theta_i = 8.0
a_slope = 1.2
I_E_ext = 1.5; I_I_ext = 0.0

def S_wc(x, theta, a):
    return 1.0 / (1.0 + np.exp(-a * (x - theta)))

dt_wc = 0.1
T_wc = 500.0
n_wc = int(T_wc / dt_wc)

E_wc = np.zeros(n_wc)
I_wc = np.zeros(n_wc)
E_wc[0] = 0.1
I_wc[0] = 0.05

for i in range(n_wc - 1):
    dE = (-E_wc[i] + S_wc(w_ee*E_wc[i] - w_ei*I_wc[i] + I_E_ext, theta_e, a_slope)) / tau_E
    dI = (-I_wc[i] + S_wc(w_ie*E_wc[i] - w_ii*I_wc[i] + I_I_ext, theta_i, a_slope)) / tau_I
    E_wc[i+1] = E_wc[i] + dt_wc * dE
    I_wc[i+1] = I_wc[i] + dt_wc * dI

# Check for oscillations
E_late = E_wc[n_wc//2:]
E_peaks = []
for i in range(1, len(E_late)-1):
    if E_late[i] > E_late[i-1] and E_late[i] > E_late[i+1]:
        E_peaks.append(i)

if len(E_peaks) >= 2:
    period = np.mean(np.diff(E_peaks)) * dt_wc
    osc_freq = 1000.0 / period
    print("  Oscillation detected: freq = {:.1f} Hz, period = {:.1f} ms".format(osc_freq, period))
else:
    print("  Fixed point (no oscillations)")

print("  E steady: {:.4f}, I steady: {:.4f}".format(E_wc[-1], I_wc[-1]))

# --------------------------------------------------
# 5. BALANCED NETWORK (LIF SPIKING)
# --------------------------------------------------
print()
print("5. BALANCED E-I SPIKING NETWORK")
print("-" * 55)

N_E_net = 200; N_I_net = 50
N_total = N_E_net + N_I_net
K_conn = 20  # connections per neuron
J_ee_net = 0.1; J_ei_net = 0.4; J_ie_net = 0.1; J_ii_net = 0.4

dt_net = 0.5  # ms
T_net = 500.0
n_net = int(T_net / dt_net)

V_net = V_rest * np.ones(N_total)
spikes_net = [[] for _ in range(N_total)]
I_ext_net = 3.5

for t_step in range(n_net):
    t_now = t_step * dt_net
    noise = 0.5 * np.random.randn(N_total)
    I_syn = np.zeros(N_total)

# Random sparse connectivity (simplified)
    spiked = V_net >= V_th
    n_spiked_E = np.sum(spiked[:N_E_net])
    n_spiked_I = np.sum(spiked[N_E_net:])

# Mean field synaptic input
    I_syn[:N_E_net] += J_ee_net * n_spiked_E * K_conn / N_E_net - J_ei_net * n_spiked_I * K_conn / N_I_net
    I_syn[N_E_net:] += J_ie_net * n_spiked_E * K_conn / N_E_net - J_ii_net * n_spiked_I * K_conn / N_I_net

for i in range(N_total):
        if V_net[i] >= V_th:
            spikes_net[i].append(t_now)
            V_net[i] = V_reset
        else:
            dV = (-(V_net[i] - V_rest) + R_m * (I_ext_net + I_syn[i] + noise[i])) / tau_m
            V_net[i] += dt_net * dV

# Count spikes
total_spikes_E = sum(len(s) for s in spikes_net[:N_E_net])
total_spikes_I = sum(len(s) for s in spikes_net[N_E_net:])
rate_E = total_spikes_E / (N_E_net * T_net / 1000.0)
rate_I = total_spikes_I / (N_I_net * T_net / 1000.0)

print("  N_E = {}, N_I = {}, K = {}".format(N_E_net, N_I_net, K_conn))
print("  Mean E rate: {:.1f} Hz".format(rate_E))
print("  Mean I rate: {:.1f} Hz".format(rate_I))

# --------------------------------------------------
# PLOTTING
# --------------------------------------------------
fig, axes = plt.subplots(2, 3, figsize=(16, 10))
fig.suptitle("Computational Models: LIF, Hodgkin-Huxley, Cable Theory, and Networks",
             fontsize=14, fontweight='bold', color='white')
fig.patch.set_facecolor('#0a0a0a')

for ax in axes.flat:
    ax.set_facecolor('#111111')
    ax.tick_params(colors='white', labelsize=8)
    ax.xaxis.label.set_color('white')
    ax.yaxis.label.set_color('white')
    ax.title.set_color('#f0abfc')
    for spine in ax.spines.values():
        spine.set_color('#333333')

# Panel 1: LIF membrane potential
t_lif = np.arange(n_steps) * dt
axes[0,0].plot(t_lif, V, color='#ec4899', lw=1)
axes[0,0].axhline(V_th, color='#fbbf24', linestyle='--', alpha=0.5, label='Threshold')
axes[0,0].set_xlabel('Time (ms)')
axes[0,0].set_ylabel('V (mV)')
axes[0,0].set_title('LIF Neuron (I={} nA)'.format(I_ext))
axes[0,0].legend(fontsize=7, facecolor='#1a1a1a', edgecolor='#333', labelcolor='white')

# Panel 2: F-I curve
axes[0,1].plot(I_range, fi_curve, color='#d946ef', lw=2)
axes[0,1].axvline(I_ext, color='#fbbf24', linestyle='--', alpha=0.5)
axes[0,1].set_xlabel('Input current (nA)')
axes[0,1].set_ylabel('Firing rate (Hz)')
axes[0,1].set_title('LIF F-I Curve')

# Panel 3: HH action potential
t_hh_axis = np.arange(n_hh) * dt_hh
axes[0,2].plot(t_hh_axis, V_hh, color='#ec4899', lw=2)
axes[0,2].set_xlabel('Time (ms)')
axes[0,2].set_ylabel('V (mV)')
axes[0,2].set_title('Hodgkin-Huxley Action Potential')

# Panel 4: Cable attenuation
axes[1,0].plot(x_cable, V_cable_ss, color='#ec4899', lw=2)
axes[1,0].axhline(0.37, color='#fbbf24', linestyle='--', alpha=0.5, label='1/e (lambda)')
axes[1,0].axvline(lambda_cable, color='#fbbf24', linestyle=':', alpha=0.5)
axes[1,0].set_xlabel('Distance from soma (mm)')
axes[1,0].set_ylabel('Relative voltage')
axes[1,0].set_title('Cable: Dendritic Attenuation')
axes[1,0].legend(fontsize=7, facecolor='#1a1a1a', edgecolor='#333', labelcolor='white')

# Panel 5: Wilson-Cowan oscillations
t_wc_axis = np.arange(n_wc) * dt_wc
axes[1,1].plot(t_wc_axis, E_wc, color='#ec4899', lw=1.5, label='Excitatory')
axes[1,1].plot(t_wc_axis, I_wc, color='#60a5fa', lw=1.5, label='Inhibitory')
axes[1,1].set_xlabel('Time (ms)')
axes[1,1].set_ylabel('Population activity')
axes[1,1].set_title('Wilson-Cowan E-I Dynamics')
axes[1,1].legend(fontsize=7, facecolor='#1a1a1a', edgecolor='#333', labelcolor='white')

# Panel 6: Network raster plot
for i in range(min(50, N_E_net)):
    if spikes_net[i]:
        axes[1,2].scatter(spikes_net[i], [i]*len(spikes_net[i]), s=0.5, color='#ec4899', alpha=0.5)
for i in range(N_E_net, min(N_E_net + 20, N_total)):
    if spikes_net[i]:
        axes[1,2].scatter(spikes_net[i], [i - N_E_net + 50]*len(spikes_net[i]), s=0.5, color='#60a5fa', alpha=0.5)
axes[1,2].set_xlabel('Time (ms)')
axes[1,2].set_ylabel('Neuron index')
axes[1,2].set_title('Balanced Network Raster')

plt.tight_layout()
plt.savefig('output.png', dpi=150, bbox_inches='tight', facecolor='#0a0a0a')
plt.close()
print()
print("[Plot saved: LIF trace, F-I curve, HH spike, cable attenuation,")
print(" Wilson-Cowan oscillations, and balanced network raster]")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Chapter Summary

• LIF neurons: firing rate $f = 1/[\tau_m \ln((RI - V_{\text{reset}})/(RI - V_{\text{th}}))]$ for suprathreshold input.
• Hodgkin-Huxley: action potentials arise from fast Na$^+$ activation, slow Na$^+$ inactivation, and delayed K$^+$ activation.
• Cable theory: signals attenuate as $e^{-x/\lambda}$ in passive dendrites, with space constant $\lambda = \sqrt{r_m/r_a}$.
• Wilson-Cowan: E-I networks generate oscillations when loop gain exceeds unity; frequency depends on time constants and coupling.
• Balanced networks: strong E-I balance produces irregular, Poisson-like firing matching cortical observations.

← Attention & Consciousness Neural Networks →