Forums

The topic of this vote is:
REFERENCES TO CONTROLLED VOCABULARIES

The URL for the voting page is:
http://www.surveymonkey.com/s.asp?u=207211607892

Additional background is available in the minutes from the
October SBML Forum meeting at
http://www.sbml.org/forums/index.php?t=msg&th=713&rid=2

The SBML Level 2 Version Specification is at:
http://sbml.org/wiki/sbml-level-2-version-2.pdf

This survey involves multiple questions.

One of the proposed additions in SBML Level 2 Version 2 is
an attribute that would permit directly annotating certain
SBML elements with links to resources such as controlled
vocabulary terms. The need for such a capability in SBML is
widely acknowledged.

The proposal for SBML Level 2 Version 2 is to add an
attribute to the elements Model, Rule, KineticLaw,
Parameter, SpeciesReference, and Constraint. This is
proposed to be called 'sboTerm' and its data type would be a
URI. The set of values that can be assigned to this
attribute would be limited to a specific ontology, the
Systems Biology Ontology (SBO), developed and maintained
independently from SBML.

Under the proposal as currently formulated, the URI value of
an 'sboTerm' attribute on any given element in a model must
refer to a single SBO term that best defines the entity
represented by the SBML element in question. An example of
the type of relationship intended is:

KineticLaw in reaction R1 is a
first-order irreversible mass action rate law

Note the careful use of the words "defines" and "entity
represented by the SBML element" in the paragraph above.
The relationship between the SBML element and the URI is:

the "thing" represented by this SBML element *is an*
instance of the "thing" represented by the referenced
SBO term

One of the requirements to be imposed on SBO will be that it
is constructed in such a way that not more than one term is
appropriate as a value of an 'sboTerm' attribute. SBO will
not encode biological and biochemical concepts already
encoded by other ontologies.

'sboTerm' supersedes the previously proposed definitionURL
as first proposed in the discussion referenced here:
http://www.sbml.org/forums/index.php?t=tree&goto=2323&rid=0
http://www.sbml.org/forums/index.php?t=tree&goto=2237&rid=0
http://www.sbml.org/forums/index.php?t=tree&goto=2343&rid=0

Here are the questions:

1) Do you think the introduction of the 'sboTerm' attribute
as described above is a good idea for SBML Level 2
Version 2?

2) In which XML namespace should the attribute 'sboTerm'
reside?

a) The new level 2 version 2 namespace,
"http://www.sbml.org/sbml/level2/version2". In this
case, the attribute would appear in an SBML document
simply as 'sboTerm', in the same way as other SBML
elements appear.

b) The SBO namespace. In this case, the attribute would
have to appear with a namespace prefix in an SBML
document.

(Note that this question is not about whether having to
use a namespace prefix is pleasant or unpleasant; the
question is about whether the 'sboTerm' attribute should
be considered part of the SBML namespace.)

3) The 'sboTerm' attribute is not a general purpose
mechanism for linking SBML elements to particular
resource like controlled vocabulary terms. It is now
widely believed in the SBML community that SBML needs
such a mechanism. Andrew Finney and Nicolas Le Novere
proposed a scheme here:
http://www.sbml.org/forums/index.php?t=tree&goto=1435&rid=0
http://www.sbml.org/forums/index.php?t=tree&goto=1436&rid=0

The specification for this scheme is available here:
http://www.ebi.ac.uk/compneur-srv/sbml/proposals/AnnotationURI.pdf

The Finney-Le Novere scheme would supersede the use of
the CellML metadata scheme defined in SBML Level 2
Version 1, and the use of the CellML metadata scheme
would be deprecated in SBML Level 2 Version 2.

Do you think the Finney-Le Novere scheme should be part
of Level 2 Version 2?


Please cast your vote by using the voting page at
http://www.surveymonkey.com/s.asp?u=207211607892

Andrew and Mike

Sorry if I missed something, but what are the arguments for/against
using the same or a different namespace here? I don't even recall
this part of the discussion in Boston (must have been snoozin).
Bruce

On Dec 13, 2005, at 2:21 PM, Michael Hucka wrote:

> The topic of this vote is:
> REFERENCES TO CONTROLLED VOCABULARIES
>
>
>
> 2) In which XML namespace should the attribute 'sboTerm'
> reside?
>
> a) The new level 2 version 2 namespace,
> "http://www.sbml.org/sbml/level2/version2". In this
> case, the attribute would appear in an SBML document
> simply as 'sboTerm', in the same way as other SBML
> elements appear.
>
> b) The SBO namespace. In this case, the attribute would
> have to appear with a namespace prefix in an SBML
> document.
>
> (Note that this question is not about whether having to
> use a namespace prefix is pleasant or unpleasant; the
> question is about whether the 'sboTerm' attribute should
> be considered part of the SBML namespace.)

One could answer it depends on the tools. Because it depends on what
you want to do with the sboTerm. If you use the sboTerm of a
speciesReference to generate a SBGN graph, I would select the
sboTerm. If you want to process a kineticLaw and your tool can
understand the mathML I would go for the mathML. If you want to
convert a continuous model into discrete, I would choke and refuse the
model as inconsistent.

On Thu, 15 Dec 2005, Ralph Gauges wrote:

