Modeling protein lifespans

· Uncategorized

To be useful, regulatory proteins need to have fairly fixed lifespans. If a protein population is created to address a transient need in the cell then it needs to endure while the need exists and to go away after the need has passed. Also proteins likely accumulate injuries over time that could render them non-functional or even toxic. For these reasons, the cell employs a number of deliberate mechanisms to destroy the very proteins it creates. Autophagy, both specific and non-specific is one; another is the proteasome. At its simplest, a population of a protein once generated would decay hyperbolically as its members randomly collided with the destroyers, more or less a straight line decline with a small tail. Nature improves on this dynamic by the use of ubiquitin, a 70-aa protein that it attaches to other proteins. Presumably the ubiquitins are attached randomly one at a time. Only when a protein has accumulated four or more such tags is it recognized by the destroyers and dissolved. Sort of like accumulating unpaid parking tickets and then getting the boot. The consequence is that for a period, little of the new protein population is destroyed. After that, the population declines to zero in about the same amount of time as it stayed constant.

I have written a primitive Java program to plot this mechanism and senescent declines in general:

package splot;

import java.io.*;
import java.util.Random;

public class splot {

    public static void main(String[] args) {
        nt kP = 1000; // population
        int kG = 1000; // generations
        int kT = 100; // tags per generation
        int kM = 4; // min tags required for destruction
        int kK = 4000; // destroyer attempts per generation
        int kZ = 0; // spontaneous destructions per generation (0=disabled)
        int kR = 1234; // random seed

        File outFile = new File("splot.txt");
        BufferedWriter out = null;
        FileWriter fw = null;
        try {
            fw = new FileWriter ( outFile);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        out = new BufferedWriter( fw );

        Random r = new Random( kR );
        Integer [] p = new Integer[kP];
        Integer [] a = new Integer[kP];
        for (int i = 0; i < kP; i++) {
            p[i] = 0;
            a[i] = 1;
        }
        String header = String.format("t=%d m=%d k=%d z=%d p=%d g=%d", kT, kM, kK, kZ, kP, kG);
        System.out.println(header);

        try {
            out.write(header);
            out.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // For kG generations
        for (int g = 0; g < kG; g++) {

            // Randomly tag
            for (int t = 0; t < kT; t++) {
                p[r.nextInt(kP)]++;
            }

            // Randomly kill untagged
            for (int z = 0; z < kZ; z++) {
                int m = r.nextInt(kP);
                if (p[m] == 0) {
                    a[m] = 0;
                }
            }

            // Randomly kill overtagged 
            for (int k = 0; k < kK; k++) {
                int m = r.nextInt(kP);
                if (p[m] >= kM) {
                    a[m] = 0;
                }
            }

            int c = 0;
            for (int i = 0; i < kP; i++) {
                c += a[i];
            }
            String line = String.format("%d, %d\n", g, c);
            System.out.println(line);

            try {
                out.write(line);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

The parameter kP is the population size, kG is the number of cycles in the simulation, kT is the number of taggings per cycle, kM is the number of tags that enables destruction, kK is the number of destruction attempts per cycle, kZ is the number of spontaneous destructions per cycle, and kR is the seed of the random generator. Edit these numbers as desired.

The output file, splot.txt, can be loaded into any spreadsheet and an x-y graph or a bar graph quickly displayed from the data.

The parameters given model the typical case where four or more ubiquitin tags enable the destroyers:
u4
Note that substantially increasing the tags required increases the ratio of level time to decay time and that only this modification seems to do that. A 100 tag requirement, for instance increases the ratio from one to five compared to the 4 tag requirement:
u100

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: