Model a Gene-Regulation Pathway

About The Gene Regulation Model

Model Diagram

You can visualize a systems biology model with various levels of detail. One view sketches only the major species and processes. This model is an example of simple gene regulation, where the protein product from translation controls transcription. You could create a more complex model by adding the enzymes, coenzymes, cofactors, nucleotides, and amino acids that are not included in this model. The gene regulation example simplifies the regulatory mechanism by not showing the contributions of RNA polymerase and any cofactors. The protein product from gene expression binds to a regulatory region on the DNA and represses transcription.

Another way of looking at a systems biology model is to list the reactions in a model with the processes they represent.

DNA -> DNA + mRNA            		(transcription)
mRNA -> mRNA + protein       		(translation)
DNA + protein -> DNAProteinComplex 	(binding)
DNAProteinComplex -> DNA + protein 	(unbinding)
mRNA -> null                 		(degradation)
protein -> null              		(degradation)

Drawing the reaction pathways will help you visualize the relationships between reactions and species. In the gene regulation example, as the amount of a protein increases, the protein forms a complex with the gene responsible for its expression, and slows down protein production.

Model Reactions

Reaction equations define a systems biology model at the level of detail needed for a software program to simulate the dynamic behavior of the model. The following reactions for transcription, translation, binding, and degradation describe a simple gene-regulating mechanism.

Transcription. Transcription is where RNApolymerase and cofactors bind with a DNA molecule. The RNApolymerase then moves along the DNA and combines nucleotides to create mRNA. A simple model of transcription shows only the DNA and mRNA.

This model simplifies the transcription and the synthesis of mRNA by using a single reaction.

Reaction	`DNA -> DNA + mRNA`
Reaction rate	`v = k1 * DNA` molecule/second
Species	`DNA` = `50` molecule
Species	`mRNA` = `0` molecule
Parameters	`k1` = `0.20` second^-1

Translation. After the mRNA moves from the nucleus to the cytoplasm, it can bind with ribosomes. The ribosomes move along the mRNA and create proteins with the help of tRNAs bound to amino acids. A simple model of translation shows only the mRNA and protein product.

The synthesis of the protein is modeled as a single reaction.

Reaction	`mRNA -> mRNA + protein`
Reaction rate	`v = k2 * mRNA` molecule/second
Species	`mRNA` = `0` molecule
Species	`protein` = `0` molecule
Parameters	`k2` = `20` second^-1

Gene Repression. Transcription of DNA to mRNA is regulated by the binding of the protein product from translation to the DNA. As more protein is produced, the DNA is bound with the protein more often and less time is available for transcription with the unbound DNA.

Forward Reaction (Binding)

Reaction	`DNA + protein -> DNAProteinComplex`
Reaction rate	`v = k3 * DNA * protein` molecule/second
Species	`DNA` = `50` molecule
Species	`protein` = `0` molecule
Parameters	`k3` = `0.2` 1/(molecule*second)

Reverse Reaction (Unbinding)

Reaction	`DNAProteinComplex -> DNA + protein`
Reaction rate	`v = k3r * DNA_protein` molecule/second
Species	`DNAProteinComplex` = `0` molecule
Parameters	`k3r` = `1` second^-1

For this tutorial, model the binding and unbinding reactions as one reversible reaction.

Reaction	`DNA + protein <-> DNA_protein`
Reaction rate	`v = k3 * DNA * protein - k3r * DNA_protein` molecule/second
Species	`DNA` = `50` molecule
Species	`protein` = `0` molecule
Parameters	`k3` = `0.2` 1/(second*molecule)
Parameters	`k3r` = `1` second^-1

Degradation. Protein and mRNA degradation are important reactions for regulating gene expression. The steady-state level of these compounds is maintained by a balance between synthesis and degradation reactions. Proteins are hydrolyzed to amino acids with the help of proteases, and nucleic acids are degraded to nucleotides.

mRNA degradation is modeled as a transformation to the null species.

Reaction	`mRNA -> null`
Reaction rate	`v = k4 * mRNA` molecule/second
Species	`mRNA` = `0` molecule
Parameters	`k4` = `1.5` second^-1

Likewise, protein degradation is also modeled as a transformation to the null species. The species null is a predefined species name in SimBiology^® models.

Reaction	`protein -> null`
Reaction rate	`v = k5 * protein` molecule/second
Species	`protein` = `0` molecule
Parameters	`k5` = `1` second^-1

Create a SimBiology Model

A SimBiology model is a collection of objects that are structured hierarchically. A model object is needed to contain all the other objects.

Create a SimBiology model with the name cell.

Mobj = sbiomodel('cell')

Mobj = 
   SimBiology Model - cell 

   Model Components:
     Compartments:      0
     Events:            0
     Parameters:        0
     Reactions:         0
     Rules:             0
     Species:           0
     Observables:       0

Add a compartment named comp to the model and set the unit of compartment capacity.
```
compObj = addcompartment(Mobj,'comp');
compObj.CapacityUnits = 'liter';
```

Add the Reaction for Transcription

Add the reaction DNA -> DNA + mRNA to the model. SimBiology automatically adds the species DNA and mRNA to the model with the default initial amount of 0.
```
Robj1 = addreaction(Mobj,'DNA -> DNA + mRNA');
```
Note
Because this example has only one compartment, you need not specify the compartment to which each species belongs. If there are multiple compartments, here is an example of the reaction syntax:
```
Robj1 = addreaction(Mobj, 'nucleus.DNA -> nucleus.DNA + cytoplasm.mRNA');
```
nucleus and cytoplasm are the names of the compartments.

Display the added species of the model.

Mobj.Species

ans = 
   SimBiology Species Array

   Index:    Compartment:    Name:    Value:    Units:
   1         comp            DNA      0               
   2         comp            mRNA     0