> Hi,
>
> unfortunatelly I was not there at the discussion in Boston, so I have a
> question that might has probably been discussed before.
> What happens if e.g. an sboTerm states that the kineticLaw is "irreversible
> first order mass action" but the formula is Michaelis-Menten? Which do I
> take? Same thing goes for SpeciesReferences. Is is an error if a
> SpeciesReference that is in the listOfProducts has an sboTerm that states
> that it is an inhibitor? How should inconsistencies like this be handled?
>
> Thanks
>
> Ralph
>
>
> Michael Hucka wrote:
>
>> The topic of this vote is: REFERENCES TO CONTROLLED VOCABULARIES
>>
>> The URL for the voting page is:
>> http://www.surveymonkey.com/s.asp?u=207211607892
>>
>> Additional background is available in the minutes from the
>> October SBML Forum meeting at
>> http://www.sbml.org/forums/index.php?t=msg&th=713&rid=2
>>
>> The SBML Level 2 Version Specification is at:
>> http://sbml.org/wiki/sbml-level-2-version-2.pdf
>>
>> This survey involves multiple questions.
>>
>> One of the proposed additions in SBML Level 2 Version 2 is
>> an attribute that would permit directly annotating certain
>> SBML elements with links to resources such as controlled
>> vocabulary terms. The need for such a capability in SBML is
>> widely acknowledged.
>>
>> The proposal for SBML Level 2 Version 2 is to add an
>> attribute to the elements Model, Rule, KineticLaw,
>> Parameter, SpeciesReference, and Constraint. This is
>> proposed to be called 'sboTerm' and its data type would be a
>> URI. The set of values that can be assigned to this
>> attribute would be limited to a specific ontology, the
>> Systems Biology Ontology (SBO), developed and maintained
>> independently from SBML.
>>
>> Under the proposal as currently formulated, the URI value of
>> an 'sboTerm' attribute on any given element in a model must
>> refer to a single SBO term that best defines the entity
>> represented by the SBML element in question. An example of
>> the type of relationship intended is:
>>
>> KineticLaw in reaction R1 is a
>> first-order irreversible mass action rate law
>>
>> Note the careful use of the words "defines" and "entity
>> represented by the SBML element" in the paragraph above.
>> The relationship between the SBML element and the URI is:
>>
>> the "thing" represented by this SBML element *is an*
>> instance of the "thing" represented by the referenced
>> SBO term
>>
>> One of the requirements to be imposed on SBO will be that it
>> is constructed in such a way that not more than one term is
>> appropriate as a value of an 'sboTerm' attribute. SBO will
>> not encode biological and biochemical concepts already
>> encoded by other ontologies.
>>
>> 'sboTerm' supersedes the previously proposed definitionURL
>> as first proposed in the discussion referenced here:
>> http://www.sbml.org/forums/index.php?t=tree&goto=2323&rid=0
>> http://www.sbml.org/forums/index.php?t=tree&goto=2237&rid=0
>> http://www.sbml.org/forums/index.php?t=tree&goto=2343&rid=0
>>
>> Here are the questions:
>>
>> 1) Do you think the introduction of the 'sboTerm' attribute
>> as described above is a good idea for SBML Level 2
>> Version 2?
>>
>> 2) In which XML namespace should the attribute 'sboTerm'
>> reside?
>> a) The new level 2 version 2 namespace,
>> "http://www.sbml.org/sbml/level2/version2". In this
>> case, the attribute would appear in an SBML document
>> simply as 'sboTerm', in the same way as other SBML
>> elements appear.
>>
>> b) The SBO namespace. In this case, the attribute would
>> have to appear with a namespace prefix in an SBML
>> document.
>>
>> (Note that this question is not about whether having to
>> use a namespace prefix is pleasant or unpleasant; the
>> question is about whether the 'sboTerm' attribute should
>> be considered part of the SBML namespace.)
>>
>> 3) The 'sboTerm' attribute is not a general purpose
>> mechanism for linking SBML elements to particular
>> resource like controlled vocabulary terms. It is now
>> widely believed in the SBML community that SBML needs
>> such a mechanism. Andrew Finney and Nicolas Le Novere
>> proposed a scheme here:
>> http://www.sbml.org/forums/index.php?t=tree&goto=1435&rid=0
>> http://www.sbml.org/forums/index.php?t=tree&goto=1436&rid=0
>>
>> The specification for this scheme is available here:
>> http://www.ebi.ac.uk/compneur-srv/sbml/proposals/AnnotationURI.pdf
>>
>> The Finney-Le Novere scheme would supersede the use of
>> the CellML metadata scheme defined in SBML Level 2
>> Version 1, and the use of the CellML metadata scheme
>> would be deprecated in SBML Level 2 Version 2.
>>
>> Do you think the Finney-Le Novere scheme should be part
>> of Level 2 Version 2?
>>
>>
>> Please cast your vote by using the voting page at
>> http://www.surveymonkey.com/s.asp?u=207211607892
>>
>> Andrew and Mike
>>
>>
>>
>

--
Nicolas LE NOVÈRE, Computational Neurobiology,
EMBL-EBI, Wellcome-Trust Genome Campus, Hinxton, Cambridge, CB10 1SD, UK
Tel: +44(0)1223 494 521, Fax: +44(0)1223 494 468, Mob: +33(0)689218676
http://www.ebi.ac.uk/~lenov AIM screen name: nlenovere

> I
> could imagine that there are some programs out there that will just read
> the sboTerm because this is simpler
> So programs would have to evaluate both the formula and the sboTerm.

But in most of the case, that will hardly be sufficient to run the
simulation. sboTerm are not meant to replace kineticLaw. In the case of a
wrong sboTerm, it is likely that there will be inconsistencies between
sboTerms of parameters, speciesReferences and kineticLaws. Therefore, the
simulator clever enough to reconstruct kineticLaws based on sboTerms won't
be able to. In the event where sboTerms are consistent, there are great
chances that the mistake is actually in the kineticLaw!



--
Nicolas LE NOVÈRE, Computational Neurobiology,
EMBL-EBI, Wellcome-Trust Genome Campus, Hinxton, Cambridge, CB10 1SD, UK
Tel: +44(0)1223 494 521, Fax: +44(0)1223 494 468, Mob: +33(0)689218676
http://www.ebi.ac.uk/~lenov

Hello,
The advantages of the sboTerm (as I understood it, but someone
please correct me if I'm wrong) are:

1) A compiled program can read in a unique identifier classifying a
reaction / species / kinetic parameter and match it to a list of
hard-coded reaction rate laws.
Without the unique identifier, the compiled program must parse the
MathML expression in the kineticLaw and repeatedly evaluate the
expression using a relatively expensive operation.

2) Two MathML expressions may be (string-wise) different, but are in
fact algebraically identical. How do you a) simplify the algebraic
expression to the least expensive form for evaluation b) test if two
MathML expressions are algebraically identical? (a) is important if
you are parsing the MathML expression and evaluating it. (b) is
important if you want to compare two models, analyzing the differences
in reaction rate laws/etc. It is also easier to label a species as
'Inhibitor' and the reaction 'Michaelis Menten Inhibition' than to parse
the MathML reaction rate law expression and identify which variable in
the MathML expression is the inhibiting species.

3) It is much easier to make a mistake in the reaction rate law than in
the sboTerm, in my opinion. There are many (in fact, infinite) ways to
write down the standard Michaelis Menten expression, but there will only
be one unique identifier for that expression.

4) Not everyone programs in an interpreted or object-oriented language.
You have to understand that most supercomputers do not use Java and new
architectures usually do not have the Python/Perl/etc interpreters
ported in a timely fashion. How often do new & useful architectures
arrive? Consider the Sony/Toshiba/IBM Cell processor and its potential
use in scientific computing.

5) Also, new (and old) simulation techniques for studying biological
systems do require a lot of computing time. Any additional costs for
evaluating algebraic expressions are big obstacles. The sboTerm removes
that obstacle. Consider most Molecular Dynamics software packages. Even
the presence of a square root in a calculation is usually eliminated via
mathematical manipulation of the expression or an approximation. Special
routines are written solely for evaluating inverse square root
expressions. These optimizations are responsible for 10-20% savings in
time which saves days/weeks of computing time on modern supercomputers.

So there are some good reasons why using the sboTerm is advantageous.
But, like you said, adding new rate laws so the whole community may use
them does require communication with the SBO database. Nicolas can
probably say more about how adding rate laws and other sboTerms to the
SBO database will be handled.


-Howard Salis


hugh.d.spence@gsk.com wrote:

>
> Ralph,
>
> My own view is that the formula should be the correct one and that
> programs should not rely on the sboTerm (which is not backwards
> compatible). But, if a program does check that they are equivalent, it
> should give a warning that they don't match. The specification does
> not have to state which is correct because everyone who uses SBML will
> make sure they have got the equation type right, won't they?
>
> I can't find it in the spec at the moment, but I think the sboTerm may
> be optional.
> 1) Otherwise how can you create a new type of rate law for a
> particular model before changing the SBO to add the law?
> 2) For backward compatibility.
>
> The advantages of having the sboTerm in the kinetic law have been
> given as speed of compilation, but I can't see why one can't compile a
> model once and then merely alter parameters in (a copy of) the
> compiled model before running, rather than automatically recompile
> thousands of times. Knowing that I could do it that way in an
> object-oriented language, I failed to follow the argument for doing
> the longer process in a loop as being more efficient.
>
>
>
> Hugh Spence
> GSK Scientific Computing and Mathematical Modelling
> Medicines Research Centre
> Gunnels Wood Road
> Stevenage
> UK
> SG1 2NY

Howard,

I admit that I've not explored new architectures, but under old
architectures compilers and assemblers had the ability to produce memory
maps which had the positions of variables in the binaries produced. Thus
you could compile your model ONCE and produce a binary image of your
program, which could be modified (in C or similar by changing only the
relevant individual bytes) before being run. This does not depend on
object-orientation or interpretation (beyond some operating system
commands which are so basic that they are practically inescapable).

This is less expensive than re-evaluating the sboTerm many
thousands of times and does not prevent you using your special libraries
for optimisation. The time to evaluate the algebraic expression once is
truly negligible.
The time to read in a binary image is going to be less than to
read an SBML file.
The time to alter and write a new version of the binary image is
going to be less than to parse an SBML file.

Maybe the new architectures preclude this, but it would appear to
the uninitiated to be a retrograde step.



Hugh Spence
GSK Scientific Computing and Mathematical Modelling
Medicines Research Centre
Gunnels Wood Road
Stevenage
UK
SG1 2NY

Hello,

All of my programs are model-independent. That is, they read the model
from a file and then run the simulation. What you're proposing sounds
like reading the model file, generating source code using the model
information, compiling the source code into instructions, and running
those instructions. Like I said, I do not want to recompile my program
for every model I simulate. For example, what happens when you want to
simulate .... multiple models? Must you recompile for each model?

If the solution resorts to manipulation of individual bits, is that
really a practical, elegant solution? And it still does not solve
reasons #2 and #3.
Btw, I would not be re-reading the SBML file thousands of time per model
for the sboTerms. Why not simply read them in all at once and map them
to a nice integer array?

-Howard

hugh.d.spence@gsk.com wrote:

>
> Howard,
>
> I admit that I've not explored new architectures, but under
> old architectures compilers and assemblers had the ability to produce
> memory maps which had the positions of variables in the binaries
> produced. Thus you could compile your model ONCE and produce a binary
> image of your program, which could be modified (in C or similar by
> changing only the relevant individual bytes) before being run. This
> does not depend on object-orientation or interpretation (beyond some
> operating system commands which are so basic that they are practically
> inescapable).
>
> This is less expensive than re-evaluating the sboTerm many
> thousands of times and does not prevent you using your special
> libraries for optimisation. The time to evaluate the algebraic
> expression once is truly negligible.
> The time to read in a binary image is going to be less than to
> read an SBML file.
> The time to alter and write a new version of the binary image
> is going to be less than to parse an SBML file.
>
> Maybe the new architectures preclude this, but it would appear
> to the uninitiated to be a retrograde step.
>
>
>
> Hugh Spence
> GSK Scientific Computing and Mathematical Modelling
> Medicines Research Centre
> Gunnels Wood Road
> Stevenage
> UK
> SG1 2NY
>
>

