Refactor documentation and update synapse initialization for clarity and consistency

Author: chaoming0625

docs_state/examples/gallery.rst

@@ -142,9 +142,6 @@ Series of models exploring different gamma generation mechanisms:
       - Excitatory-inhibitory interaction
 
 
-**Combined**: `Susin_Destexhe_2021_gamma_oscillation.py <https://github.com/brainpy/BrainPy/tree/master/examples_state/Susin_Destexhe_2021_gamma_oscillation.py>`_ - All mechanisms
-
-**Key Concepts**: Gamma mechanisms, network states, oscillation generation
 
 Spiking Neural Network Training
 --------------------------------

docs_state/index.rst

@@ -131,7 +131,6 @@ See also the ecosystem
    :caption: Tutorials
 
    quickstart/index.rst
-   tutorials/index.rst
    examples/gallery.rst
 
 

docs_state/quickstart/core-concepts/architecture.ipynb

@@ -456,7 +456,7 @@
    "source": [
     "post_size = 50  # Postsynaptic population size\n",
     "\n",
-    "syn = brainpy.state.Expon.desc(post_size, tau=5*u.ms)"
+    "syn = brainpy.state.Expon(post_size, tau=5*u.ms)"
    ],
    "outputs": [],
    "execution_count": 9
@@ -479,10 +479,10 @@
    },
    "source": [
     "# Current-based output\n",
-    "out = brainpy.state.CUBA.desc()  \n",
+    "out = brainpy.state.CUBA()  \n",
     "\n",
     "# Or conductance-based output\n",
-    "out = brainpy.state.COBA.desc(E=0*u.mV)"
+    "out = brainpy.state.COBA(E=0*u.mV)"
    ],
    "outputs": [],
    "execution_count": 10
