The amount of biological data exposed in semantic formats is steadily increasing. In particular, pathway information (a model of how molecules interact within a cell) from databases such as KEGG and WikiPathways are available in a standard RDF-based format BioPAX. However, these models are descriptive and not executable in nature. Being able to simulate or execute a pathway is one key mechanism for understanding the operation of a cell. The creation of executable models can take a significant amount of time and only relatively few such models currently exist. In this paper, we leverage the availability of semantically represented pathways, to bootstrap the creation of executable pathway models. We present an approach to automate the creation of executable models in the form of Petri-Nets from BioPAX represented pathways. This approach is encapsulated in an online tool, BioPax2PNML.
A biological pathway, simply said, is a sequence of interactions among molecules
of a cell. There are many different types of pathways; gene regulation
pathways, signaling pathways and protein interaction pathways are among the most
commonly used ones. [
Originally, pathways were hand-drawn and presented in papers. Pathways
are now made available in online databases in computer parsable formats (e.g.
BioPAX). For example, the WikiPathways has over 1700 available pathways1.
While these pathway descriptions are highly useful, they contain mostly static
information about interacting molecules and do not describe how pathways
actually work or give insight into the dynamics of these interactions [
To address this lack of information, work has been undertaken to create
computational models of these pathways [
This paper begins to address this bottleneck by leveraging the availability of semantic representations of pathways and converting them to an executable model. Concretely, the contributions of this paper are: i) to present a method to automate validation of pathway data; ii) a mapping of the BioPAX format to an executable model (Petri nets, represented in the Petri Net Markup Language; PNML); and, iii) a method to automatically create these executable models. We have developed a webservice that encapsulates the described method and can be accessed at www.few.vu.nl/∼twn370/BioPax2PNML/. Additionally, all code is available online at: https://github.com/TimoWillemsen/Biopax2PNML.
The rest of this paper is organized as follows. We begin in Section 2 with background information on biological pathways and common formats for both descriptive (BioPAX) and executable (PNML) representations of them. We then describe our approach for mapping between these two formats (Section 3). To ensure that a BioPAX pathway has the appropriate information to be converted to PNML, we present a validation approach in Section 4. This is followed, in Section 5, by a description of the implementation of our method. Finally, we conclude with some thoughts on future work in Section 6. 2
There are different types of biological pathways, corresponding to different
levels of abstraction. For example, a pathway may describe interactions between
different cells, or between genes, or between proteins, or it may describe
biochemical reactions (or combinations thereof). Many databases exist that collect
this information in a variety of forms, and some are very specialized on
particular types of data. It is beyond the scope of this work to provide a comprehensive
overiew. Some of the most well-known are WikiPathways [
The examples provided in this paper will focus on signal transduction pathways, as these tend to be well-studied and therefore well-defined. Such pathways typically include protein-protein interactions, protein-gene interactions and biochemical reactions.
We have based our research on the pathways provided by the WikiPathways
database [
One such example is the C. elegans Programmed Cell Death pathway from the WikiPathways Database, as shown in Fig. 1.
For the purpose of this paper, we have taken a subset of this pathway, as shown in Fig. 1. This pathway consists of 5 genes. When ced-3 is activated, it will trigger the cell’s programmed death.
We now discuss the computational representation of pathways used by WikiPathways. After which, we briefly describe the use of Petri-nets to as a language for executable models of pathways. 2.1
In 2010 Demir et al [
BioPax can be used to model different types of pathway components. An example of how genes are modelled in BioPax, is shown below; the ced-3 and ced-4 genes of the C. elegans Programmed Cell Death pathway, as shown in Fig. 1.
Two genes, ced-3 and ced-4, from the C. elegans Programmed Cell Death Pathway from the WikiPathways Database ID:WP367 < bp:Protein rdf:about =" eef1e " > < bp:displayName >ced -3 </ bp:displayName > < bp:entityReference rdf:resource =" id3 " / > </ bp:Protein > < bp:Protein rdf:about =" c0b3e " > < bp:displayName >ced -4 </ bp:displayName > < bp:entityReference rdf:resource =" id4 " / > </ bp:Protein > An example of interactions in a pathway modelled in BioPax is shown below; we see a reaction ‘id40’ that connects a right-hand-side element (eef1e; ced-3) with a left-hand-side (c0b3e; ced-4) element.
Gene interaction of the C. elegans Programmed Cell Death Pathway from the WikiPathways Database ID:WP367 < bp:BiochemicalReaction rdf:about =" id40 " > < bp:right rdf:resource =" eef1e " / > < bp:left rdf:resource =" c0b3e " / > </ bp:BiochemicalReaction > 2.2
Petri nets are a formalism geared towards modelling and analysis of concurrent systems. A Place-Transition (PT) Petri net is a quadruple (P, T, A, m), where P is a set of places and T a set of transitions. A describes arcs which connect places with transitions or vice versa. Each place holds zero or more tokens, which represent flow of control through this place. The number of tokens in each place all together are called a marking m of the network.
Fig. 2 shows a graphical representation of such a Petri Net, again for our
small example part of the C. elegans Programmed Cell Death pathway. Squares
are transitions, representing interactions, and circles are places, representing
genes. Arcs are represented by arrows, and the marking is empty. Firing of a
transition depends on the availability of resources (tokens) in the input places,
and represents the execution of a reaction: consuming substrates and creating
products.[
For computational purposes we have chosen to represent Petri nets in the
Petri Net Markup Language (PNML) format. This is a straightforward XML
standard that a number of systems support.[16] Fig. 2.2 shows the Petri net of
Fig. 2 in an XML representation. Petri nets are recognized as a powerful tool
to model biological pathways [
To transform static BioPax data into an executable Petri net, we have developed a mapping between the two formats. BioPax is an RDF format, while PNML is an XML format. It should be taken into account that the semantic linking is lost when a BioPax pathway is converted to PNML Petri-net. For example, genes or proteins have different identifiers in different databases. BioPax gives a way to link multiple identifiers to a gene or protein, but PNML does not support this feature. 3.1
Each gene or protein is modelled as a place in the Petri net. Because the creation of the Pathways in WikiPathways has been done manually, often they are not consistent and may, for example, contain multiple instances of one gene or protein. The mapping does not take into consideration the fact that duplicate genes or proteins may represent the same entity and are modelled twice simply for readability, or rather that they are modelled twice because they represent a different entity of the same gene/protein (for example in a different location, or in a different state). However we address this issue with the validation rules introduced in Section 4.
The first stage in mapping is shown in Algorithm 1, which transforms BioPax proteins/genes to PNML.
P = ∅ for all <bp:Protein> p in BioPax do if p ∈/ P and p is other entity then add p to P end if end for
Interactions are also mapped to PNML. Each <bp:BiochemicalInteraction> is mapped to a transition. Then for each <bp:Left> an arc is added pointing into the transition and out from the corresponding place; for each <bp:Right> an arc is created pointing out of the transition and into the corresponding place. Algorithm 2 shows the straightforward way to do this.
Once both algorithms 1 and 2 are executed a Petri net is created. Formally, the Petri net can be described as P N = P, T, A, ∅ where P are the places, T the transitions, A the arcs and markings m = ∅ since there are no tokens in the system yet. In terms of modelling the biological system, the places represent biological entities, like genes, proteins or complexes, the transitions represent biochemical reactions and interactions, and the arcs represent the associations between these two. Tokens represent the availability of the resources of the corresponding place in the Petri net.
T = ∅ A = ∅ for all <bp:BiochemicalInteraction> t in BioPax do
Add t to T for all <bp:Left> left in BioPax do left.in = t left.out = left.resource
Add left to A end for for all <bp:Right> right in BioPax do right.in = right.resource right.out = t
Add right to A end for end for
If we then execute both Algorithm 1 and Algorithm 2 on Fig. 1, a petri net is generated. Part of the output is shown in Fig. 2.2 4
The mapping described in Section 3 is based on several assumptions about the contents of the input BioPax file. The basic assumptions are that genes, proteins and complexes (bound combinations of proteins, possibly including a gene) are entities, and that these entities can change state or identity only through biochemical interactions.
However, because of the manual nature of pathway construction, these assumptions may not hold for a given pathway instance in the database. To make sure the data is presented as it should be, we have developed a set of validation rules and a validator available online.
We have developed two types of validation rules; semantic and syntactic. The syntactic validation consists of basic RDF-validation. This is necessarily because from our preliminary survey, a large fraction of pathways are not modelled correctly for translation.
More interesting is the semantic validation. These rules ensure that the information contained in the model is consistent and complete enough to create an executable Petri net. Table 1 shows these validation rules.
These rules ensure that the provided BioPax file contains everything needed. We have categorized the validation rules by severity: – Category error rules are minimal requirements for mapping. – Category warning rules that mean the mapping can proceed but may lead to an unconnected or incomplete Petri net.
This framework is set up in a modular fashion, so that extension is easy. We have implemented the methods described above as a webservice. The service consists of 4 components: a validation rule database, a validator, a BioPax to PNML converter and a pathway retriever, as is shown schematically in Fig. 4. The webservice provides an interface to query different datasources. At the time of writing only an interface to WikiPathways is provided, using the available webservices [17]. However, support for other generic BioPax could be a future extension.
The retriever queries WikiPathways and downloads the pathway in the BioPax format, so validation and conversion can be done. The validation rule database is a set of SPARQL queries. Each query returns a set of RDF triples that violate the rule (this set may be empty). This way feedback can be given about where the rule violation takes place in the BioPax File.
The way the database is set up allows easy addition of rules. This modularity makes it possible to improve on the current validation rules, but also allows validation rule sets for different types of pathways (for example signalling pathways vs. gene regulatory networks). Fig. 5 shows as an example the implementation of rule 1 of Table 1. PREFIX xsd: < http: // www . w3 . org /2001/ XMLSchema # > PREFIX owl: < http: // www . w3 . org /2002/07/ owl # > PREFIX rdf: < http: // www . w3 . org /1999/02/22 - rdf - syntax - ns # > PREFIX bp: < http: // www . biopax . org / release / biopax - level3 . owl # > SELECT ? reaction WHERE { ? reaction rdf:type bp:BiochemicalReaction .
OPTIONAL {
? reaction bp:left ? left . } }
FILTER (! BOUND (? left ))
This query returns every bp:BiochemicalReaction that does not have a bp:left child element associated to it. 5.3
The biopax validator is software that can analyze BioPax files according to the validation rules provided by the rule database. It is essentially a graphical user interface around the SPARQL queries. It annotates the place where errors or warnings have occurred and provides an easy to use interface to solve them. 5.4
Once a BioPax file has been validated, the BioPax to PNML
converter can be used to generate an executable Petri net. This converter
works according to the mapping described in Section 3. This is
implemented as an online tool, named BioPax2PNML, and can be accessed on
www.few.vu.nl/∼twn370/BioPax2PNML/.
Although the proof of concept of the current work stops with the generation
of a valid Petri net model in the form of a PNML file, it is nevertheless
instructive to consider what subsequent steps should be. Execution of a Petri net
can be performed under different execution semantics, however the most
relevant for biological systems is commonly thought to be the so-called ‘bounded
asynchronous’ execution [
Execution leads to a trajectory of markings, that represent the progression
of states of the system in response to the intial marking, which corresponds to
a particular state or condition of the biological system. Typically, token levels
are collected from a few places of interest and compared to experimental data
of the corresponding biological molecule, or used to predict the behaviour of
that particular molecule under the conditions modeled. Examples of these for
signalling pathways can be found in [
Automatic Petri net creation of biological pathways is still a tedious process. The manual labor involved makes it so that even a modestly sized model can take several months to develop. In this paper we have provided a method to bootstrap this process. By using a mapping between the commonly used BioPax format and the PNML format, we have developed a way to automate the construction of Petri net models. Because biological information online may be inconsistent or incomplete, we have developed a set of validation rules to make sure that the data is suitable for automatic conversion.
To facilitate this, and as a proof of concept, an online tool BioPax2PNML that executes this and provide an easy interface for Petri net modelers to bootstrap the process of model creation.
The approach outlined here is an initial start to making fully developed executable models. In particular, deriving the weights on edges of the Petri nets is a challenging task. In terms of future work, we believe that by leveraging the links to other databases (e.g. Uniprot) we may be able to find additional information to infer such edge weights. Moreover, we may be able to connect additional parts of the resulting Petri-nets based on background knowledge about interactions contained in other databases or even use knowledge of chemistry provided by other data sources to create more precise models. A key foundation for work going forward is that Linked Data and Semantic Web standards facilitate the merging and acquisition of this information. 7 15. Nicola Bonzanni, K. Anton Feenstra, Wan Fokkink and Elzbieta Krepska. What can Formal Methods bring to Systems Biology? In: Proc. FM’09, 5850 LNCS, 16–22. Springer, 2009. 16. Masao Nagasaki, Ayumu Saito, Atsushi Doi, Hiroshi Matsuno, and Satoru Miyano.
Using Cell Illustrator and Pathway Databases. Springer, April 2009. 17. Kelder T, Pico AR, Hanspers K, van Iersel MP, Evelo C, et al. Mining Biological
Pathways Using WikiPathways Web Services. PLoS ONE 4(7): e6447, 2009 18. Jasmin Fisher, Tom Henzinger, Maria Mateescu, and Nir Piterman. Bounded asynchrony: A biologically-inspired notion of concurrency. In Proc. FMSB’08, Cambridge, 5054 LNCS 17–32. Springer, June 2008.