On Sat, 17 Dec 2005, Gauges, Ralph wrote:

> So this said, if there is no way to to have a kineticLaw elemtn without a formula, the sboTerm is useless at least for deterministic simulation programs?

Maybe. But one of the reasons we felt we had to use SBO within SBML
was precisely the continuous versus discrete problem (I assume you
meant continuous when you said "determinitic"). In the current SBML,
there is nothing that tells-us if a formula has to be understood as a
discrete or continuous formulation. Since all kineticLaws provide
substance/time, I can read all of them in a discrete simulator, and
into problems if they were expressing contiuous mass-action laws.


--
Nicolas LE NOVÈRE, Computational Neurobiology,
EMBL-EBI, Wellcome-Trust Genome Campus, Hinxton, Cambridge, CB10 1SD, UK
Tel: +44(0)1223 494 521, Fax: +44(0)1223 494 468, Mob: +33(0)689218676
http://www.ebi.ac.uk/~lenov AIM screen name: nlenovere

Hi Ralph,
True, it would be great if the SBML reader caught any error and I
think issuing a warning that the reader is only using the sboTerm is a
good idea. But what happens if the stoichiometry, kinetic parameter, or
species list of a reaction is wrong? It's an error, but there's really
no good way to detect the error.

I think SBML is very complicated too, but with good software
encapsulation, one should be able to read/write it with ease. (Or else
we have another problem all together.)

-Howard Salis

Ralph Gauges wrote:

> Hi Howard,
>
> I am sorry, but I totally disagree with your point of view here. This
> problem can not be shifted to the SBML file generators, but those
> errors have to be caught by the SBML readers.
> I know that in a perfect world, all programs would be able to write
> correct SBML files, but lets face it, due to the complexity of SBML,
> there is probably no program that gets it all right and there are many
> incorrect SBML files around already.
> I think if a program reads in an incorrect SBML file, it should report
> this to the user and in order to be able to do this, it needs to be
> clearified what is to be considered an error and what is correct SBML
> and this has to be stated in the specs.
> So in my eyes, programs that only use the sboTerm for the simulation
> should issue a warning to the user that there was a forumnla as well,
> but that it has been ignored and that this might lead to problems.
>
>
> Ralph
>
>
>
>
> Howard Salis wrote:
>
>> Hi Ralph,
>>
>> I think the main question is "What happens when an incorrect model is
>> created (by a person or by a program)?" Is it the program's fault for
>> simulating the wrong model or the person's/program's fault for
>> creating it in the first place?
>>
>> Hopefully, programs that create models will be smartly written so
>> that the sboTerm is never, ever, ever different from the
>> corresponding kineticLaw. (Also the same for sboTerms of species /
>> etc). Otherwise, it's an incorrectly written program and it must be
>> fixed. ;) But these are systematic errors that may be identified and
>> fixed. (Human error on the other hand is rather sporadic.)
>>
>> I think this problem can be effectively handled by the developers of
>> SBML writing programs.
>>
>> -Howard Salis
>>
>> Gauges, Ralph wrote:
>>
>>> Hi Howard,
>>>
>>> this is exactly the answer I feared was coming!
>>> This means that there are going to be programs that rely on the
>>> sboTerm for simulation instead of reading the formula.
>>> I can understand that it is a lot less work to parse a string then
>>> it is to parse a formula. So in the scenario where the sboTerm is
>>> not consistent with the formula, a program that parses the formula
>>> will create different simulation results than the program that only
>>> parses the sboTerm and I think this is bad for the users.
>>> I think we should either state that the forumla if present is to be
>>> read or we should make the formula and the sboTerm mutualy exclusive
>>> for the kineticLaw, which is not a nice solution.
>>> I think it should only be allowed to use the sboTerm to simulate the
>>> model if there is not formula present. (Can there be a kineticLaw
>>> without a formula? Since the math field is not optional, can it be
>>> empty?)
>>> I think that it is very important to state which is the correct
>>> behavior in case of potentialy contradicting information because
>>> only one behavior can be correct here. And since it is not trivial
>>> to make a consistency check in this case, I think we should state
>>> that it is wrong to use the sboTerm to simulate the model if there
>>> is an equation present?
>>> So this said, if there is no way to to have a kineticLaw elemtn
>>> without a formula, the sboTerm is useless at least for deterministic
>>> simulation programs?
>>>
>>> OK, I guess after this sentence Nicolas is going to come up with the
>>> Michaelis-Menten vs. Briggs-Haldane example where you need the
>>> sboTerm to distinguish those two, but are there any other examples
>>> where this would be needed?
>>>
>>> Ralph
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>>

Sorry to take so long in getting back to this.

Ralph asked a very important question,

>>>>> On 15 Dec 2005, Ralph Gauges <ralph.gauges@eml-r.villa-bosch.de> wrote:
RG> What happens if e.g. an sboTerm states that the
RG> kineticLaw is "irreversible first order mass action"
RG> but the formula is Michaelis-Menten? Which do I take?
RG> [...] How should inconsistencies like this be handled?

which was later reiterated by Sven,

>>>>> On 19 Dec 2005, Sven Sahle <sven.sahle@eml.org> wrote:
SS> [...] I think Ralphs question is still valid: Since
SS> the sbo term is meant to be a proper part of the sbml
SS> specification (rather than just some annotation) there
SS> should be clear rules about what should take
SS> precedence if there is a conflict between sbo term and
SS> kinetic law. And if conflicts are to be considered an
SS> error. And, how should programs behave that can only
SS> deal with one of the two: Is it proper sbml to only
SS> give the sbo term (it may be, since kinetic law is
SS> optional). Should programs that do not really
SS> understand sbo terms still keep them and write them
SS> out again, even if they changed something about the
SS> model?

Howard, Hugh and others chimed in. Hugh in particular
suggested the following:

>>>>> On 15 Dec 2005, hugh.d.spence@gsk.com wrote:
hds> [...] If your program can tell that there is a
hds> difference between the maths and the description then
hds> it should report that there is an error. You then
hds> have to suspend processing untill the error has been
hds> resolved. [...]

I think Hugh's suggestion is a good idea as a general
best-practice guideline. For those tools that can check
both source of information, it would be courteous to the
modeler to alert them to a conflict and offer the modeler
some choices in the next step to take.

In what follows, I'd like to examine the question of strict
rules of precedence in more detail. To begin, in the white
paper that serves as the underlying basis for 'sboTerm' (nee
'definitionURL') by myself and Nicolas, which you can find
here,

http://www.sbml.org/forums/index.php?t=tree&goto=2343&rid=0

we tried to answer this exact question in Section 5 of that
document. Here is the paragraph (with emphasis added by
putting the relevant phrases in all capitals):

"If you have a means of linking (say) a reaction rate
formula to a term in a CV, is it possible to have
an inconsistency between the formula in the SBML model
and the one defined for the CV term? Yes. But, this is
not a new problem; it arises in other situations
already. The guideline should be that the SBML MODEL
MUST BE SELF-CONTAINED AND STAND ON ITS OWN. Therefore,
in cases where they differ, the definitions in the
model take precedence over the definitions referenced
by the CV. In other words, THE MODEL (AND ITS MATHML)
IS AUTHORITATIVE."

This concurs with what Stefan Hoops wrote:

>>>>> On 20 Dec 2005, Stefan Hoops <shoops@vbi.vt.edu> wrote:
shoops> Hello All, In my opinion the sboTerm adds semantic
shoops> information. The model must still be valid without
shoops> it and therefore in a case of conflict the SBML
shoops> rate law or function definition must have
shoops> precedence.

The following is a more systematic list of questions and
answers, based on Ralph's and Sven's questions and other
recent postings on this topic. (This perhaps needs to be
considered my personal opinion, because I haven't consulted
with Nicolas and Andrew before writing the following.)

* Question #1: What is the rule to be followed if there is a
conflict between the 'sboTerm' value and the kinetic law?

Answer #1: The kinetic law wins.

* Question #2: What if an application cannot access the
resources indicated by the 'sboTerm'?

Answer #2: It should do what applications do with SBML
today, where 'sboTerm' doesn't exist: read the SBML and
treat it as the authoritative definition. The kinetics
should be defined by the kinetic law given in the SBML.

* Question #3: Should a conflict between sboTerm and the
kinetic law be considered an error?

Answer #3: Since the sboTerm is optional but
non-authoritative, and furthermore, since there is the
understanding that applications are not *required* to
have the capability of accessing the indicated sboTerm
resource, it is not possible to require that conflicts
must be detected. The best we can do is write it as a
recommendation: applications should attempt to detect
conflicts and report them if they can.

* Question #4: What if an application can interpret *only*
the sboTerm values, because it does not have the ability
to interpret the mathematics of the kinetic law
definition?

Answer #4: Let's examine this from the perspective of an
application in today's SBML world, without sboTerm in
existence. What would an application do if it could not
read the kinetic law definition? It could interpret the
SBML to some extent (e.g., it could read out the
reactants, products and modifiers in a reaction) and
perform some manipulations (maybe?), but there is a risk
that anything it does would be suspect because the tool
is not intepreting the full model. In the end, it could
not hope to be a fully compliant SBML application
because it can't interpret the kinetics. Likewise, in
an sboTerm world, the application could perform some
manipulations (maybe) but it could not be a fully
compliant SBML application because it did not have the
ability to interpret the kinetics. (If the authors of
the package were thoughtful, they would also provide
some warning to the user about the limitations of the
tool with respect to its ability to handle SBML.) In
the end, when the SBML Test Suite is finished and widely
used, applications in this category will be
distinguished from applications having the ability to
work with the kinetics, and users will be able to judge
which applications best suit their needs.

* Question #5: Is it proper to give only the sboTerm values?

Answer #5: It would be acceptable, in the same way that
today an SBML model is not required to have KineticLaw
elements at all. Whether it is "proper" is a more
subjective question.

* Question #6: Should programs that do not understand
sboTerms still keep them and write them out again, even if
they changed something about the model?

PROVISIONAL Answer #6: I think this is a more difficult
question to answer, and we didn't address this (at least
in the white paper I was involved in). I now propose
the following: if an application gets a model with
sboTerms, but it cannot understand sboTerms, then for
any object it modifies, it should remove any sboTerm on
that object. This reduces the changes of creating a
conflicting situation in the model, at the cost of
removing some potentially useful information. But, this
seems to be the safest approach to handling this
situation.

MH

--
Mike Hucka, Ph.D. <mhucka@caltech.edu> tel +1.626.395.8128
Biological Network Modeling Center http://bnmc.caltech.edu
The Beckman Institute @ The California Institute of Technology

>> Answer #4: Let's examine this from the perspective of
>> an application in today's SBML world, without sboTerm
>> in existence. What would an application do if it could
>> not read the kinetic law definition? It could
>> interpret the SBML to some extent (e.g., it could read
>> out the reactants, products and modifiers in a
>> reaction) and perform some manipulations (maybe?), but
>> there is a risk that anything it does would be suspect
>> because the tool is not intepreting the full model. In
>> the end, it could not hope to be a fully compliant SBML
>> application because it can't interpret the kinetics.
lenov>
lenov> IMHO it is untrue. It is perfectly acceptable to
lenov> have SBML files without kineticLaw. SBML coming
lenov> from KEGG, Reactome or *cyc are valid SBML files.
lenov> In addition, if you have all the reactants,
lenov> products and the stoichiometry, you can already do
lenov> a lot of numerical analysis of the models (although
lenov> not time-series). The models would not be
lenov> MIRIAM-compliant, and they would certainly not be
lenov> acceptable in BioModels DB. But they would be valid
lenov> SBML.

