Abstract
Modeling functions is a key aspect of artifact design, including software engineering and business systems modeling, but it is likewise of fundamental importance in natural systems modeling, for example in modeling biological organisms. The Unified Modeling Language (UML), which originated from object-oriented software engineering, is nowadays a de facto standard for conceptual modeling and its current applications go far beyond software engineering. The paper investigates first to what extent UML is suited for modeling functions. We survey various approaches to function modeling with UML and identify their limitations. Based on the conducted analysis, we introduce a UML profile for function modeling, called the Function Modeling Language (FueL). FueL enables the modeling of the structure of functions, of relations between functions, such as function decomposition, as well as of function ascription, i.e., of relations linking functions with other types of entities. The main application field that we considered while developing FueL is bioinformatics. Nonetheless, the presented profile is domain-independent and is capable of modeling cross-domain systems. The profile has been tested on fragments of the Molecular Function Ontology, a sub-ontology of the Gene Ontology. In this connection the paper further demonstrates that the applications of FueL transcend the construction of new models, by showing how the profile aids restructuring and refactoring existing models.
Introduction
The present work is primarily concerned with the problem of modeling functions. Our interests do not concern the mathematical understanding of a function as a set of tuples that satisfies certain uniqueness conditions. Rather, we are interested in the common sense usage of this term and its ontological interpretation, for example, when saying that the function of a warehouse is to store goods, or the function of the heart is to pump blood. Functions are modeled in many areas of engineering, such as mechanical engineering, software engineering or business and enterprise modeling. They are also a key aspect of modeling systems in general, for instance, encompassing natural systems such as biological organisms.
The de facto standard for graphical conceptual modeling of software systems is the Unified Modeling Language (UML) (Rumbaugh et al., 2005), currently developed and maintained by the Object Management Group (OMG).1
The high potential of modeling natural systems with UML lies not only in the language itself but also in the related infrastructure and the available tools. UML has built-in extension mechanisms such as stereotypes and profiles, which allow for constructing domain- or task-specific UML dialects. Furthermore it has a rich library of tools, which has a decades-long record of successful application in software engineering and systems modeling, both in academia and industry. Today, when applying UML for a new task of modeling biological knowledge, all of those tools are ready to be used out of the box. This is a significant boost factor for graphical modeling of natural systems, since neither need new languages/graphical notations nor tools enabling their usage to be developed from scratch. Instead, the UML infrastructure can be utilized. Having the above in mind, in this paper we consider UML not as a mere software engineering formalism, but instead as a cross-domain, general purpose modeling lingua franca, which has a high potential of depicting not only artificial but also natural systems.
The important aspect, which occurs across many domains, is modeling in terms of functions. The first goal of the research reported here is to find out to what extent UML, as a general purpose language for various domains, supports function modeling. Accordingly, we analyze the means that UML offers for function modeling. Section 3 reports several limitations that we have encountered in this respect. Therefore we propose to extend UML with notions that support comprehensive and full-fledged modeling of functions.
Function modeling is supported by numerous modeling frameworks, especially in many engineering domains, including mechanical engineering, software engineering as well as systems and enterprise modeling. The goal of the current paper is not to develop yet another function modeling formalism, but instead to investigate purely the modeling or engineering question, i.e. how to model functions with UML effectively, in particular in the field of bioinformatics. It is further not our goal to provide yet another account of functions. Rather, based on the rich results from the areas of function modeling in mechanical engineering, software and systems modeling as well as ontological modeling, we provide means for modeling functions, their ascription and their decomposition by means of UML. The UML extension that is expounded in the present paper is constructed upon foundations from the literature on the subject, as referred to below, and on our own ontological research conducted in the framework of the General Formal Ontology (GFO)2
The paper is structured as follows. Section 2 provides an introduction to the notion of function and to modeling functions. Section 3 investigates the means for function modeling that are available in UML. Our extension of UML, called the Function Modeling Language (FueL), is introduced in Section 4. The subsequent Section 5 illustrates an application of it to the Molecular Function Ontology (MFO), a sub-ontology of GO. FueL is designed to enhance the function modeling capabilities of UML. Accordingly, Section 6 compares it with standard UML constructs for functional modeling. Moreover, its final subsection responds to remarks on the present article in the introduction to this special issue by Artiga (2016). Overall conclusions and future work are reported in Section 7.
Notions of function
The term ‘function’ is ambiguous and has many interpretations, which is reflected by a rich philosophical discussion addressing notions of function both in the context of natural/biological systems (Artiga, 2011; Wouters, 2005) and of artificial systems (Houkes and Vermaas, 2010). In mechanical engineering several frameworks for function modeling have been introduced, among them Multilevel Flow Modeling (Lind, 1994; 2011), the Functional Concept Ontology (Kitamura et al., 2002), Functional Representation (Chandrasekaran, 1994; Chandrasekaran and Josephson, 2000), Function–Behavior–Structure (Qian and Gero, 1996), the Causal Functional Representational Language (Iwasaki et al., 1995), Function Behaviour State (Umeda and Tomiyama, 1995) and Functional Basis (Stone and Wood, 2000). In the area of software engineering and systems modeling the modeling of functions has a similarly long tradition. It plays a crucial role not only in structured approaches, in which functions are the main elements of abstraction (DeMarco, 1979; Yourdon and Constantine, 1979; Yourdon, 1993), but also in other modeling frameworks such as the Object Process Methodology (OPM) (Dori, 2002) or Axiomatic Design (Suh, 2001). Furthermore, functions play a prominent role in business and enterprise modeling, e.g. in The Open Group Architecture Framework (TOGAF) (The Open Group, 2011), as well as they have received recent attention in the context of ontologies, for instance, triggered by biomedical applications (cf. e.g. Arp and Smith, 2008; Burek et al., 2006).
In the present paper we understand the function model of an item as a model that focuses on the purposes or goals associated with that item, instead of other aspects, such as physical structure, behavior or history. Function models are present in most domains of engineering, including all of those concerned with technical artifacts, among them software. As observed by Shimomura et al. (1998), function models are helpful at several stages of artifact design, i.e. during requirement specification, designed artifact specification and evaluation. Functional requirements are undoubtedly of great importance in software engineering, as it is reflected in requirements classifications such as FURPS and FURPS+ (Grady, 1992).4
The acronym FURPS stands for the terms Functionality, Usability, Reliability, Performance and Supportability.
In order to investigate how well UML is suited for function modeling, we list requirements for a succinct function modeling formalism below. We are not aware of any comparable compilation of the subsequent requirements in the literature. However, the requirements themselves are not new and, as presented below, they are fulfilled by numerous function modeling frameworks across the fields of software, systems and mechanical engineering.
We argue that formalisms for function modeling should meet the following requirements.
Specification beyond natural language
labels. Natural language names for functions are crucial for human users
and therefore they are a part of function specification in many function modeling
frameworks, both in the field of mechanical engineering (e.g. Chandrasekaran, 1994; Iwasaki et al., 1995; Kitamura et al., 2002; Takeda et al., 1996; Umeda
and Tomiyama, 1995) as well as in software
and systems modeling (Barker and Longman, 1992; Dori, 2002; Yourdon, 1993). However, a natural language label alone
can be insufficient for the specification of a function. Therefore the structure of
a function is often depicted with additional components. For example, for
Chandrasekaran (1994) the function name
is only one out of six components for specifying a function, the remaining being
type, goal, conditions, device, and a causal process realizing the function.
Overall, the specification of functions beyond natural language labels yields a
clearer understanding and representation of
functions. Separation of function from
realization. For any single function there may be numerous ways of its
realization. For example, the very same function “to pump blood” can be realized by
a natural or an artificial heart. Each of them reaches the same goal, which is to
pump blood through the vessel system, yet the way in which they achieve that is
different. Thus it is necessary that a function modeling formalism enables precise
function specifications independently of particular realizations. Many frameworks
account for that demand, for instance, Kitamura et al. (2002) separate a functional level from realizing functions at
a behavioral level; Lind (1994)
distinguishes components and their behaviors from functions, which in turn
contribute to the achievement of goals. In systems modeling, Axiomatic Design
(Suh, 2001) separates functional
requirements from design parameters realizing them. Another common function
decomposition pattern, which relates to the previous item, is to extend the
definition of a function by a mode of realization. Remaining at Axiomatic Design for
illustration, there a zigzagging process of functional requirements decomposition
results in mapping a function to alternative design parameters. Based on that
general decomposition pattern we think that a function modeling formalism should not
only separate the notions of function, goal and mode of realization clearly, but
moreover it should identify their interdependencies
properly. Separation of function from
behavior and process. The interplay between function and behavior is
present in various function modeling frameworks, e.g. in Multilevel Flow Modeling
(Lind, 1994; 2011), the Functional Concept Ontology (Kitamura et al., 2002), Functional Representation
(Chandrasekaran, 1994), the Causal
Functional Representational Language (Iwasaki et al., 1995) and Function Behaviour State (Umeda and Tomiyama, 1995). Moreover, functions are often
considered in relation to behaviors or processes, as in the Basic Formal Ontology
(BFO) (Spear, 2006), for example, where
functions are realizable by time-extended processes. For Chandrasekaran (1994) a description of a causal process that
realizes a function is part of the function specification. The notion of
process is a topic in itself. For the purposes of this paper, we thus treat it as a
primitive, covering the following intuitions: a process is a time extended happening
in which items of various types can take part/participate. This understanding of the
notion of process is aligned with the approach adopted by many top level ontologies,
where processes are linked with objects participating in them, e.g. in BFO
(Spear, 2006), the Descriptive Ontology
for Linguistic and Cognitive Engineering (DOLCE) (Masolo et al., 2003) and GFO (Herre, 2010; Herre et al., 2006). We understand a behavior as a process of a particular type, namely
as a process which is “a doing of” some object. This understanding corresponds to
the UML account of behavior, where a behavioral classifier responds to a request by
invoking a behavior, whose fundamental unit is an action, which takes a set of
inputs and converts them into a set of outputs. With this understanding of
behaviors and processes in mind, we argue that functions cannot be identified with
behaviors or processes, because not every realization of a function is a behavior or
a process. For example, Keuneke (1989)
discusses so-called passive functions, which are not realized by
active behavior, but by the structure of an entity. Accordingly, the function of a
fence around an estate, namely A corresponding, clear separation between function and
behavior/dynamics can also be found in the Object Process Methodology (OPM)
(Dori, 2002). Dori argues that a
function and its dynamics are often confused synonyms, while in fact they are
distinct concepts. According to him a function is about ‘what’ a system does and
‘why’ it does it, whereas dynamics is about ‘how’ the system acts or operates in
order to attain its function (Dori, 2002, p. 257). It is worth mentioning that, according to Dori, a behavior is
not the only way in which functions can be realized. Instead, as he points out, a
combination of structure (or form) and behavior (or dynamics) can realize a
function. In some systems, even a structure alone can account for that, where he
refers to bridges and sundials as examples (Dori, 2002, p. 261f.). Merged input–output
view and participant view. In many cases functions are considered in
terms of input–output pairs, e.g. by Rodenacker (1971), however, the former cannot be reduced to the latter. Especially in
the contexts of resource allocation and scheduling it is necessary to model the
interplay of entities that are involved in function realization. We call the view on
functions that focuses on the entities involved in function realizations the
participant view. It can be found in numerous function modeling
frameworks. For example, in structured methods the data input object and the data
output object on which a function operates are often part of function models
(DeMarco, 1979; Yourdon and
Constantine, 1979). For
Chandrasekaran (1994), in turn, the
device, which is an entity executing a function, is a part of a function
specification. We contend that a function modeling framework should enable the
modeling of various perspectives on functions, in particular including the
input–output view and the participant
view. Representing dependencies between
functions, including function decomposition. Functions are rarely modeled
in isolation. Instead, they are typically organized in complex networks in which
multiple functions interfere. A very popular method of hierarchical function
organization is function decomposition, where a root function is
decomposed into its subfunctions. This method is well-known not only in software
engineering (e.g. Sommerville, 2004),
business modeling and enterprise architecture modeling (e.g. Eriksson and
Penker, 2000; The Open Group, 2011), systems modeling (e.g. Dori, 2002), and mechanical systems engineering
(e.g. Kitamura et al., 2002; Lind, 1994; 2011; Pahl et al., 2007), but it
is likewise a popular approach in the natural sciences. For instance, the Gene
Ontology (GO) (cf. du Plessis et al., 2011; The Gene Ontology Consortium [GOC], 2004) decomposes ‘molecular function’, one of its three root nodes, into a
tree of over 8,000 functions.
UML and function modeling
As summarized in the introduction, the Unified Modeling Language (Rumbaugh et al., 2005) is currently not only used for OO software engineering, but also as a general-purpose conceptual modeling language which is utilized both in engineering and in the natural sciences. Since function modeling is a crucial part of conceptual modeling, in this section we investigate the UML approach to modeling functions.
UML is founded on an explicit distinction between the static and the dynamic views of a system; it introduces twelve diagram types, grouped into two primary sets: structural modeling diagrams and behavioral modeling diagrams. UML lacks a function construct dedicated to function modeling as such, yet several constructs appear to be fairly good candidates for modeling functions. The most promising among them are use cases, interfaces, operations and collaborations. In this section we investigate how functions can be modeled by these means.
Use cases
The use case diagram is a behavioral diagram that is intended for representing the overall functionality of a system, of a subsystem, or of a class perceived by (and available to) users that are external to the system, called actors. Each use case shall represent a coherent unit of functionality. It captures what a system or a subsystem, a class or an interface does in interaction with external actors. A use case is not intended to specify how the system realizes a function. Instead, this is supposed to be provided in terms of other UML diagram types, e.g., as corresponding sequences of events in a sequence diagram. Additionally, as presented in Fig. 1, use case diagrams can be used for modeling function decomposition by means of generalization.

