STDP and BDNF in CA1 spines (Solinas et al. 2019)

 Download zip file   Auto-launch 
Help downloading and running models
Storing memory traces in the brain is essential for learning and memory formation. Memory traces are created by joint electrical activity in neurons that are interconnected by synapses and allow transferring electrical activity from a sending (presynaptic) to a receiving (postsynaptic) neuron. During learning, neurons that are co-active can tune synapses to become more effective. This process is called synaptic plasticity or long-term potentiation (LTP). Timing-dependent LTP (t-LTP) is a physiologically relevant type of synaptic plasticity that results from repeated sequential firing of action potentials (APs) in pre- and postsynaptic neurons. T-LTP is observed during learning in vivo and is a cellular correlate of memory formation. T-LTP can be elicited by different rhythms of synaptic activity that recruit distinct synaptic growth processes underlying t-LTP. The protein brain-derived neurotrophic factor (BDNF) is released at synapses and mediates synaptic growth in response to specific rhythms of t-LTP stimulation, while other rhythms mediate BDNF-independent t-LTP. Here, we developed a realistic computational model that accounts for our previously published experimental results of BDNF-independent 1:1 t-LTP (pairing of 1 presynaptic with 1 postsynaptic AP) and BDNF-dependent 1:4 t-LTP (pairing of 1 presynaptic with 4 postsynaptic APs). The model explains the magnitude and time course of both t-LTP forms and allows predicting t-LTP properties that result from altered BDNF turnover. Since BDNF levels are decreased in demented patients, understanding the function of BDNF in memory processes is of utmost importance to counteract Alzheimer’s disease.
1 . Solinas SMG, Edelmann E, Leßmann V, Migliore M (2019) A kinetic model for Brain-Derived Neurotrophic Factor mediated spike timing-dependent LTP. PLoS Comput Biol 15:e1006975 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell; Synapse; Dendrite;
Brain Region(s)/Organism: Hippocampus;
Cell Type(s): Hippocampus CA1 pyramidal GLU cell;
Channel(s): I Na,t; I_KD; I K; I h; I A; I Calcium;
Gap Junctions:
Receptor(s): AMPA; NMDA;
Transmitter(s): Glutamate;
Simulation Environment: NEURON;
Model Concept(s): Facilitation; Long-term Synaptic Plasticity; Short-term Synaptic Plasticity; STDP;
Implementer(s): Solinas, Sergio [solinas at]; Migliore, Michele [Michele.Migliore at];
Search NeuronDB for information about:  Hippocampus CA1 pyramidal GLU cell; AMPA; NMDA; I Na,t; I A; I K; I h; I Calcium; I_KD; Glutamate;
distr.mod *
h.mod *
kadist.mod *
kaprox.mod *
kdrca1.mod *
na3n.mod *
naxn.mod *
netstims.mod *
BDNF kinetics

Includes extracellular and intracellular mechanisms.

Based on data provided by V. Lessmann and Kurt ???

Developers: Solinas & Migliore 2017