Yes, strictly speaking, you're right; sorry for writing it
the way I did. When I wrote "compliant", I was thinking of
the SBML Test Suite and the idea (discussed on and off) of
having a prescribed procedure for validating an
application's handling and coverage of SBML. Such tested
applications would be branded "SBML compliance tested", and
allowed to use the corresponding icon/logo.

>> Likewise, in an sboTerm world, the application could
>> perform some manipulations (maybe) but it could not be
>> a fully compliant SBML application because it did not
>> have the ability to interpret the kinetics.
lenov>
lenov> I do not agree. If you have the adequate sboTerms
lenov> on the speciesReferences, the local parameters and
lenov> the kineticLaw (whatever the math element is), you
lenov> can inerpret the kinetics in some cases.

Well, this is a funny situation. What you say is true, but
it also touches on the other question of what's
authoritative in a model. If the kinetic law definitions
are authoritative, yet an application can't read them, then
the application would not be able to interpret the kinetics
based on the authoritative definition in the model. What
are the implications of this?

MH

RG> [...] (Can there be a kineticLaw without a formula?
RG> Since the math field is not optional, can it be
RG> empty?)

KineticLaw is optional (which is why the math field is not).
See http://sbml.org/specifications/sbml-level-2/version-1/html/sbml-level-2.html#fig:reaction

RG> I think it should only be allowed to use the sboTerm
RG> to simulate the model if there is not formula present.
RG> [...]
RG> I think that it is very important to state which is
RG> the correct behavior in case of potentialy
RG> contradicting information because only one behavior
RG> can be correct here. And since it is not trivial to
RG> make a consistency check in this case, I think we
RG> should state that it is wrong to use the sboTerm to
RG> simulate the model if there is an equation present?

I think you're right that the issue exists.

Your suggestion is an interesting idea. It would be a
stronger version of the guidelines I wrote about earlier
today.

Do we need to put this question to a separate vote?

MH

bshapiro> Its not just the reaction that needs to have the
bshapiro> correct SBO term: don't all of the appropriate
bshapiro> parameter values also need to have corresponding
bshapiro> (correct) SBO Terms (or some equivalent
bshapiro> information) for the kinetic law to be fully
bshapiro> specified independent of the math fields?

But, won't a parameter declared as (e.g.) "rate constant for
first-order mass action" remain the same no matter if the
kinetic law itself is changed? Or (e.g.) "Michaelis
constant"?

bshapiro> So we can't just ignore the kineticLaw if
bshapiro> there is an SBO term, we have to read the
bshapiro> parameter values and figure out where the go in
bshapiro> the reaction specified by the SBO term.

I thought of this when I was writing my other message, but
decided it seemed like the meanings of the quantities and
other elements of a model would stay the same despite that a
change in a formula may change how they are *used*. This
assumption may be incorrect. I'd like to see a case example
if so.

MH

>Some software tools provide users with a pull-down list of
>rate laws, from which the user can select what they want for
>a given reaction. The tool then writes out the appropriate
>math expression into the model. Those tools would like a
>way to go in the reverse direction, from rate law to name.
>Currently there's no systematic way of supporting this in
>SBML, because it requires some sort of additional annotation
>beyond the math of the kinetic expression.
>
>MH
>
>
>
>
Hi Mike,

Thanks for clearifying some of the points and I do agree with most of
them, but I think what you wrote above is somewhat dangerous since it
seems to me that this would encourage people to write software that is
not fully SBML compliant. While I think it is perfectly OK for program
authors to do so, I also think that it should not be encouraged.

Maybe I am missing some point here, but in order to go in the reverse
direction, you would have to check if the formula corresponds to any of
your built in functions which basically is the same as doing a
consistency check on the sboTerm and the given formula. So if tools now
just take the sboTerm and substitute one of their built in equations,
they essentially ignore the formula which makes those tools "SBML
uncompliant" to some extent. If the tools have the capability to do
consistency checks for sboTerms, they actually do not need the sboTerm
any longer since they might just as well check if the the formula
corresponds to one of their built in functions. So in this case the
sboTerm on the kineticLaw is superfluous.
So if you encourage people to do this, you basically encourage them to
write software that is not fully SBML compliant, right?

You also mentioned that you would allow a kineticLaw to just have an
sboTerm, so I guess since the formula attribute is not optional it would
have to be an empty string, right?


Ralph

Hi All,

While thinking aloud to Andrew and Nick at the SBML Forum, I suggested
putting the sboTerm attribute in its own XML namespace. Upon further
reflection, I see no benefits to doing so, only drawbacks. First, it
is uncommon for XML namespaces to apply to attributes at all.
Technically, unless explicitly declared, XML attributes do not belong
to any XML namespace (this makes survey option 2a incorrect). Second,
since some XML technologies are flawed when it comes to namespace
processing (e.g. XPath), putting sboTerm in its own namespace could
cause problems.

Thanks.

Ben


On Dec 20, 2005, at 7:50 PM, Michael Hucka wrote:

> An argument for (b) might that taking the sboTerm attribute
> out of the SBML namespace would encapsulate the things
> dealing with SBO, which perhaps is conceptually cleaner.

Hello all,

Hopefully I'm not presuming too much, but (in my mind) a way to
handle sboTerms might go something like this:

There's two major tasks that use sboTerms: reading & writing SBML files
(ok duh). Each task involves the conversion to or from the SBML to some
internal representation.
Here, we will assume that we have an internal database of SBO terms for
rate laws, species, and kinetic parameters which we may match against.