An exemplary UML use case diagram presenting a selection of a Banking System use case
diagram. Ovals depict use cases and stick man icons represent actors. The association
between a use case and an actor involved in it is depicted by a line between the two.
Use cases are realized by the system, i.e. the subject, which is depicted by the
rectangle. Use cases can be interlinked by several types of relations. Among these are
generalization, depicted by an empty-head arrow, and the include relation, shown as a
dashed arrow stereotyped with
Considering use cases as a formalism for representing functions raises several issues. Firstly, a use case comprises both the behavior and the function of a classifier. Although use cases specify what a system does and not how, the explicit difference between the notion of function and behavior is not provided in UML. These two notions are often used interchangeably, i.e. on the one hand, a use case is understood as a coherent unit of functionality (Rumbaugh et al., 2005, p. 668) and, on the other hand, as a descriptor of a potential behavior (Rumbaugh et al., 2005, p. 669).
Secondly, use cases lack a specification beyond a natural language expression. The only precise definition of a use case can be given by its owned behavior, realized by a subject and further involved users. However, that does not specify the use case, but rather its realization. Thus, although use cases are intended to represent what is to be done instead of how it is realized, in the end their semantics is given by a specification of the latter instead of the former.
Thirdly, since use cases are behavioral diagrams, we argue that they do not provide means
to model functions separately from behavior. This situation leads to a confusion of the
notions of function and behavior, and it actually reduces functions to behaviors. Use
cases were invented for modeling dynamic systems such as software, in which it is quite
natural to consider the functionality of the system as its behavior. Unfortunately, this
approach may become cumbersome when a system realizes not only active but also passive
functions. For instance, it is rather unnatural to specify the functionality of the fence:
Concerning the requirement of supporting the participant view on functions, one can see
that use case diagrams provide means for relating functionality with the entities
participating in its realization. This can be achieved, firstly, by means of a subject
and, secondly, in terms of actors. A subject is an entity that is involved in the use case
and to which the functionality defined by that use case applies. Actors are associated
with the use case and model external participants of it. The application of those
constructs comes at the risk of realization-biased use case specifications. For example,
if one defines the use case
Another difficulty that arises when modeling functions with UML use cases is implied by the fact that use cases are intended to represent functions available to external actors only (OMG, 2011b). This means that use cases cannot directly be used for modeling internal functions of a subject (and their participants, in particular), i.e. for functions that are not exposed to external actors (from the point of view of the subject).
When it comes to modeling function decomposition, it seems that UML generalization together with the include relationship are appropriate, cf. Fig. 1 for an example. A minor problem for a modeler is to decide which of these distinct relations should be chosen. Although the distinction between generalization and include relationships is of value in detailed models, it is typically not important in early phases of design, for which a single relation might be sufficient.
Intuitively speaking, the include relation captures a kind of part-of relation between
functions, which is of high value for modeling. However, some semantic problems may occur
if include is used for modeling passive functions. The include link is founded on the
relationship between the behaviors of use cases. This prevents its use in situations where
a function is realized by the structure of an entity instead of its behavior. It is also
problematic to use the include relation if a use case can be realized by several different
behaviors, as in the example of the function
Finally, modeling causal dependencies between functions is not well supported by use case diagrams. Informally a relationship called invoke is often used for that purpose, possibly borrowed from the OPEN Modeling Language (Firesmith et al., 1998).5
The acronym OPEN stands for Object-oriented Process, Environment and Notation.
Apart from use cases, UML comes with other constructs that appear suitable for modeling functions, namely operations and interfaces. As defined in (OMG, 2011b, p. 105) “an operation is a behavioral feature of a classifier that specifies the name, type, parameters, and constraints for invoking an associated behavior”. Analogously to use cases, operations resemble functions in their input–output character – they are defined by sets of pre- and post-conditions. However, in contrast to use cases, pre- and post-conditions in operations are handled formally in UML as associations to constraints. Furthermore, the application of operations for function modeling nicely decouples the specification of what should be done from how it should be done by the separation of operations from their realizing behavior. What may be problematic in utilizing operations for modeling functions is that operations, like use cases, are assigned to owners. This can cause a realization bias in the specification of operations.
The problem could be solved by modeling functions as operations owned by interfaces. Interfaces are UML elements which can own operations and which are specified independently of particular realizations. A function could then be modeled as an interface together with an owned operation, as it is presented in Fig. 2. This approach drives the specification of functions beyond using mere natural language expressions. Additionally, it distinguishes the specification of functions and their realizations and thus enables the corresponding separation of modeling aspects, as described in the previous section. Moreover and similarly to use cases, functional decomposition can be handled by the generalization relation, which here can be set between interfaces.

An example of a UML interface. An interface is depicted by a rectangle labeled with
the stereotype
Unfortunately, this approach likewise raises some difficulties regarding, firstly, the requirement of the separation of function from behavior and, secondly, the handling of the participant view on functions. Concerning the former, the operation owned by an interface is a UML behavioral feature, i.e. a feature that specifies the behavior of a classifier. Thus, utilizing interfaces together with owned operations for representing functions would not allow for handling passive functions, but only for functions related to behavior. Secondly, operations provide no means beyond the specification of parameters for introducing participants and the roles that they play in operations. Parameters, in turn, indicate the entities involved in operations only indirectly and give no hint on the role that those entities play in the context of an operation. Interfaces, in contrast, can be interrelated with other UML constructs – in this way involved participants could be introduced. However, UML provides no means for a deeper understanding of such function participants.
After use cases, interfaces and operations, collaborations can be considered as another candidate UML construct which is of interest for representing functions. A collaboration “describes a structure of collaborating elements (roles), each performing a specialized function, which collectively accomplish some desired functionality” (OMG, 2011b, p. 174). In contrast to the UML elements discussed so far, a collaboration focuses on the entities involved in the realization of functions and, by specifying their interplay, it accounts for the specification of a function beyond natural language labels. A collaboration example is presented in Fig. 3.

An example of a UML collaboration. The collaboration is displayed as an oval with dashed border. The roles participating in the collaboration are depicted by interfaces linked to the collaboration with dashed arrows (i.e. dependency associations).
Interestingly, a collaboration indicates its participants not by a direct relationship to them, but by the references to the roles that the participants play in the context of the collaboration. Collaboration roles specify the required set of features that a participating instance must have in a collaboration. They can be specified by means of interfaces, such that they are independent of realizing classifiers. Consequently, such a specification of a collaboration is independent of particular realizations. For instance, in Fig. 3 the class Customer is not present, but instead the role Depositor is shown, which a customer would play in the context of a collaboration.
Unfortunately, in analogy to use cases, interfaces and operations, collaborations are specifications of behaviors and therefore are limited to active functions only. Additionally, in contrast to operations, which focus on the input–output perspective and have limited means for presenting the participant view on functions, collaborations handle the participant view, but not the input–output view.
It is further not very clear whether collaborations enable the separation of modeling aspects: on the one hand, they are considered as general specifications of functionality that can be realized differently by various participants that fulfill collaboration roles, but on the other hand, collaborations themselves are used to specify the realization of use cases.
Finally, function decomposition can be handled in collaborations by means of generalization, analogously to other constructs discussed. Yet again that provides no further insights into the nature of function decomposition.
Summarizing the above analysis one can see that UML does not provide a clear-cut and precise notion of function. Instead, several aspects identified in Section 2 are scattered across various distinct UML constructs. Some of these constructs, e.g. operations, focus more on the input–output view whereas others, such as collaborations, support the participants view. Use cases, in turn, cover functions of particular types, namely, transactions between a system and external actors. Altogether, a modeler who intends to utilize UML for function modeling faces a difficult choice between several constructs, each of which supports function modeling partially, but none enabling it to a full extend.
Moreover, it is shown above for all discussed constructs that the UML understanding of function is closely related to the notion of behavior. This prevents using them for modeling passive functions. Additionally, the interdependencies between some of these constructs, e.g. realizations of use cases by collaborations, complicate a clear understanding of the notion of function that underlies UML.
Eventually, although UML generalization can be used to model function decomposition, that yields no insights into the nature of function decomposition and, in fact, it identifies function decomposition with the general-purpose relation of generalization.
FueL: A UML profile for function modeling
The previous section reveals some limitations of UML with respect to representing functions and functional knowledge. UML adopts two main views, namely the structural and the behavioral, and it lacks an independent functional view. Although a functional view (as distinguished from the behavioral perspective) may not be required in the context of object-oriented modeling, it is of value where UML is employed as a general purpose language for conceptual modeling.
Therefore, we propose to introduce a dedicated functional view for UML. The suggested extension supports the modeling of a broad spectrum of domains that require functional concepts. It is not limited to software and systems engineering only, in particular, it is likewise applicable to modeling in the domain of the natural sciences.
We extend UML with a functional view by using a lightweight UML built-in extension mechanism called a profile (cf. OMG, 2011b, Section 18). A UML profile is “a kind of Package that extends a reference metamodel” (OMG, 2011b, p. 670). The primary extension construct of a profile is the stereotype, which is defined as an element of the Profiles package. A profile introduces several constraints or restrictions on ordinary metamodeling through the use of the metaclasses defined in this package (OMG, 2011a, p. 184). By means of profiles a new dialect of UML can be defined to customize the language for particular platforms (e.g., J2EE/EJB,.NET/COM+) and domains (e.g. finance, telecommunications, aerospace). Furthermore, UML profiles have been introduced on the basis of results of ontological investigations, motivated by the need to clarify the real world semantics of UML core concepts (Guizzardi et al., 2004). For example, OntoUML (Guizzardi, 2005) is a profile that addresses some problems of UML regarding its ontological expressivity. The goal of OntoUML is to increase the capabilities of UML in making ontological distinctions explicit that are present in a domain, which, in turn, supports modelers in expressing a domain conceptualization (Guerson et al., 2014).
We follow the same general ideas and propose a profile for function modeling – the
The more obvious acronym FuML, which was used in earlier phases of this work, has been abandoned in favor of FueL for better distinction from Foundational UML (fUML) (OMG, 2016).

The FueL stereotypes designed for modeling a single function, its structure and its assignment to entities. An exemplary application of some of these stereotypes is presented in Fig. 5.

An exemplary FueL model depicting – in two modes of representation – a function with
its structure as well as its assignment to an entity via has-function relations. The
top-part of the figure with a single UML class shows the compact notation, whereas the
extended notation is at the bottom. The model represents that
UML profiles are usually specified by a diagram depicting the dependencies between the
introduced stereotypes and their UML metaclasses, and by the set of UML stereotype
specifications. In this paper the stereotype dependencies are split into two diagrams,
Figs 4 and 7. The formal UML
specification of the profile is published in (Burek and Herre, 2015), whereas it is omitted here for the sake of compactness.
Instead, we introduce the stereotypes in terms of natural language specifications, augmented
with partial formalizations in standard first-order logic. For those formulas we assume the
ontological distinction between categories and individuals, which most closely corresponds
to the OO notions of classes and objects. We explicitly indicate whether the arguments of a
predicate are categories or individuals by means of (possibly multiple) subscripts
The task of modeling functions can be split into three subtasks, namely (1) modeling the
structure of a function, i.e. itself and the elements that constitute its specification;
(2) the assignment of a function to an entity, in the sense that an entity
E has a function F; (3) the modeling of the
interdependencies between functions, for instance, the modeling of function decomposition,
in which a function F is decomposed into functions
Function
The notion of function has a rich literature across many scientific and engineering fields, yet there is no consensus on its single reading. Surveys (including Burek, 2006; Erden et al., 2008; Perlman, 2004; Wouters, 2005) witness the many definitions of function proposed in engineering, philosophy and ontology research. A popular family of accounts of function is formulated in terms of the notion of role. For example, Kitamura et al. define a function as a role played by a behavior and specified in some context (Kitamura and Mizoguchi, 2004; Kitamura et al., 2006). Similarly, Lind represents a function as a role that an item plays in the achievement of the goals of the system(s) of which the item is a part. Chandrasekaran and Josephson (1998; 2000) define the object O to have a role F in the world W if and only if (iff) O causes F to be satisfied in W. If F is intended or desired by an agent A, who is a designer or a user of O, then O is said to have or perform the function F in W for A.
In the context of biological systems functions are also defined in terms of roles. For example, Karp (2000) indicates that a biological function of a molecule can be described in terms of the role that a molecule plays in a biological process. He recognizes four roles that can be identified for biological functions, namely substrate, catalyst, modulator and cofactor (Karp, 2000, esp. p. 275f. and p. 284).
Following the above intuitions, the notion of function in the presented profile is
constructed based upon the notion of role. We follow the very general understanding of a
role presented in (Loebe, 2007), where a role
individual is defined as a relational entity that links any entity, called the role
player (or filler), with some context, in which the entity plays that role. Hence, one
can say that a role is that which is played by some entity in a given context, formally
captured as
We take the notion of context as a primitive here and, following Loebe (2007), we understand it as “a more comprehensive
whole in which a role may be interpreted as a part”. In that sense, the
This
relation is primarily called
At the categorial level we adopt the following two axioms stated by Loebe (2007) as weak restrictions on role categories in
connection with role playing and having contexts, respectively.
The former formula expresses the constraint that if y’s instances
cannot play roles of type x (the meaning of
Based on the observations from the literature above and the discussed role understanding, we are almost prepared to introduce the notion of function. A missing component, which is elucidated in detail in Section 4.1.2, is the notion of goal achievement. It draws its inspiration directly from Lind’s (1994) representation of function as a role that an item plays in achieving some goal. To provide a rough, first intuition, at this stage one may think of a goal achievement as a process or a situation (categorially) that is associated with a goal, which is to be brought about or maintained.
A function is a category that captures a role occurring in the
context of a goal achievement. The function is then said to have that goal
achievement.
Before we provide a specification for goal achievement, let us illustrate this
characterization with the example of the molecular function
Goal achievement
The notion of goal achievement is intended to grasp the teleological character of a function – its orientation at a goal. This aspect of functions is stressed in many approaches to function representation. For instance, Sasajima et al. (1995) define a function as a teleological interpretation of B1 behavior, where B1 behavior is considered as a change of an attribute value of an operand from that at the input port of a device to that at the output port of the device. Chandrasekaran and Josephson (1998) identify the function of a device with the effect “that the object under discussion has on its environment”. In Functional Representation (Chandrasekaran, 1994) and in the Causal Functional Representational Language (CFRL) (Iwasaki et al., 1995) a goal, understood as the state in which function realization results, is an explicit part of function specification. Last but not least, Gero (1990) and colleagues (Qian and Gero, 1996) consider a function as the result of a behavior, as its effect or product.
Those intuitions lead us to the notion of goal achievement, which is meant to capture teleological, i.e., goal-oriented, transitions from one situation to another. In order to capture this notion more precisely, we provide characterizations of a notion of goal, in order to account for the teleological aspect, as well as of transition. Both are introduced as starting points for the purposes of this paper. Especially the case of goal certainly constitutes only a first and rough approximation of an actual ontological analysis of concepts labeled with the term ‘goal’.
(Goal).
A goal x is a teleological situation, i.e., a situation (considered
to be) of utility, determined as or through a kind.
This notion of goal is based on utility as a primitive, denoted by
A situation is a state of affairs that is composed of facts and can be comprehended as a whole. We interpret situations very broadly here – they can vary in their complexity depending on the number of objects that they contain, as well as on the features and interrelations of those objects. In our running example we consider ‘carbohydrate being located on the one side of the membrane’ as a situation.8
While the notion of situation is deliberately only weakly constrained in this paper, it is influenced by the understanding of situations in GFO, which can be found in (Herre, 2010, Section 14.4.6; Herre et al., 2006, Section 11).
The second notion required for capturing goal achievement is the idea of transitions.
At the level of individuals we capture this aspect of the transition from one situation
(or state) to another by means of the primitive ternary relation
A transition x leads from one situation y to
another situation z.
A special class of transitions are causal transitions, where much background intuition on the notion of causality rests on the work by Michalek (2009), which is compatible with GFO. We consider two kinds of such transitions. A causal transition x from y to z is either a causally mediated process9
For example, it is a process with causal cohesion in the sense of Michalek (2009, Section 5.2.3).
Baumann et al. (2014) present the notion of coincidence in connection with theories of time in GFO.
The case of two situations at coincident time points is a borderline case in connection with “after”.
Although we utilize the ontological understanding of causality and situation aligned with GFO, notably FueL as such is agnostic about the ontological interpretation of those notions and can also be employed if different theories of situations and causality are utilized.
With goals and transitions available we are prepared for the formal introduction of goal achievements.
A goal achievement (GA) is a teleological transition, i.e., a
transition to a situation that is (considered to be) a goal.
Overall, a goal achievement category accounts for a teleological specification of transitioning to what is intended to be achieved, hence, to what is expected. It describes the context in which an item has (and possibly realizes) a function. Typically, GAs are realized by processes, in which case a GA category can be understood as a process category. In the running example, the GA is a teleological process category describing the process of carbohydrate transfer from one side of the membrane to the other. Accordingly, the process exhibits the causal transition from the situation of carbohydrate being on one side of the membrane to the situation in which carbohydrate is on the other side of the membrane. However, as we will demonstrate in Section 4.3, GA is a broader concept, the instances of which cannot be reduced to temporally extended processes only.
Input–output perspective
GAs support the modeling of two aspects of functions: the input–output perspective and the participant perspective. Defining a function in terms of input–output pairs has a long tradition in modeling technical artifacts. For instance, Rodenacker (1971) defines a function as a relationship between input and output of energy, material and information. Borgo et al. (2011) indicate that an overall artifact function is often given in terms of input and output flows and Goel et al. (2009) characterize a function as a schema that specifies its preconditions and its expected postconditions. Similarly, Wirth and O’Rorke (1993) define a function, among others, by the input flux and the output flux. For example, the function of a hot–cold water facet can be understood as follows: the input fluxes are hot and cold water, while the mixture of both is the output flux. In the area of software engineering and systems modeling, especially in the framework of structured methods, a function is considered as a transformation of an input object into an output object (Yourdon, 1993).
It is worth mentioning that input–output pairs are not only used for modeling functions, but likewise for modeling processes. For example, the Business Process Modeling Notation (OMG, 2011c), a widely used business process modeling formalism, enables the modeling of inputs and outputs of a process with data input and data output constructs. The Eriksson–Penker UML extension for business process modeling (Eriksson and Penker, 2000), in turn, models a process with input and output objects. In this context, the introduced GA concept can be considered as a general teleological component which is common for both processes and functions.
In the UML profile presented herein the input–output perspective of goal achievements is modeled with its two attributes: input and output. Since this aspect of GAs originates from their understanding as transitions, these attributes are defined more generically for transitions as follows, whereby they apply directly to GAs, as well.
(Input).
An input y of a transition x is a situation that
x starts from.
(Output).
The output y of a transition x is a situation in
which x results.
For example, the goal achievement
We note that inputs and outputs of GAs are in general not assumed to be maximal, but they can be partial situations, in the sense that there may be even more comprehensive situations that a GA transitions from or to and that embed the “smaller” situations, possibly identified as input or output. This appears useful for modeling, e.g. in order to focus on relevant aspects only. As a consequence, a GA may be linked to multiple inputs and/or outputs. Regarding outputs, this further allows for distinguishing some of them as intended, namely goals. Yet also unwanted effects play a role in modeling functions. Next we turn to both of these elements of function representation in more detail.
Goals and side effects
The notion of output in the context of function analysis is intimately tied to the notion of goal. Indeed, the term ‘goal’ occurs commonly in function modeling frameworks, however, its meaning is diverse. In Functional Representation (Chandrasekaran, 1994), for example, the goal of a function is considered to be a causal process of function realization, whereas McDowell et al. (1996) understand a goal as a goal state, which is the result of a realization. In FueL both of these intuitions behind ‘goal’ are reflected. Goals comprehended as realizing processes are represented by the notion of goal achievement. Goals understood as resulting states are based on the notion of output. But before strengthening the link between goals and outputs, we turn to the observation of side effects.
According to Britton et al. (2000), one of
the limitations of (pure) input–output approaches is their focus on useful outcomes
only, thereby ignoring negative side effects. A side effect is basically an output, as
well, in the sense that it indicates a class of situations that result from realizing
goal achievements. The remaining question is why some resulting outputs are considered
to be goals, whereas others are not. In some functional modeling frameworks outputs or
goals are identified with desired states of reality (e.g.
Chandrasekaran and Josephson, 1998). For
instance, in the context of the goal achievement
To some extent, interpreting outputs as goals or side effects based on a designer’s desire is problematic, especially for natural systems. However, the establishment of a goal, in our understanding, can be driven not only by a desire, but likewise by the belief in the utility of a given output or in the role that an output plays in the explanation of a given phenomenon. For example, the state in which blood is being pumped is useful for the human organism (in order to stay alive; as an autopoietic system) and as such it is acknowledged as a goal by some agent, like a physician or biologist.
A particular type of a goal’s utility is its epistemic usefulness. A state of the world may be crucial for some theory acknowledged by an agent as it may provide an explanation of some phenomenon and, therefore, it may be recognized as the goal of some function. For instance, the fact that hemoglobin transports oxygen from the lungs to other parts of the body may be considered as an answer to the question “Why does blood contain hemoglobin?”, relevant in the context of some biological theory. This kind of explanation, called functional, is common in biology.
In the light of those considerations, we distinguish between two types of outputs in
FueL: goals and side effects. Formally, this
distinction in FueL traces back to the primitive predicate
(Goal of GA).
The output y of a goal achievement x is a
goal of x if it is (considered to be) of utility,
i.e., if y is a goal.
(Side effect of GA).
Any output y of a goal achievement x that is
(considered to be) a side effect of x is (considered
to be) of no utility.
It should be mentioned that the usefulness of an output does not only depend on the
context, but likewise on the agent who recognizes that utility. The very same output may
be considered useful by one person but may lack utility for another. However, it is
worth noting that the rationale behind the establishment of the
Burek (2006) discusses the question of why certain situations are considered to be goals. We think that a goal is an intentional entity, i.e. for some reasons an agent distinguishes some (imagined) part of reality to be a goal. The inclusion of an agent into the structure of a goal (and, consequently, of a function) leads to accepting both, goals and functions, as subjective entities.
Function specification can transcend the specification of mere input–output pairs. In particular, a function can be characterized by constraints on the method of function realization. For instance, for Chandrasekaran (1994) one component of function specification is a causal process, which is a particular way of function realization. In the ontology of Kitamura et al. (2002), the way-of-function-achievement represents the abstraction of key information about how to implement a function, such as physical laws and intended phenomena. A mode of realization, often called the implementation, is a common component of modeling formalisms also present in UML. For instance, as discussed in Section 3, UML use cases are specified by behaviors implementing them.
Following these views we think that often it is insufficient to describe a function
only in terms of its input and output. For example, the molecular functions
In order to enable a clear separation of the goal from the way of realization we introduce the mode of realization as an additional and optional component of GAs.
(Mode of realization).
The mode y of a goal achievement x, denoted by
For the function
The mode is a constraint on the function realization which does not affect the input or the output. For instance, if one adds to the function of transmembrane transport the constraint that the transport should be realized by a uniporter protein, then the input and the output remain unchanged. However, the function will change and not every transportation process can realize the new one but only those processes driven by a uniporter protein.
We provide only a very weak formal specification of mode above. It is difficult to
determine an appropriate kind of categories that could be used instead of
Participants perspective
A function together with its GA cannot only be depicted in teleological terms. Another perspective on function representation does not focus on the goal of the function, but on the entities involved in the realization of the function. In device modeling a common component of function specification is the device realizing the function (Chandrasekaran, 1994), also called a function carrier (Wirth and O’Rorke, 1993). Moreover, in structured methods of software engineering the common part of function specification is not only the entity realizing the function, i.e. the system or its component, but also the objects on which the function operates.
In FueL, the entities occurring in a goal achievement13
Inputs, outputs, modes and participants are all directly related to goal achievements and only indirectly to functions. However, for the sake of simplification of the language we refer to those notions directly in combination with functions, as well. Accordingly, whenever we refer to inputs, outputs, modes and participants of a function, that should be understood as a shortcut for inputs, outputs, modes and participants of the goal achievement related to the function.
The latter relationship yields the most commonly used participant type in the Molecular
Functions Ontology (MFO), namely operand. An operand is affected by the GA it
participates in, for example, resulting in changes of its shape or state. In FueL the
notion is defined as follows, employing
An entity y that undergoes effects of a goal achievement
x is an operand of x.
The notion of operand in FueL is inspired by the concept of ‘objective entity’ in
(Shimomura et al., 1998; Takeda et al., 1996). An objective entity is an entity that a
function “occurs on or to”. Typically, in a noun–verb phrase depicting a function it is
represented by a noun, e.g.
We have constructed the notion of operand based on the primitive predicate
Besides ‘operand’, two further types of participants in goal achievements are declared
above for FueL. Next we focus on the notion of doer, which basically
captures those participants of a function that are responsible for or cause GA
execution.
(Doer).
A doer y of a goal achievement x is an entity that
executes x.
Although, as discussed at the beginning of the present section, a doer is a common
component of function modeling frameworks in mechanical engineering, in MFO it is not as
typical to specify a goal achievement with a doer as with an operand. For example, in
the
In addition to doers, entities can contribute to goal achievements in other ways. In FueL we call such entities contributors, which are defined as follows.
(Contributor).
A contributor y of a goal achievement x is an
entity that contributes to x without itself executing
x.
Besides the general characterization, we identify two more specific patterns of contribution. Firstly, there are instruments, which contribute to the goal achievements in which they are used. Thereby it is assumed that instruments are used by a doer of the GA under consideration.
(Instrument).
An instrument y of a goal achievement x is an
entity which is used by doers in the execution of x. Thereby
y is a contributor of x.
A doer can use an instrument to achieve a goal. In this sense resources such as tools are contributors. For instance, a hammer is a contributor for the GA of hammering nails.
Beside instruments, contributors can be understood in terms of sub-components. For
example, in (Mizoguchi et al., 2012) the
behavior of sub-components participating in the realization of a function of a certain
system s is seen to be contributing to the function of
s. In FueL, a corresponding conception of contribution can be defined
by utilizing the sequence-part relationship
Function ascription
As is demonstrated above, the concept of goal achievement is a complex one, which can be analyzed both in teleological terms of input and output, as well as in terms of participants involved in it. A function is a role, according to our understanding, or more precisely, a role category in the context of some goal achievement category. Based on the very same GA category one may determine multiple roles and therefore several functions may share the same goal achievement.
It remains open to present a selection of role types that can be used for the purpose of function specification. As presented in Section 4.1.1, there are numerous approaches dealing with functions and their authors have described a variety of role types that can be used for specifying functions. In the current paper we adopt a modest approach, based on the classification of GA participants presented above. Accordingly, we introduce only two function types, namely doer functions and contributor functions.
(Doer function).
A function x is a doer function if x
is a role played by entities executing the goal achievement y of
x, i.e., the x role of y is played
by a doer z of y.
(Contributor function).
A function x is a contributor function if
x is a role played by entities contributing to the goal achievement
y of x, i.e. the x role of
y has a contributor z of y.
For instance, with respect to the biological process
See
The above classification surely cannot be considered as being finished, yet it seems that
it can serve as a good foundation for the further classification of functions.
Additionally, using the above two function types, we introduce the ascription of a
function to an entity by means of the has-function relationship. The
basic idea of function ascription in FueL is that doers or contributors can be said to
have the function that they are a doer of or that they contribute to, in view of
understanding these kinds of GA participants to relate causally to function realization.
For example, as just stated we may say that putative glucose uptake protein has the
function
First, we capture two corresponding specific notions of function ascription for doers and
contributors, respectively. On this basis the section culminates in defining a generic
For any entity x that has a function y of doing a goal achievement z, y must be a function with the goal achievement z and x must be a doer of z (in virtue of playing the role y).15
We note
that it remains future work to capture the connection of x being a
doer of z in virtue of the role y in greater
detail, which is the main reason of characterizing the ternary
Note the connection with
The entity x has a function y if it plays that role y
and there is a goal achievement z such that x has a
function of doing or contributing to z in virtue of y.
In the light of the previous observation on deriving
As a final remark, the reduction of the notion of a function to a role of an entity involved in some GA enables the modeling of function ascriptions even in situations where no explicit model of functions is available. Hoehndorf et al. (2010) observe that in the Gene Ontology various molecular functions needlessly duplicate biological processes. As they point out, many functions need not be named explicitly in GO because the processes realizing them are already present.
Types of functions
After introducing the notions of input and output in the previous sections, we briefly outline a classification of functions based on the relation between inputs and outputs regarding time. This issue is of relevance since, firstly, it permits to separate the notion of function from the notions of behavior and process, and secondly, it enables the identification of three kinds of function realization.
Concerning the first point, we find that functions are commonly related to processes. Either functions are treated as particular types of processes, or processes are considered as the only type of entities that are realizing functions. The former approach is taken in (Barker and Longman, 1992), for example, where functions are considered as a kind of mechanism-free processes. The latter view can be observed, e.g., in the Gene Ontology, where only biological processes are realizations of molecular functions.
Treating functions as processes would require all functions to be time-extended, because
all processes are time-extended entities. This meets the intuitions behind functions such
as
The distinction and availability of the notions of time point and time interval, possibly employing different labels for them, such as instant and period, is common in numerous time ontologies besides GFO; e.g., cf. some theories discussed by Hayes (1996) and Vila (2005). The assumed granularity and precision of the time model determines what is considered as a point and what is considered as a time interval. Hence, these notions are relative to an assumed time scale. The problem of granularity is out of the scope of the current paper, and, in fact, it does not influence the presented results. We presuppose that the time scale is fixed and is taken as primitive in a given modeling context.

Three combinations of temporal locations of function input and output situations lead to the types of functions discussed in Section 4.3. Points depict situations that are not extended in time but located on a single time point; lines depict situations extended in time. The following cases are distinguished: (i) both input and output are not temporally extended and input takes place before output; (ii) both input and output are not time-extended, but they are located at the same time point; (iii) both input and output are temporally extended situations that co-occur, i.e. they have the same temporal extension.
In the first two cases in Fig. 6, both input and output
states are presentic situations. In case (i) the input state is temporally located before
the output state. In the function
The function x is called a sequential function iff the inputs and the outputs of x are presentic situations and all of the former are present before all of the latter according to the time ordering.
In the second case presented in Fig. 6, input and output are
also presentic situations, but they are not sequentially ordered in time, but instead they
are present at the same time point. As this case might seem odd at first glance, we
demonstrate that it is well justified. Consider the function F:
(Instantaneous function).
The function x is called an instantaneous function iff the inputs and the outputs of x are presentic situations that are located at coincident time points.
The inputs and outputs of an instantaneous function can be replaced by time extended entities, which leads us to case (iii) in Fig. 6, i.e., to the notion of continuous functions.
(Continuous function).
The function x is called a continuous function iff the inputs and the outputs of x are situations extended over the same time interval, thus sharing their initial and final time points.
To illustrate this kind of functions, the
The above analysis reveals the rationale for considering goal achievements in more general terms than identifying them with processes only. Instantaneous and continuous functions, although often neglected, are common for domains dealing with structures, for example, engineering and building construction.
Relations between functions
Functions are rarely modeled in isolation, instead they are usually embedded into complex networks of interrelations. A relation of particular importance in functional modeling is function decomposition. The main idea behind function decomposition is to analyze a system that is characterized by a root function in terms of more specific functions. In FueL, the notion of function decomposition generalizes several relations, including function subsumption and certain part-of relations among functions, which are discussed subsequently. Beforehand, we introduce function decomposition more generally, linking further to associated and equally labeled methods.
Function decomposition
Function decomposition is a popular technique used for the modeling of complex systems, which comprise high numbers of functions. In software and systems engineering it is present not only in structured methods, where functions serve as the main elements of abstraction, but also in other paradigms, e.g. in the Object Process Methodology (OPM) (Dori, 2002) or in Axiomatic Design (Suh, 2001). In the area of information and enterprise architecture, modeling function decomposition plays a significant role in TOGAF (The Open Group, 2011), for example. In mechanical engineering taxonomic links between functions are employed in numerous approaches, cf., among others, links of function-is-a and method-of-function-achievement (Kitamura et al., 2002), functional decomposition (Pahl et al., 2007), degree of complexity (Hubka and Eder, 1988) or the part-whole relation in Multilevel Flow Modeling (Lind, 1994; 2011).

FueL stereotypes enabling the modeling of interdependencies between functions, and of function decomposition in particular.
Figure 7 shows the FueL constructs designed for handling interdependencies between functions, and function decomposition in particular. These constructs are the result of an earlier ontological analysis (Burek et al., 2009), which can be summarized by the statement that behind functional decomposition actually several distinct relations are hidden implicitly. We illustrate this claim with an example of the Business Goal Decomposition Pattern (Eriksson and Penker, 2000).17
Eriksson and Penker do not speak about function
decomposition, but about the goal decomposition. However, we think that this is
merely a terminological difference. A closer look at their examples of goals like
The goal for FueL is to support, within a single framework, the modeling of the rich family of function decomposition types, which is currently scattered across numerous approaches. Hence we introduce the relation of function decomposition as a common umbrella relation for various ways of decomposing functions. This does not only enable the modeling of function decomposition by means of a single relation if there is no need for more precise models (as in the example reported above). Moreover, it allows for the refinement of links already introduced in a model in later steps.
As an umbrella relation, function decomposition is a relation between two functions,
denoted by
The function x decomposes the function y iff
(1) x is subsumed by y, (2) x is
a part of a function sequence realizing y, or (3) the operand of
x is a part of the operand of y. In all cases we
say that the subfunction x is a decomposition of the
superfunction y.
Function subsumption
We introduce the notion of function subsumption based on a generic understanding of the
is-a relation, which we denote by
The semantics of the is-a relation is, however, not clear-cut.18
For a much more detailed discussion on that topic see (Brachman, 1983).
We note that the characterizations of generalization also refer to instances and thereby have an extensional aspect, as well (cf. e.g. OMG, 2011a, Section 9.2.2, p. 51; Rumbaugh et al., 2005, p. 370ff).
Taking a subsumption relation as a primitive, using the terms ‘generic is-a relation’ or ‘generic subsumption’, we specify function subsumption in the following way.
The function x is subsumed by the function
y iff x is generically subsumed by
y, the goal achievement of x is subsumed by the
goal achievement of y and both x and
y are of the same kind with respect to executing or contributing to
their goal achievements.
In FueL the notion of function subsumption is founded on the subsumption of goal achievements. Accordingly, GAs can be utilized in order to detect patterns of function subsumption. Much of Section 4.1 above elaborates a structural analysis of GAs, including in particular their operands as well as modes of realization. On this basis the next two subsections introduce three specializations of function subsumption, namely operand specialization, mode addition and mode specialization.
Operand specialization
Functions are often specified with the help of operands occurring in their realizations. Therefore it is very common to construct subsumption hierarchies of functions in accordance with the taxonomic structure among their operands. This leads us to the relation of operand specialization, corresponding to the first pattern for function subsumption.
(Operand specialization).
The function x is subsumed by the function
y by operand specialization if x is subsumed by
y and an operand of x is subsumed by an operand of
y.
The pattern of operand specialization is applied frequently in the Molecular Functions
Ontology of Gene Ontology. For instance, consider the functions
Mode addition and specialization
Another pattern of function subsumption is not based on the operand, but on the mode of
realization. This pattern can be found, e.g., in work of Bracewell and Wallace (2001), where the link of function-means-context
provides for function decomposition driven by means of function realization. As an
example of the pattern let us consider two functions,
(Subsumption by mode addition).
The function x is subsumed by the function
y by mode addition if x is subsumed by
y and x has some mode, whereas y
has no mode assigned.
Furthermore, modes can serve as a principle of decomposition also in cases where a
parent function has already a mode assigned. Consider, for instance, the function
(Mode specialization).
The function x is subsumed by the function y by
mode specialization if x is subsumed by y and mode
r of x is a subclass of mode s of
y. Formally,
Since the mode of realization could be a complex structure, e.g. a complex process, it
is not trivial to determine if a mode is a subclass of another mode. In this connection
the notion of participant may be helpful, since it is often the case that the
specialization of a mode of a GA is related to the specialization of its participants.
That is the case in the decomposition of
Function decomposition and part-of relations
There are two contexts in which the interrelation between the notions of function, function decomposition and part-of relation are discussed in literature. One focuses on the interpretation of the part-of relation between objects or, more precisely, of doers and contributors, in terms of their functions. The second concerns representing the interconnection of functions in terms of the part-of relation.
The former approach is applied in several frameworks, e.g. in Axiomatic Design, Object Process Methodology or OntoUML. The general idea is that an entity can be decomposed into its parts based on the functions of those parts and their contribution to the overall function. In Axiomatic Design that pattern is present in zigzagging, which is a basic routine of decomposition. In zigzagging each design parameter is decomposed into its sub-parameters by dissecting the corresponding function requirement. Analogously, in OPM objects modeled in function hierarchies are decomposed into their parts by the analysis of their functions and their dependencies. The pattern of a function-oriented part-of relationship is further formalized by Vieu and Aurnague (2005) and is adopted in OntoUML. Vieu and Aurnague (2005) introduce functional parthood together with distinct flavors as a relation between a whole and its part, where there is some type of functional dependency between them. For direct functional parthood, for instance, for x is to be a part of y to function as an X, then y must function as a Y.
In the present paper we are not primarily interested in function-driven part-of relations, but instead we focus on the second interplay mentioned above, namely between the notion of functional dependency and part-of relationship. This addresses the question to what extent functional dependency, as a relation between functions, can be expressed in terms of the part-of relation. It is worth mentioning that some authors, for instance Vermaas (2010), question the adequacy of interpreting function decomposition purely in terms of a part-of relationship between functions. On the other hand, numerous authors interpret function decomposition in that way. For example, Kitamura et al. (2004) introduce the notion of decomposition of functions by means of the part-of relation: “the part-of relation between functions represents how a function is achieved by finer grained functions” (Kitamura et al., 2004, p. 116). Analogously, regarding the function hierarchy introduced in (Dori, 2002), lower level functions answer the question of how the superordinate function is achieved.
It can be observed that those how-questions can be already tackled by the mode-related
subsumption introduced in the previous section. For instance, the function
In order to introduce sequence-part formally, we utilize three additional notions: that
of a function sequence, denoted by
The notion of function support rests on the relationship of the inputs and outputs of two functions.
(Function support).
A function x supports a function y if the goal
achievement of x supports the goal achievement of y,
i.e., some inputs required for y are available as outputs of
x.
For example, one can say that the function
Returning to function sequences, those can realize functions, which is formalized by
means of
On this overall basis the relationship of sequence part can be characterized by a necessary condition.
(Sequence part).
A function x that is a sequence part of a function
y must be a member of a function sequence that realizes
y.
The specification of function decomposition based on function sequences realizing the
goal of the decomposed function is clearly present in the literature. For instance, in
the work of Stone and Wood (2000) function
decomposition is on chains of subfunctions that operate on the flow of the super
function. Vermaas and Garbacz (2009) interpret
such chains in terms of an ordering relation between functions, such that a functional
ordering
This section on function decomposition concludes with yet another dimension that can be
utilized for dissecting functions, namely by means of the part-of relation applied to
operands. This is especially useful in cases where an operand is a complex entity or
where it is a collection of entities that are difficult to be operated on at once.
Consider, for instance, the transportation of big building constructions like bridge
elements or wind turbines. Usually these objects are transported in parts, thus the root
function For a function x that is a
component of a function y by operand
decomposition, the goal achievement of x has an operand
part that is a part of an operand regarding y.
(Operand decomposition-based
decomposition).
Application to the Gene Ontology
In order to verify if the presented profile is helpful for developing complex function models we have used it for modeling sections of the Molecular Function Ontology (MFO) graphically. Thereby MFO provides us with non-trivial real-life examples, as it is a sub-ontology of the Gene Ontology (GO) (Ashburner et al., 2000; GOC, 2004; 2008), the largest and a broadly used resource for cataloguing gene functions. GO is manually curated with substantial effort, which led to its steady growth, from less than 5,000 terms in 2000 (GOC, 2004, Table 1) to more than 30,000 in 2010 (du Plessis et al., 2011). As the size of the ontology increased, it has been observed that its structure is no longer optimal (du Plessis et al., 2011). Corresponding improvements of the GO structure are not trivial, which is reflected by many refactoring initiatives (e.g. Guardia et al., 2012).

A segment of the is-a hierarchy of MFO. An enhanced model using FueL is shown in Fig. 9.

This FueL model results from the MFO segment shown in Fig. 8. Design choices are explicitly visible at the subsumption links by
annotations with FueL stereotypes. Regarding the connection between
In the present section we demonstrate how the application of FueL can support function modeling in GO and how it opens some refactoring options for MFO. Note that this FueL application is presented in a condensed form in a conference paper (Burek et al., 2015), where the actual analysis is sketched in less than a single page. At the time of writing, another more detailed exposition in a submission to a biomedical journal remains under review.20
That pending submission covers basically the same case of analysis, but adopts a more application-oriented perspective and terminology. More importantly, it provides additional theoretical background not covered herein. Function subsumption patterns are proposed for broadening application, which are based on FueL and inspired by intensional subsumption, e.g. in the sense of Woods (1991) (cf. also Section 4.4.2 above).
Functions in MFO are specified by an id, a list of synonyms, a natural language definition
and possibly a comment, a list of is-a links relating a function with its subsumption
parents, and part-of links connecting it to processes from the Biological Process Ontology
in GO. The structure of functions in MFO is specified mainly in terms of the natural
language expressions, i.e. by the definition and comment. Therefore, the first objective is
to adapt MFO functions according to the function structure introduced by FueL. When modeling
selected MFO functions with FueL, we observe that the FueL function structure based on goal
achievements does not only provide a blueprint for representing the body of molecular
functions in an organized way, but moreover, it adequately represents the interplay between
biological processes and molecular functions, which is depicted in GO by means of the
part-of relation. The part-of relation between biological processes and molecular functions
maps to the
The explicit documentation of the design choices and of subsumption patterns occurring in
MFO is the second objective and of major importance of applying FueL to MFO. Figure 8 displays a plain fragment of the is-a hierarchy of MFO (in UML
notation). Figure 9 is derived from that MFO segment and
demonstrates how the modeling of MFO with FueL allows for documenting subsumption patterns
explicitly in the model, by means of FueL stereotypes. This enables a visualization of the
structure of MFO, including the underlying design choices, which is easily accessible and
increases the intelligibility of the ontology for its users. This is particularly beneficial
for the frequent situations where more than one subsumption relation underlies is-a links,
like in the case of the functions
Additionally, the application of FueL can lead to refactoring and revision for MFO. For
instance, modeling the functions
Therefore, a first refactoring option, covered in Fig. 9, is
to explicitly document the subsumption between

Siblings of

Comparison of siblings
A second refactoring option of the analyzed MFO segment can be discovered by comparing the
operands of two sibling functions:
Finally, a third possible refactoring option which we have considered is depicted in
Fig. 12. It is based on the assumption that the distinction
between the two operands (‘substance’ for

Third refactoring approach, merging
The three refactoring options that we have presented can be devised on the conceptual basis of FueL, as laid out in Section 4. Of course, it remains the task of domain experts to decide about the most appropriate analysis. One advantage of the FueL framework is to allow for a more structured approach in revising or developing ontologies that cover functions.
Before concluding this section, yet another application of FueL shall be mentioned that is
beneficial if processes but not (yet) functions are available in an ontology. A sample case
regarding GO is annotating cellular components with functions that lack a proper or any
representation in MFO. Indeed, it has already been observed that the Molecular Function
Ontology and the Biological Process Ontology are not fully compatible, e.g. in the sense
that there are many biological processes for which MFO does not comprise corresponding
molecular functions (Hoehndorf et al., 2010).
Therefore, it is not obvious how to annotate genes and gene products that participate in
biological processes and have functions in their context. The relations
After the presentation of the developed UML profile and its applications to MFO, in this
section we reconsider our work from two angles. The final Section 6.6 is devoted to a response to remarks on the present article in the introduction
to this special issue (Artiga, 2016). This
comprises a discussion of the relationship between FueL as a language and its underlying
theory of functions. All previous subsections compare FueL elements with the UML candidates
for function modeling that are discussed in Section 3. The
comparison is based on the requirements for functional modeling as listed in Section 2. Figure 13 presents a FueL model of
the exemplary function
Prior to the comparison we devote a few comments to the relationship between FueL, as a UML profile, and UML. The first observation in these regards is that functions in FueL are neither reduced to structure nor to behavior in UML. This is the reason why the FueL stereotypes are mounted very high in the meta-class model of UML. This suggests furthermore that FueL is only weakly related to UML, and one may even question the need for anchoring FueL constructs in UML. However, FueL is not designed as a standalone language, but is constructed upon UML instead, not at least in order to benefit from the rich tool-set available for UML. The latter includes numerous modeling tools and the possibility of integrating functional models with other types of UML and UML-based models.

A simple FueL model of two functions of depositing money. The model utilizes the
compact notation of the FueL, in which a function structure is modeled with a single
stereotyped classifier. The function
First we compare use cases and FueL functions with respect to the input–output perspective. FueL functions, analogously to use cases, are defined in terms of pre- and post-conditions, called input and output in FueL. However, in contrast to pre- and post-conditions of use cases, which are actually no elements of the UML meta-model, input and output in FueL are ontologically analyzed and formally characterized by referring to the notion of situation, particularly inspired by GFO. The lack of a formal treatment of pre- and post-conditions in UML use cases may cause erroneous functional models. In particular, intended and unintended post-conditions cannot be distinguished from one another.
As discussed in Section 3.2, besides use cases, good UML
candidates for modeling functions can be found in interfaces and operations. For instance,
a function could be understood as an interface, providing a label with one operation,
defining its pre- and post-conditions. In contrast to the use case, this solution provides
a good treatment of pre- and post-conditions. In addition, side effects can be handled by
exceptions assigned to operations. The pre- and post-conditions of operations in UML are
modeled as constraints. In contrast, in FueL they are modeled as situations. The latter
approach allows for modeling dependencies between them. By means of that, dependencies
between functions, in which those situations are involved, can be introduced. One
exemplary relation along these lines is introduced in Section 4.4.5, where the overlap between the output of a function F and
the input of a function
Collaborations, the remaining UML candidate for functions that we discuss in Section 3, completely neglect the input–output perspective.
Participants perspective
Despite similarities between UML use cases and functions in FueL with respect to the participant view, it turns out that they cannot be identified. In order to illustrate this, let us have a closer look on how participation is handled by use cases. For UML use cases, two types of participation are introduced: a subject, i.e. an element performing a use case in collaboration with one or more actors (OMG, 2011b), and an actor, which is “a type of role played by an entity that interacts with the subject (e.g., by exchanging signals and data), but that is external to the subject (i.e., in the sense that an instance of an actor is not a part of the instance of its corresponding subject)” (OMG, 2011b, p. 598). Further, it is stated that “the subject of a use case could be a system or any other element that may have behavior, such as a component, subsystem, or class” (OMG, 2011b, p. 606). Consequently, it can be observed that subject and actor are distinctly represented. The former refers to an arbitrary classifier, whereas the latter is understood as a behavioral classifier and is founded on the informal notion of role. We discuss next which consequences this architecture has on representing functions with use cases.
Firstly, the distinction between a subject and a use case role is problematic, because it
appears impossible to decide what a subject is and what an actor is, when analyzing only
functionality. Instead, this distinction is made with respect to a given system. For
instance, if one models an
Secondly, the general treatment of a subject leaves the modeler with freedom of choice of
what a subject is, but on the other hand, there is no guidance in constructing
realization-independent functional models. It even seems that a realization-biased
approach to modeling a subject is implicitly assumed. In this approach a subject is not a
general role, but a particular entity type. For instance, in the example given in the UML
specification (OMG, 2011b, p. 608) the subject
of the use cases
One may argue that the shortcoming discussed above can easily be overcome by excluding a subject from a use case specification. Admittedly, this is consistent with the UML meta-model. In this approach the participant view would be accounted for by actor roles only. Unfortunately, the actor role concept is not clear-cut (see e.g. Irwin and Turk, 2005), and a user who attempts to utilize it for functional modeling may face the following problems.
Firstly, the actor represents the role of an external entity in the interaction with a
subject, not with a single use case. Since the subject is optionally assigned to the use
case, it is further impossible to assign actors to use cases having no subject.
Additionally, the role concept itself, on which the notion of actor is founded, is not a
part of the UML meta-model, which makes the concept of an actor vague. For instance, it is
not clear how the role of an entity in the context of a subject differs from the roles
that an entity has in the context of the use cases provided by that subject. Consider a
person that plays a customer role in the context of a banking system, whereas in the
context of the use case
The above shortcomings of UML use case actors are addressed by collaboration roles in
UML, which abstract away from all aspects of their players that are not relevant for a
collaboration. Thus, in the case of a collaboration
Eventually, the weakest support of the participant perspective is associated with interfaces and operations. The latter refer to participants at most indirectly, e.g. by means of parameters. The former do not provide any constructs that are tailored especially for that purpose. Instead, they offer only general associations between classifiers.
Separation of function from realization
The analysis of UML notions related to use cases, namely subject and actor, presented in the previous section demonstrate that use case diagrams prevent modeling function participants independently of a realization and, contrariwise, they impose a particular realization of use cases. FueL solves these problems by explicitly distinguishing two components of function structure, namely goal achievement and mode of realization. This enables a clear separation of the what-question from the how-question regarding functions. On the other hand, in FueL both, goal achievement and mode, can be combined into a single function specification. Accordingly, the modeling of realization-free functions as well as of realization-biased functions is supported. In contrast to use cases, the remaining UML constructs that we discuss do not suffer from such a realization-bias. They provide means for the specification of functionality, independently of realizing classifiers.
Separation of function from behavior
Another drawback of the available UML candidates for functional modeling is the fact that they interrelate the notion of function very closely with the notion of behavior:
Use cases are behavioral classifiers, such that “[e]ach use case specifies some behavior, possibly including variants, that the subject can perform in collaboration with one or more actors.” (OMG, 2011b, p. 606).
Collaborations are behavioral classifiers, their “[…] primary purpose is to explain how a system works […]” (OMG, 2011b, p. 174) and “[c]ollaborations are generally used to explain how a collection of cooperating instances achieve a joint task or set of tasks.” (OMG, 2011b, p. 175).
Operations are behavioral features and as such they specify that an instance of a classifier will respond to a designated request by invoking a behavior (OMG, 2011b, p. 104ff).
From the above it follows that if any of the mentioned constructs is considered for representing functions, then they are restricted to behavioral functions only, i.e. to functions realized by some behavior. FueL differs from that in that it considers functions to be independent of behaviors in the first place. While FueL does accommodate functions realized by behaviors, it additionally enables the modeling of functions that are not related to behavior, e.g. remembering passive and instantaneous functions in Section 4.3. Therefore, we argue that the notion of function in FueL is broader than the notions of function based on any of the UML constructs discussed above.
Function decomposition
Use cases, interfaces and collaborations can be organized into hierarchical structures by means of generalization, which resembles function decomposition. However, generalization in UML is a general-purpose relationship, which does neither provide any insight into the specificity of function decomposition, nor does it support the separation of different types of function decomposition. On the one hand, UML leaves the modeler without dedicated relations for dealing with function decomposition precisely. On the other hand, UML does not provide a single function decomposition relation for models in which detailed specializations of decomposition types need not be provided. Instead, using UML requires a choice by modelers from several available relations, such as generalization or composition. In contrast, FueL offers a single generic notion of function decomposition, which can be specialized in those models which require such precision.
The real difficulty of function modeling does not lie in modeling single, isolated functions, but much more in the modeling of function networks. We believe that the FueL toolkit of modeling relations for connecting functions is its main asset. Moreover, Section 5 demonstrates that the identification of several patterns of functional decomposition cannot only be helpful for constructing new functional models, but that such patterns can also be used for refactoring existing models.
Function language and theory – Response to the Editorial
We conclude this discussion section by reconsidering our work and the status of FueL in the light of the introductory article (Artiga, 2016) to this special issue, where Marc Artiga reconsiders desiderata for theories of functions, on the basis of which the proposals in the issue are evaluated. Before getting into some detail, our first point to be made might be understood as a kind of disclaimer for the discussion of the details. That point is to stress that the main objective of the present work is to present a language – FueL, in the form of a UML profile – which is intended to serve function modeling. In its development, aspects of existing approaches of functions have been surveyed and adopted, whereas the formation of a novel theory of functions was no explicit target. Insofar and on the one hand, there is a certain tendency to be only weakly restrictive regarding the theory of functions that one may consider “behind” the language. The purpose of that approach is to find a rather small set of commitments that suffices for modeling functions adequately and efficiently in practice and which is suited to promote broad acceptance and applicability. On the other hand, there are certain presuppositions with respect to FueL and its elements, which are presented above, especially in Section 4. As also observed by Artiga (2016), the profile has indeed been formulated against the background of a longer period of analyzing the notion of function. Hence, while keeping both perspectives in mind, we shall now adopt more of a theory-of-functions attitude and enter the actual discussion of the comments by Marc Artiga.
First, we agree on the classification of our approach as a systemic account of functions, similarly to that of Mizoguchi et al. in this issue and earlier (2012). The characterization of our work as adopting a revisionary, overarching or defiant strategy seems to remain open, however. In view of the above comments on aiming at a rather weakly constraining account, we are at least interested in adopting an overarching strategy, trying to find “an umbrella concept” that can encompass a number of existing proposals. Note in this regard that the basic notions (such as role, situation and transition) that are employed in the specifications of function, goal achievement, etc. are deliberately captured only generically, with few formal constraints, cf., e.g., the remarks on situation in Section 4.1.2. Of course, this does not prevent using FueL while assuming compatible, more elaborate theories on such basic notions.
Turning to the assessment based on the five desiderata called Normativity, Accidental, Teleology, Epiphenomenalism, and Novelty listed by Artiga, we find primarily three points that are raised and discussed (Artiga, 2016) with regard to the present submission:
the nature of goals (which means observer-dependence in our case),
the distinction between essential and accidental effects, and
teleology.
Surely, concerning Point (1) we admit that observer-dependence results in our approach, which could potentially lead to an inflation of functions. We argue, however, that it is an attractive feature of FueL that it remains a decision of its users to determine functions that are justified for them. Thereby the framework provides a certain guidance towards analyzing functions in terms of goal achievements, inputs, outputs, etc. Moreover, especially in the community-based development of ontologies covering functions (cf. the case of the Gene Ontology, for example), we expect that the danger of a proliferation of functions remains limited, at least for observant communities.
Point (2) of distinguishing essential from accidental effects is clearly discussed in the literature on function theories, see Wouters’ work (2005, Section 3.1) for several sources. One may also agree with many examples illustrating this requirement, which appear intuitive and plausible. At a general level, however, in our opinion the recourse to ‘essence’ in the criterion Accidental is not without problems, because the notion of essence in itself is subject to much debate. Depending on the question of which notion/form of essence or essentialism one subscribes to, functions that are determined by user-defined goals may be more or less in conflict with Accidental. For example, if a view close to psychological essentialism and an explanation-based account of essence is adopted (cf. Burek, 2005, Section 3), an approach with observer-dependent goals may satisfy Accidental. More roughly speaking, if essence and accidentality are understood to be observer-dependent themselves, Accidental can be fulfilled for an observer by a systemic account of functions.
Teleology (3) is another disputed criterion, as Artiga points out. Note first that the intended sense of ‘teleological’ in the text above, e.g., in the specification of goal achievement in Section 4.1.2, is of a weaker kind, which is not related to explaining the existence of an entity on the basis of functions. Indeed, while an important explanatory role of functions should be acknowledged in many contexts, we maintain a skeptical position against function-based explanations of the existence of entities as well as against adopting this as a necessity for functions in general. Note that we see no conflict between this position and modern biological theories of evolution, where one may clearly refer to functions (say, of body parts) in connection with natural selection, for instance. In any case, in favor of the broad applicability of FueL, satisfying Teleology does not seem beneficial, as the discussion of the criterion by Artiga (2016) shows, for example, for naturefacts and use functions.
One may further ask how the claim of Teleology should actually be understood, namely whether at the level of individual entities or of categories of entities (tokens or types, in Artiga’s terminology)? It is mentioned as a noteworthy point here that we find the distinction between individuals and categories rarely addressed in connection with functions themselves and entities having those functions, for example. The specifications in Section 4 as well as the discussion of Epiphenomenalism (Artiga, 2016) show that rather different readings may result from a natural language phrase, if the entity terms occurring in that phrase are interpreted with explicit assumptions about which of the named entities are individuals and which are categories.
Another comment of Artiga concerns the further elaboration of certain notions of FueL, e.g., of doer and contributor in Section 4.1.6. On the one hand, we agree that further elaboration of primitives such as ‘executing a function’ is desirable and promising from a theoretical perspective, and this will be pursued in future work. On the other hand, for extensions at the theoretical side it remains a different question which consequences this will have for the language constructs of FueL and for those presuppositions that must be made or adhered to when using FueL. At this point, we have basically returned to the introductory disclaimer of this section. As a reminder, we highlight again that FueL and this article are intended to provide and introduce a function modeling language that is fit for its purpose and for wide-spread use and which is compatible with different (more elaborate) theories of function.
Conclusions
The present paper starts with analyzing the means for function modeling provided by the Unified Modeling Language (UML). Function modeling is a key aspect for artifact design, software engineering and business modeling, and, moreover, it is crucial for natural systems modeling. UML has been examined regarding its capabilities of modeling functions. We argue and demonstrate that UML lacks the expressive power to capture all significant function modeling distinctions. In addition, it is shown that UML does not provide a single construct for representing functions. Instead, functional aspects are scattered across several distinct UML elements, including use cases, collaborations and interfaces with operations. While operations focus primarily on an input–output understanding of functions, collaborations concentrate on a participant view, and use cases, in turn, cover only functions of a particular type, namely, transactions between a system and external actors. Consequently, modelers who intend to adopt UML for function modeling are left alone with the problem of selecting adequately from the mentioned elements.
Additionally, in UML the notions of function, behavior and realization are closely coupled. This is unproblematic for the purpose of object-oriented software engineering, for which UML was initially designed. However, the same approach can cause problems when UML is used as a general-purpose modeling language, which is applied also to device and artifact design or to modeling natural systems. The observation that UML provides only very limited means for handling function decomposition and that it does not account for distinguishing its various flavors adds to the problems of using UML “as is” for functional modeling.
For these reasons we propose a UML profile for function modeling, which is founded on results from the areas of mechanical engineering, software and systems modeling as well as ontological modeling. In this connection the present paper focuses on three problem areas: modeling (1) the structure of functions, (2) function ascription and (3) function decomposition. Each of these is approached conceptually on the basis of the literature on functions. The resulting specifications are augmented with formal characterizations of the notions involved. The developed account of function covers all aspects of functions present in the discussed UML constructs, such as the input–output view on functions or the perspective of function participants. The approach to functions adopted herein starts from an understanding of functions as roles in the context of goal achievements. The latter are perceived abstractly as specific transitions, and the analysis of goal achievements leads to several further key elements, including inputs and outputs, goals and side effects, modes of realization and different kinds of participants. Moreover, FueL provides means for modeling function ascription as well as function decomposition and specialization. Types of functions are identified on the basis of relating their realizations to time. Among these, as a rarely supported case, passive functions are included, characterized by instantaneous realizations.
The developed profile, together with its underlying conceptual framework, is domain independent and its applications exceed the fields of software engineering and business modeling, for which UML was originally designed. Beyond those fields the paper demonstrates that FueL can be used for modeling functions of natural systems. We employ the profile for modeling parts of the Molecular Function Ontology (MFO) within the Gene Ontology (GO). This application reveals some alternative refactoring options, including the elimination of non-function classes from the function hierarchy as well as the explicit representation of adopted function decomposition patterns.
Altogether, the presented results of applying FueL to GO appear promising. Therefore, in a next step we plan to translate larger parts of MFO into a FueL representation in order to then use available standard UML tools to investigate its structure. Hopefully, this will result in more precise specifications of molecular functions for GO and, moreover, we expect that it leads to further possibilities for refactoring, which may be abstracted into and provided in the form of generic refactoring patterns.
Footnotes
Acknowledgements
We are grateful to the reviewers for their valuable comments as well as to the journal editors Nicola Guarino and Mark Musen for their patience and for including the article in this special issue.