BDNF release 
The proBDNF-containing vesicles are released with 100 s delay 
after an increase of cai. To model this we must explicity model BDNF vesicles
as events triggered by a cai thereshold that execute a net_send with a probability 
that is proportional to the inverse of the time step.


    USEION ca READ cai	: Weight update requires cai 
    RANGE tau_RM
    RANGE alpha_cai_RM,theta_cai_RM, sigma_cai_RM
    : RM->RMr
    RANGE tau_RMLTP11, RMr
    : RMr->U_SE
    RANGE alpha_RMru, theta_RMru, sigma_RMru
    RANGE alpha_cai_RMBLK, theta_cai_RMBLK, sigma_cai_RMBLK
    RANGE tau_RM_RMr, alpha_RM_RMr, theta_RM_RMr, sigma_RM_RMr

    : delta_U->U_SE
    POINTER delta_U

    (nA) = (nanoamp)
    (mV) = (millivolt)
    (uS) = (microsiemens)
    (molar) = (1/liter)
    (mM) = (millimolar)
    FARADAY = (faraday) (coulomb)
    R = (k-mole) (joule/degC)

    cai (mM)
    dt (ms)
    : RM
    tau_RM = 1800e3 (ms)
    RM_inf = 0 (mM)
    alpha_cai_RM = 1e-3 (mM/ms)
    theta_cai_RM = 1.5e-3 (mM)
    sigma_cai_RM = 0.01e-3 (mM)
    tau_RMLTP11 = 1800e3 (ms) :1800e3 (ms) : 1 min = 60e3 ms, 30 min = 1800e3 ms
    RMr_0 = 0 (mM)
    alpha_RMru = 0.3 (1)
    theta_RMru = 0.5 (mM)
    sigma_RMru = 0.1 (mM)
    tau_RMBLK = 1800e3 (ms)
    RMBLK_inf = 0 (mM)
    alpha_cai_RMBLK = 1e-3 (mM/ms)
    theta_cai_RMBLK = 1.8e-3 (mM)
    sigma_cai_RMBLK = 0.01e-3 (mM)
    theta_RMBLK = 0.015 (mM)
    sigma_RMBLK = 0.001 (mM)
    tau_RM_RMr = 1e3 (ms)
    alpha_RM_RMr = 1
    theta_RM_RMr = 0.02 (mM)
    sigma_RM_RMr = 0.001 (mM)

    delta_U (1)

    RM (mM)
    RMr (mM)
    RMBLK (mM)
    post_intra (mM)

    RM = RM_inf
    RMr = RMr_0
    : printf("sigcai%f\t", sigh(RMr,theta_RMr,sigma_RMr))
    RMBLK = RMBLK_inf
    : RMBLKe = RMBLKe_0
    post_intra = 0
    delta_U = alpha_RMru * sigh(RMr,theta_RMru,sigma_RMru): * (1 - sigh(RMBLKe,theta_RMBLKe,sigma_RMBLKe))

    SOLVE state METHOD cnexp

    RMBLK' = (RMBLK_inf - RMBLK)/tau_RMBLK  + alpha_cai_RMBLK * sigh(cai,theta_cai_RMBLK,sigma_cai_RMBLK): - alpha_rmep * RMBLK: + (RMBLK_inf - RMBLK) / tau_RMBLKLTP11
    : RMBLKe' = (RMBLK - RMBLK_inf) / tau_RMBLKLTP11 : thereshould be a decay here otherwize the LTP11 accumulates, this is a memory eraser
    : We have to use a negative rate to decrease RM if during induction the RMBLK is activated to prevent RM accumulation.
    : This way is preferreble to the product by a sigmoid of delta_u, see below, as it does not depotentiate the effects induced by an LTP11.
    : This should be further clarified as depotentiation could be important here.
    : Note that for this to work must be alpha_rmep > alpha_cai_RM
    RM' = (RM_inf - RM)/tau_RM  + alpha_cai_RM * sigh(cai,theta_cai_RM,sigma_cai_RM) * (1 - sigh(RMBLK,theta_RMBLK,sigma_RMBLK))  + (RM_inf - RM) / tau_RM_RMr * alpha_RM_RMr * sigh(RM,theta_RM_RMr,sigma_RM_RMr)
    RMr' = (RM - RM_inf) / tau_RM_RMr * alpha_RM_RMr * sigh(RM,theta_RM_RMr,sigma_RM_RMr) - RMr / tau_RMLTP11
    : there should be a decay here otherwize the effects of LTP11 accumulates, this would a memory eraser
    : post_intra is a intracellular buffer for RMr states that will be converted to post_intra with time const tau_RMLTP11 
    post_intra' = RMr / tau_RMLTP11
    delta_U = alpha_RMru * sigh(post_intra,theta_RMru,sigma_RMru)

FUNCTION sigh(x (mM), theta (mM), sigma (mM)) {
    : LOCAL e
    : e = (x - theta) / sigma
    : if ( -e > 700 ) {
    : 	printf("%f\t",(-(x - theta) / sigma))
    : }
    sigh = 1 / (1 + exp((theta - x) / sigma))

Loading data, please wait...