The database of SBO terms might look like (I'll omit the URL for brevity):

#SBO:000001 1st order mass action reaction
#SBO:000002 2nd order mass action reaction -- bimolecular
#SBO:000003 2nd order mass action reaction -- monomolecular
#SBO:000004 Michaelis Menten reaction
#SBO:000005 Michaelis Menten + Inhibition reaction
#SBO:100001 1st Reactant species
#SBO:100002 2nd Reactant Species
#SBO:100003 1st Product species
#SBO:100004 2nd Product species
#SBO:100005 Enzyme Catalyst #1
#SBO:100006 Inhibitor #1
#SBO:200001 Mass action kinetic constant (x units)
#SBO:200002 Kcat (x units)
#SBO:200003 Km (x units)

'x units' are the units of the parameters.

Using a GUI and a drop down menu, one can add the reaction 'A --> B'
with 1st order mass action kinetics, where 'A' is the '1st Reactant
Species' and 'B' is the '1st Product Species'.
The GUI then writes the following SBML (excuse any errors, but you'll
get the gist):

<listOfReactions>
<reaction id = "Example Reaction"
<kineticLaw>
<sboTerm = #SBO:000001/>
</kineticLaw>
<listOfReactants>
<speciesReference species = "A" stoichiometry = "1" sboTerm
= #SBO:100001 />
<listOfReactants/>
<listOfProducts>
<speciesReference species = "B" stoichiometry = "1" sboTerm
= #SBO:100003/>
<listOfProducts/>
<listOfParameters>
<parameter id = "k1" sboTerm = #SBO:200001/>
</listOfParameters>
</reaction>
</listOfReactions>

This labels 'A' as the 1st reactant species, 'B' as the 1st product
species, identifies the reaction rate law as '1st order mass action',
and signifies the kinetic constant as the mass action kinetic constant
(with a particular set of units).

When reading the above SBML and converting it into an internal
representation in the program, one might do:
-look up the sboTerm for the kineticLaw and find the matching rate
law in the internal list (hard coded for compiled languages)
-match the species in the rate law by creating an index by
identifying where species in the listOfReactants, listOfModifiers, and
listOfProducts belong in the rate law
-convert the units of the parameters to whatever necessary ones
(also using the SBO term of the kinetic parameter to know what the
original units are) and create an index by identifying where each
kinetic parameter belongs in the rate law.

So the rate law for this reaction is r = k * X1. Convert 'k1' to 1/sec,
identify it as the 1st kinetic parameter in the rate law, and identify
'A' as X1. Create indexes to very quickly substitute values of 'A' into
the variable 'X1'.

Ok, now for a Michaelis Menten reaction:

Now, setting the reaction to 'A --> B' but now with the Michaelis Menten
rate law (with an enzyme 'Catalyst' as catalyst), would look like:
<listOfReactions>
<reaction id = "Example Reaction Michaelis Menten"
<kineticLaw>
<sboTerm = #SBO:000004/>
</kineticLaw>
<listOfReactants>
<speciesReference species = "A" stoichiometry = "1" sboTerm
= #SBO:00001 />
<listOfReactants/>
<listOfModifiers>
<speciesReference species = "Catalyst" stoichiometry = "1"
sboTerm = #SBO:10005 />
<listOfModifiers>
<listOfProducts>
<speciesReference species = "B" stoichiometry = "1" sboTerm
= #SBO:00003/>
<listOfProducts/>
<listOfParameters>
<parameter id = "kcat" sboTerm = #SBO:200002 />
<parameter id = "Km" sboTerm = #SBO:200003 />
</listOfParameters>
</reaction>
</listOfReactions>

The rate law for Michaelis Menten is r = kcat*E*S / (Km + S). So,
reading the above SBML and converting it to the internal representation,
might go like:
--Identify reaction as using Michaelis Menten rate law.
--Convert kcat, Km to appropriate units (using sboTerm to denote the
original units).
--Identify the substrate, product, and enzyme species using sboTerms and
create indexes to quickly substitute values.

So 'A' --> 'S' , 'B' --> 'P' , 'Catalyst' --> 'E'.
Note that 'B' is only in the stoichiometry and not in the rate law while
'Catalyst' is only in the rate law and not in the stoichiometry. 'A' is
in both.

Using the sboTerms, it is straightforward to write out the
standard/simplest MathML expression for the kineticLaw. However, _it is
not straightforward to do that in reverse without the sboTerms_.
An example:

Consider the algebraic expression r = E*S / (Km / kcat + S / kcat). Is
this the Michaelis Menten rate law? It is (multiply the top and bottom
by kcat). It is algebraically equivalent. In fact, one can write out an
_infinite_ number of algebraically identical expressions for the
Michaelis Menten rate law. There is no easy way to 'match' an arbitrary
algebraic expression to a hard coded list. That is one major reason why
sboTerms are so needed.

I hope this gives some examples for an informed discussion of the usage
of sboTerms, their necessary, advantages, disadvantages, alternatives, etc.

-Howard Salis

Michael Hucka wrote:

> bshapiro> Its not just the reaction that needs to have the
> bshapiro> correct SBO term: don't all of the appropriate
> bshapiro> parameter values also need to have corresponding
> bshapiro> (correct) SBO Terms (or some equivalent
> bshapiro> information) for the kinetic law to be fully
> bshapiro> specified independent of the math fields?
>
>But, won't a parameter declared as (e.g.) "rate constant for
>first-order mass action" remain the same no matter if the
>kinetic law itself is changed? Or (e.g.) "Michaelis
>constant"?
>
> bshapiro> So we can't just ignore the kineticLaw if
> bshapiro> there is an SBO term, we have to read the
> bshapiro> parameter values and figure out where the go in
> bshapiro> the reaction specified by the SBO term.
>
>I thought of this when I was writing my other message, but
>decided it seemed like the meanings of the quantities and
>other elements of a model would stay the same despite that a
>change in a formula may change how they are *used*. This
>assumption may be incorrect. I'd like to see a case example
>if so.
>
>MH
>
>

Here's my point: reactions may include more than one parameter, and
we need to identify which parameter is which. For example, suppose we
know that a reaction is Michaelis-Menten-Henri, and we know the k1
and the kD. We can not specify this information without giving the
entire math field, because even though the kineticlaw is optional,
if the kineticLaw is present the math is required, and the parameters
are inside of the kinetic law.

Because of this, the sboterms are completely redundant - we can't
have an sboterm on a parameter unless we also have the math.

For example, in the following the SBO terms can be safely ignored:

<reaction id="mmhex" name="Michaelis-Menten-Henri Example"
reversible="false" fast="false">
<listOfReactants>
<speciesReference species="S"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="P"/>
</listOfProducts>
<listOfModifiers/>
<kineticLaw timeUnits="time" substanceUnits="substance"
sboTerm="http://biomodels.net/SBO/#SBO:2222222"/>
<math xmlns="http://www.w3.org/1998/Math/MathML">
<apply>
<divide/>
<apply>
<times/>
<ci>k1</ci>
<ci>S</ci>
</apply>
<apply>
<plus/>
<ci>kD</ci>
<ci>S</ci>
</apply>
</apply>
</math>
<listOfParameters>
<parameter id="k1" value="1" sboTerm="http://biomodels.net/SBO/
#SBO:3333333"//>
<parameter id="kD" value="1" sboTerm="http://biomodels.net/SBO/
#SBO:4444444"//>
</listOfParameters>
</kineticLaw>
</reaction>

but in the following, which is INVALID SBML because it does not have
a math field, All THREE sboterms are needed. If any of the SBOTerms
are omitted, its not possible to figure out the reaction law.

<reaction id="mmhex" name="Michaelis-Menten-Henri Example"
reversible="false" fast="false">
<listOfReactants>
<speciesReference species="S"/>
</listOfReactants>
<listOfProducts>
<speciesReference species="P"/>
</listOfProducts>
<listOfModifiers/>
<kineticLaw timeUnits="time" substanceUnits="substance"
sboTerm="http://biomodels.net/SBO/#SBO:2222222"/>
<listOfParameters>
<parameter id="k1" value="1" sboTerm="http://biomodels.net/SBO/
#SBO:3333333"//>
<parameter id="kD" value="1" sboTerm="http://biomodels.net/SBO/
#SBO:4444444"//>
</listOfParameters>
</kineticLaw>
</reaction>


BES



On Dec 21, 2005, at 5:48 AM, Michael Hucka wrote:

> MH> But, won't a parameter declared as (e.g.) "rate
> MH> constant for first-order mass action" remain the same
> MH> no matter if the kinetic law itself is changed? Or
> MH> (e.g.) "Michaelis constant"?
>
> hds> But the name is OPTIONAL in the spec. There is
> hds> nothing to say that the parameter must be declared
> hds> with such a meaningfull name [...]
>
> Of course. The "declarations" I was referring to are
> sboTerm references, not the names. Parameter would look
> like the following example:
>
> <listOfParameters>
> <parameter id="k" sboTerm="http://biomodels.net/SBO/#SBO:
> 3333333"/>
> </listOfParameters>
>
> where the value of sboTerm is an identifier standing for
> (e.g.) "rate constant for first-order mass action" in the
> controlled vocabulary.
>
> MH
>

But how many different possible models are there? Infinite. So how many
compiled classes will be required? Equally infinite. How is this useful?
I like the sboTerm approach because it avoids these problems.

Martin Ginkel wrote:

> Howard Salis wrote:
>
>> What you're proposing sounds like reading the model file, generating
>> source code using the model information, compiling the source code
>> into instructions, and running those instructions. Like I said, I do
>> not want to recompile my program for every model I simulate. For
>> example, what happens when you want to simulate .... multiple models?
>> Must you recompile for each model?
>
>
> For different models you have different Classes in compiled code, for
> the same model with just different numbers you have another instance of
> the same class.
> No problem.
> It is especially no problem, if you want to be fast during simulation.
>
> Martin

Hello,

On Wednesday 21 December 2005 19:29, Howard Salis wrote:
> <listOfReactions>
> <reaction id = "Example Reaction"
> <kineticLaw>
> <sboTerm = #SBO:000001/>
> </kineticLaw>
> <listOfReactants>
> <speciesReference species = "A" stoichiometry = "1" sboTerm
> = #SBO:100001 />
> <listOfReactants/>
> <listOfProducts>
> <speciesReference species = "B" stoichiometry = "1" sboTerm
> = #SBO:100003/>
> <listOfProducts/>
> <listOfParameters>
> <parameter id = "k1" sboTerm = #SBO:200001/>
> </listOfParameters>
> </reaction>
> </listOfReactions>

While I'm not shure if what Howard suggests should be correct sbml (if I
understand Nicolas correctly he thinks it is not) I think at this point we
should not encourage to specify kinetics _only_ with some vocabulary that is
basically not yet existing. Allowing sbml with kinetics _only_ given as sbo
terms would _require_ software to be aware of sbo to be sbml compliant. We
may want to think about that in a few years when we have evaluated an
existing sbo vocabulary.

Sven
--
Sven Sahle
EML research gGmbH, Heidelberg, Germany

Nicolas Le Novère wrote:

>> RG> [...] (Can there be a kineticLaw without a formula?
>> RG> Since the math field is not optional, can it be
>> RG> empty?)
>>
>>KineticLaw is optional (which is why the math field is not).
>>See
>>http://sbml.org/specifications/sbml-level-2/version-1/html/sbml-level-2.html#fig:reaction
>>
>>
>
>Yes but the sboTerm is in kineticLaw. So the question is could-we have a
>kineticLaw with just an sboTerm and no math element? The answer is no. An
>empty math element. The answer is yes, but then there is an inconsistency
>between the mathML provided by the sboTerm and the one provided by the
>kineticLaw. Back to the starting point.
>
>
>

The question is, do we consider an empty math field to be a formula or
do we consider it to mean that there is no formula specified.
Alternatively, we could think about making the formula attribute
optional in Level 2 Version 2, so if no formula attribute was given and
no sboTerm was given, this would be the same as if there was no
kineticLaw, if both are given, the formula is what counts.

R.