A Minimal OO Calculus for Modelling Biological Systems

In this paper we present a minimal object oriented core calculus for modelling the biological notion of type that arises from biological ontologies in formalisms based on term rewriting. This calculus implements encapsulation, method invocation, subtyping and a simple formof overriding inheritance, and it is applicable to models designed in the most popular term-rewriting formalisms. The classes implemented in a formalism can be used in several models, like programming libraries.

💡 Research Summary

The paper introduces a minimal object‑oriented (OO) core calculus designed to capture the notion of “type” that arises in biological ontologies, and to embed this notion into term‑rewriting based formalisms commonly used for modeling biochemical systems. The authors argue that biological entities such as enzymes, substrates, and products are naturally organized into hierarchical classifications that resemble computer‑science type systems. However, existing computational models (Petri nets, hybrid systems, π‑calculus, CLS, P‑systems, etc.) rarely incorporate a formal type discipline, which limits error detection and model reuse.

The proposed calculus provides only the essential OO features deemed sufficient for biological modeling: encapsulation (methods are collections of rewrite rules), method invocation, single‑inheritance subtyping, and a simple form of method overriding. A class is declared as class C extends D { M }, where M is a set of method declarations. A method has the form m(C x) R, where x are typed parameters and R is a sequence of reduction rules written in the syntax of the underlying formalism. The special variable this denotes the object on which the method is invoked.

Method invocation v.m(t) is the sole dynamic evaluation rule. When the value v has type C in the static environment Γ, the calculus looks up the method’s parameter list and body (possibly inherited from a superclass). The body’s variables are substituted with the actual arguments t, and this is replaced by v. The resulting instantiated rewrite rules are then inserted into the model, replacing the original method call. This mechanism turns high‑level OO specifications into concrete term‑rewriting rules without altering the semantics of the host formalism.

Subtyping is defined directly by the class hierarchy: if class C extends D appears in the class table CT, then C <: D. The relation is reflexive and transitive, allowing the usual “is‑a” reasoning. The typing rules enforce that (i) a method’s declared parameter types are respected by its body, and (ii) a method call is well‑typed only when each actual argument’s type is a subtype of the corresponding formal parameter type. Consequently, biologically meaningful constraints—such as “an enzyme cannot be used as a substrate” or “a hydrolase only acts on sugars”—are guaranteed statically.

The authors illustrate the calculus with a series of biologically motivated examples. An abstract Enzyme class defines a generic action(S,P) method that rewrites S + this → this + P. Specific enzymes (e.g., lactase, phosphoglucose isomerase) are instantiated as objects of type Enzyme and invoked with concrete molecules, yielding concrete rewrite rules like glucose‑6‑ph + lactase → lactase + galactose. Subclassing is used to specialize behavior: Hydrolase extends Enzyme and overrides action to include water as a reactant and produce two products; GlycosideHydrolase further refines the parameter types to Sugar, thereby restricting the method to sugar substrates.

The calculus is then applied to two prominent term‑rewriting formalisms. In the Calculus of Looping Sequences (CLS), method bodies are expressed using the E1 ⇋ E2 notation, and class tables are fixed before simulation. In P‑systems, method bodies become membrane transformation rules. In both cases, the class table and the typing environment are immutable during execution, ensuring that the type discipline does not interfere with the dynamics of the underlying system.

The paper concludes by highlighting the benefits of the approach: (1) a clear modular organization of rewrite rules into reusable classes, (2) static type checking that catches biologically implausible interactions early, and (3) the possibility of building libraries of biological “classes” that can be shared across models. Limitations are also acknowledged: only single inheritance is supported, advanced OO features such as interfaces, generics, or multiple inheritance are absent, and complex conditional or context‑dependent rewrite rules would require extensions to the basic calculus. Future work is suggested in the direction of enriching the type system, automating class extraction from existing ontologies, and integrating the calculus with additional formalisms.

Overall, the work represents a novel synthesis of object‑oriented abstraction and term‑rewriting biology, offering a promising pathway toward more robust, reusable, and type‑safe computational models of biochemical processes.