@@ -889,164 +889,6 @@
    ],
    "outputs": [],
    "execution_count": 19
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Data Flow Example\n",
-    "\n",
-    "Here's how data flows through a typical ``brainpy.state`` simulation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2025-11-13T09:31:09.684116Z",
-     "start_time": "2025-11-13T09:31:09.550662Z"
-    }
-   },
-   "source": [
-    "# 1. Define network\n",
-    "class EINetwork(brainstate.nn.Module):\n",
-    "    def __init__(self):\n",
-    "        super().__init__()\n",
-    "        self.E = brainpy.state.LIF(800, V_rest=-65*u.mV, V_th=-50*u.mV, tau=15*u.ms)\n",
-    "        self.I = brainpy.state.LIF(200, V_rest=-65*u.mV, V_th=-50*u.mV, tau=10*u.ms)\n",
-    "        \n",
-    "        # Example projections (simplified - full setup requires more code)\n",
-    "        # self.E2E = brainpy.state.AlignPostProj(...)\n",
-    "        # self.E2I = brainpy.state.AlignPostProj(...)\n",
-    "        # self.I2E = brainpy.state.AlignPostProj(...)\n",
-    "        # self.I2I = brainpy.state.AlignPostProj(...)\n",
-    "\n",
-    "    def update(self, input):\n",
-    "        # Get spikes from last time step\n",
-    "        e_spikes = self.E.get_spike()\n",
-    "        i_spikes = self.I.get_spike()\n",
-    "\n",
-    "        # Update projections (spikes → synaptic currents)\n",
-    "        # self.E2E(e_spikes)  # Updates E2E.syn.g\n",
-    "        # self.E2I(e_spikes)\n",
-    "        # self.I2E(i_spikes)\n",
-    "        # self.I2I(i_spikes)\n",
-    "\n",
-    "        # Update neurons (currents → new V and spikes)\n",
-    "        self.E(input[:800] if len(input) >= 800 else input)\n",
-    "        self.I(input[800:] if len(input) > 800 else jnp.zeros(200) * u.nA)\n",
-    "\n",
-    "        return e_spikes, i_spikes\n",
-    "\n",
-    "# 2. Initialize\n",
-    "net = EINetwork()\n",
-    "brainstate.nn.init_all_states(net)\n",
-    "\n",
-    "# 3. Compile\n",
-    "@brainstate.transform.jit\n",
-    "def step(input):\n",
-    "    return net.update(input)\n",
-    "\n",
-    "# 4. Simulate (commented out for quick execution)\n",
-    "# times = u.math.arange(0*u.ms, 1000*u.ms, 0.1*u.ms)\n",
-    "# results = brainstate.transform.for_loop(step, times)"
-   ],
-   "outputs": [],
-   "execution_count": 20
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "State Flow:\n",
-    "\n",
-    "```text\n",
-    "Time t:\n",
-    "┌──────────────────────────────────────────┐\n",
-    "│  States at t-1:                          │\n",
-    "│    E.V[t-1], E.spike[t-1]               │\n",
-    "│    I.V[t-1], I.spike[t-1]               │\n",
-    "│    E2E.syn.g[t-1], ...                  │\n",
-    "└──────────────────────────────────────────┘\n",
-    "                ↓\n",
-    "┌──────────────────────────────────────────┐\n",
-    "│  Projection Updates:                     │\n",
-    "│    E2E.syn.g[t] = f(g[t-1], E.spike[t-1])│\n",
-    "│    ... (other projections)               │\n",
-    "└──────────────────────────────────────────┘\n",
-    "                ↓\n",
-    "┌──────────────────────────────────────────┐\n",
-    "│  Neuron Updates:                         │\n",
-    "│    E.V[t] = f(V[t-1], Σ currents[t])   │\n",
-    "│    E.spike[t] = E.V[t] >= V_th          │\n",
-    "│    ... (other neurons)                   │\n",
-    "└──────────────────────────────────────────┘\n",
-    "                ↓\n",
-    "Time t+1...\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Performance Considerations\n",
-    "\n",
-    "### Memory Management\n",
-    "\n",
-    "- States are preallocated\n",
-    "- In-place updates when possible\n",
-    "- Efficient batching support\n",
-    "- Automatic garbage collection\n",
-    "\n",
-    "### Compilation Strategy\n",
-    "\n",
-    "- Compile simulation loops\n",
-    "- Batch operations when possible\n",
-    "- Use ``for_loop`` for long sequences\n",
-    "- Leverage JAX's XLA optimization\n",
-    "\n",
-    "### Hardware Acceleration\n",
-    "\n",
-    "- Automatic GPU dispatch for large arrays\n",
-    "- TPU support for massive parallelism\n",
-    "- Efficient CPU fallback for small problems"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Summary\n",
-    "\n",
-    "``brainpy.state`` 's architecture provides:\n",
-    "\n",
-    "✅ **Clear Abstractions**: Neurons, synapses, and projections with well-defined roles\n",
-    "\n",
-    "✅ **State Management**: Explicit, efficient handling of dynamical variables\n",
-    "\n",
-    "✅ **Modularity**: Compose complex models from simple components\n",
-    "\n",
-    "✅ **Performance**: JIT compilation and hardware acceleration\n",
-    "\n",
-    "✅ **Scientific Accuracy**: Integrated physical units\n",
-    "\n",
-    "✅ **Extensibility**: Easy to add custom components\n",
-    "\n",
-    "✅ **Modern Design**: Built on proven frameworks (JAX, brainstate)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Next Steps\n",
-    "\n",
-    "- Learn about specific components: [neurons](neurons.ipynb), [synapses](synapses.ipynb), [projections](projections.ipynb)\n",
-    "- Understand state management in depth: [state-management](state-management.ipynb)\n",
-    "- See practical examples in the [tutorials](../tutorials/basic/01-lif-neuron.ipynb)\n",
-    "- Explore the ecosystem: [brainstate docs](https://brainstate.readthedocs.io/)"
-   ]
   }
  ],
  "metadata": {

docs_state/quickstart/core-concepts/index.rst

@@ -19,7 +19,6 @@ The core concepts of ``brainpy.state`` include:
 - **Neurons**: Building blocks for neural computation, including different neuron models and their state representations
 - **Synapses**: Connections between neurons that transmit signals and implement learning rules
 - **Projections**: Network-level structures that organize and manage connections between populations of neurons
-- **State Management**: The powerful state handling system that enables efficient simulation and flexible model composition
 
 
 Why these concepts matter
@@ -44,6 +43,5 @@ Each concept builds upon the previous ones, so we recommend reading them in orde
    neurons.ipynb
    synapses.ipynb
    projections.ipynb
-   state-management.ipynb