Tutorial

Basics

transsys provides a concise and powerful language for describing gene regulatory networks (GRNs). Networks are described in units that correspond to the key biological objects: genes and gene products, called "factors" in transsys parlance. A transsys program enables simulating the dynamics of gene expression, and thus to study the dynamical properties of GRNs. transsys uses object oriented concepts, and this enables the use of transsys models as components for integrated, "multi-scale" models. The object oriented structure also provides a basis for developing tools for validating transsys against molecular data, as well as its use as a source of realistic simulated gene expression data.

transsys Programs

Gene regulatory networks (GRNs) are specified by transsys programs. A transsys program consists of the keyword transsys, followed by a name and a block containing the actual GRN specification. The block contains factor declarations and gene declarations, as described below. The block may be empty.

Minimal and Useless Example

A minimal, empty transsys program is

 transsys emptyexample
 {
 }

Here, the program's name is "emptyexample". As you may correctly expect, this program is entirely incapable of doing anything interesting, as it is devoid of any content. It's just technically a complete transsys program, somewhat like an empty wallet is still techically a complete wallet. So let's look at what we can use to fill our transsys program.

Factor Declarations

Factors are transsys's representations of gene products. During a transsys simulation, each factor is characterised by its expression level, i.e. its amount or concentration. Factors are characterised by a decay rate. They also have a diffusibility, which is provided as a facility for constructing models with (possibly complex) spatial structures but not used by the core simulator. The declaration of a factor myfirstfactor with a decay rate of 0.1 and a diffusibility of 0.04711 would for example look like this:

 factor myfirstfactor
 {
   decay: 0.1;
   diffusibility: 0.04711;
 }

You could stick this factor declaration into the empty transsys program shell shown above and obtain another valid transsys program. This program would enable you to simulate the temporal dynamics of myfirstfactor. But because there is no gene that encodes myfirstfactor, it's expression level will always be 0, and the "dynamics" will thus be a flat line. Obviously, that's not particularly interesting but you can have a look at that here. For more interesting dynamics, we have to add a gene.

Gene Declarations

As a geneticist you expect that a gene encodes a product, and also that it has some regulatory information that determines which transcription factors regulate the gene's expression. That's exactly how transsys models a gene. Gene declarations are divided into a promoter block which contains the regulatory information and a product block which specifies the factor that is the gene's product. The promoter block may contain many promoter elements. The simplest promoter element is constitutive, which determines a rate at which the gene is expressed constitutively, i.e. independently of any transcription factors. So, a simple gene that is constitutively expressed and encodes the factor myfirstfactor would look like this:

 gene myfirstgene
 {
   promoter
   {
     constitutive: 0.2;
   }
   product
   {
     default: myfirstfactor;
   }
 }

By adding that to our transsys program we arrive at the introductory example that concludes the basics.

Introductory Example

The following is a transsys program comprised of one factor, myfirstfactor and one gene, called myfirstgene, which encodes that factor:

 transsys myfirstexample
 {
   factor myfirstfactor
   {
     decay: 0.1;
     diffusibility: 0.04711;
   }
 
   gene myfirstgene
   {
     promoter
     {
       constitutive: 0.2;
     }
     product
     {
       default: myfirstfactor;
     }
   }
 }

You can see a demo of this here.

Analysis

As you'll see, the expression level of myfirstfactor starts out at 0 and converges towards 2. The initial expression level of 0 is just an arbitrary starting point provided by the simulator. However, the convergence towards an expression level of 2 is a property of your transsys program: At an expression level of 2, the amount of myfirstfactor that decays in each time step is the decay rate times the expression, i.e. 0.1 * 2 = 0.2. By virtue of the constitutive element in myfirstgene the amount of myfirstfactor synthesised per time step is 0.2. So, at the expression level of 2, decay and synthesis cancel each other out exactly. That's why the expression level of 2 is an equilibrium expression level. In dynamical systems parlance, this is a fixed point attractor. For this simple program it's relatively straightforward to convince yourself that 2 is indeed the only equilibrium level (or the only fixed point) -- so we'll leave that as an exercise for you.