Set the initial amount of DNA to 50 as well the amount units for both species.

Mobj.Species(1).InitialAmount       = 50;
Mobj.Species(1).InitialAmountUnits  = 'molecule';
Mobj.Species(2).InitialAmountUnits  = 'molecule';

Specify the kinetics of the reaction to be mass action by creating a mass action kinetic law object, Kobj1.
```
Kobj1 = addkineticlaw(Robj1,'MassAction');
```
For a nonreversible reaction, MassAction kinetics defines the reaction rate expression as forward rate constant * reactants.
The kinetic law serves as a map between parameters and species needed by the reaction rate expression and parameters and species in the model. To see the parameters and species that must be mapped, retrieve the ParameterVariables and SpeciesVariables properties of Kobj1.
```
Kobj1.ParameterVariables
```
```
ans = 1x1 cell array
    {'Forward Rate Parameter'}
```
```
Kobj1.SpeciesVariables
```
```
ans = 1x1 cell array
    {'MassAction Species'}
```
Since the kinetic law requires a forward rate parameter, create a parameter, k1, and set its value to 0.2. Map the parameter k1 to the forward rate parameter, by setting the ParameterVariablesNames property of Kobj1 to k1.
```
Pobj1               = addparameter(Kobj1,'k1');
Pobj1.Value         = 0.2;
Pobj1.ValueUnits    = '1/second';
Kobj1.ParameterVariableNames = 'k1';
```
For mass action kinetics, the SpeciesVariables are automatically assigned to the reactant species. Therefore, the SpeciesVariablesNames property of Kobj1 is automatically set to DNA. The reaction rate expression is now defined as follows.
```
Robj1.ReactionRate
```
```
ans = 
'k1*DNA'
```

Add the Reaction for Translation

A simple model of translation shows only the mRNA and protein product. For more details, see Translation.

Enter the reaction mRNA -> mRNA + protein and set its kinetic law to mass action. Also set the amount unit of the species protein.

Robj2 = addreaction(Mobj,'mRNA -> mRNA + protein');
Mobj.Species(3).InitialAmountUnits = 'molecule';
Kobj2 = addkineticlaw(Robj2,'MassAction');

Define the reaction rate constant k2 for the reaction.

Pobj2               = addparameter(Kobj2,'k2');
Pobj2.Value         = 20;
Pobj2.ValueUnits    = '1/second';
Kobj2.ParameterVariableNames = 'k2';

The reaction rate is now defined as follows.
```
Robj2.ReactionRate
```
```
ans = 
'k2*mRNA'
```

Add the Reaction for Gene Regulation

Transcription of DNA to mRNA is regulated by the binding of the protein product from translation to the DNA. As more protein is produced, the DNA is bound with the protein more often and less time is available for transcription with the unbound DNA. For more details, see Gene Repression.

Enter the reversible reaction for the binding and unbinding of DNA and protein. Add a parameter k3 as the forward rate constant, and k3r as the reverse rate constant.

Robj3 = addreaction(Mobj,'DNA + protein <-> DNAProteinComplex');
Mobj.Species(4).InitialAmountUnits = 'molecule';
Kobj3 = addkineticlaw(Robj3,'MassAction');
Pobj3 = addparameter(Kobj3,'k3','Value',0.2,'ValueUnits','1/(molecule*second)');
Pobj3r = addparameter(Kobj3,'k3r','Value',1.0,'ValueUnits','1/second');
Kobj3.ParameterVariableNames = {'k3','k3r'};

Display the reaction rate.

Robj3.ReactionRate

ans = 
'k3*DNA*protein - k3r*DNAProteinComplex'

Add the Reactions for mRNA and Protein Degradation

Protein and mRNA degradation are important reactions for regulating gene expression. The steady-state level of the compounds is maintained by a balance between synthesis and degradation reactions. Proteins are hydrolyzed to amino acids with the help of proteases, while nucleic acids are degraded to nucleotides.

Enter the reaction for mRNA degradation to nucleotides. Add a parameter k4 as the forward rate constant.

Robj4 = addreaction(Mobj,'mRNA -> null');
Kobj4 = addkineticlaw(Robj4, 'MassAction');
Pobj4 = addparameter(Kobj4,'k4','Value',1.5,'ValueUnits','1/second');
Kobj4.ParameterVariableNames = 'k4';

Display the reaction rate of mRNA degradation.
```
Robj4.ReactionRate
```
```
ans = 
'k4*mRNA'
```

Enter the reaction for protein degradation to amino acids. Add a parameter k5 as the forward rate constant for the reaction.

Robj5 = addreaction(Mobj,'protein -> null');
Kobj5 = addkineticlaw(Robj5,'MassAction');
Pobj5 = addparameter(Kobj5,'k5','Value',1.0,'ValueUnits','1/second');
Kobj5.ParameterVariableNames = 'k5';

Display the reaction rate of protein degradation.
```
Robj5.ReactionRate
```
```
ans = 
'k5*protein'
```

Simulate the Model

Simulate model to see its dynamic behavior.

First turn on the optional unit conversion feature. This feature automatically converts the units of physical quantities into one consistent system. This conversion is in preparation for correct simulation, but species amounts are returned in the unit that you specified (molecule in this example).
```
configset = getconfigset(Mobj);
configset.CompileOptions.UnitConversion = true;
```

Run the simulation.

[t, simdata, names] = sbiosimulate(Mobj);

Plot the results.

plot(t,simdata)
legend(names,'Location','NorthEastOutside')
title('Gene Regulation');
xlabel('Time');
ylabel('Species Amount');

Figure contains an axes object. The axes object with title Gene Regulation, xlabel Time, ylabel Species Amount contains 4 objects of type line. These objects represent DNA, mRNA, protein, DNAProteinComplex.