joss: paper length reduced (~1000 words)

paper.md

@@ -37,10 +37,10 @@ With regard to BiGGer, bigraphs are specified using a meta-modeling approach [@g
 Grounding bigraphs on metamodels facilitate its construction via a universal and platform-agnostic language.
 
 Ultimately, this library transforms EMOF-complaint bigraphs into multigraphs that GrGen.NET can visualize and execute.
-Furthermore, BiGGer is also shipped as a command-line tool for using the functionality also via the terminal for experimentation.
-The most challenging aspect was the accurate translation of bigraphical rules to SPO-based rules, given that bigraphs and GrGen.NET employ distinct approaches regarding graph rewriting (refer to Section "Background").[^3]
+Furthermore, BiGGer is also shipped as a command-line tool for using the functionality via the terminal for experimentation.
+The most challenging aspect was the accurate translation of bigraphical rules to SPO-based rules, given that bigraphs and GrGen.NET employ distinct approaches regarding graph rewriting.[^3]
 
-[^3]: For a comprehensive analysis of the interrelated aspects of these approaches, readers can refer to the works of [@milner_EmbeddingsContextsLink_2005] and [@ehrig_BigraphsMeetDouble_2004].
+[^3]: For an analysis of the interrelated aspects of these approaches, refer to [@milner_EmbeddingsContextsLink_2005; @ehrig_BigraphsMeetDouble_2004].
 
 
 # Statement of Need
@@ -57,21 +57,24 @@ Until now, it is unknown whether the test for graph isomorphism can be solved in
 Subgraph isomorphism is computationally more complex than graph isomorphism and is known to be NP-complete due to the combinatorial nature of finding subpatterns in graphs.
 Thus, graph rewriting is NP-complete [@bacci_FindingForestTree_2014].
 
-However, bigraphs require the matching and rewriting of two substructures; refer to Section "Background".
+However, bigraphs require the matching and rewriting of two substructures.
 Specifically, one substructure of a bigraph is a *forest*, which is relevant to the problem of locating forests in trees [@bacci_FindingForestTree_2014], while the other substructure is a *hypergraph*, which is associated with the subhypergraph matching problem.
-To date, practical bigraph matching primarily exists as a CSP implementation [@miculan_CSPImplementationBigraph_2014] or SAT-based algorithm [@sevegnani_SATBasedAlgorithm_2010] in the literature (refer also to Section "State of the Field").
+To date, practical bigraph matching primarily exists as a CSP implementation [@miculan_CSPImplementationBigraph_2014], or SAT-based algorithm [@sevegnani_SATBasedAlgorithm_2010] in the literature.
 
-However, GrGen.NET provides a universal framework written in C# implementing the so-called Single-Pushout (SPO) approach of graph rewriting for multigraphs (see, for example, [@ehrig_FundamentalsAlgebraicGraph_2006; @jakumeit_GrGenNETUser_2023] and Section "Background").
+GrGen.NET provides a universal framework written in C# implementing the so-called Single-Pushout (SPO) approach of graph rewriting for multigraphs (see, for example, [@ehrig_FundamentalsAlgebraicGraph_2006; @jakumeit_GrGenNETUser_2023]).
 The choice to use GrGen.NET instead of other common graph rewrite systems in the software domain (e.g., AGG, PROGRES, FUJABA) is its execution performance with respect to matching and rewriting (refer to the benchmark described in [@geiss_ImprovementsVarroBenchmark_2007], which was introduced in [@varro_BenchmarkingGraphTransformation_2005] first).
 Specifically, GrGen.NET's pattern matching engine employs some techniques that increase the practical execution performance of subgraph matching, which is an NP-complete problem but is at least one order of magnitude faster than comparable candidates [@jakumeit_GrGenNETUser_2023].
-GrGen.NET employs custom-tailored data structures and a dynamically optimized strategy for subgraph matching, which compiles the pattern matchers into machine code to take full advantage of the structure of the current host graph. 
-As described in [@jakumeit_GrGenNETUser_2023], search plans are used to conceptualize matching strategies. Therefore the creation of search plans is framed as an optimization problem, which is heuristically solved by establishing a cost model.
 
 # Key Features
 
-The tool implements a unidirectional transformation from bigraph models to GrGen.NET models, and generates several files that GrGen.NET can execute and visualize. These include GrGen.NET's graph metamodel (`*.gm`), the graph model conforming to the metamodel (`*.grs`), rules (`*.grg`), and a script that configures the initial graph state and defines a simple rule execution strategy (`*.grs`). In turn this means that BiGGer is able to process the signature, bigraph, rules and tracking maps specified in the Eclipse EMF Ecore format [@steinberg_EMFEclipseModeling_2008], which implements the EMOF standard [@ISO19508_2014]. Refer to [www.bigraphs.org](www.bigraphs.org) on how to model EMOF-compliant bigraphs in Java, visually or via the dedicated domain-specific language BDSL [@grzelak_BigraphicalDomainspecificLanguage_2021]. 
+The tool implements a unidirectional transformation from bigraph models to GrGen.NET models, and generates several files that GrGen.NET can execute and visualize. 
+These include GrGen.NET's graph metamodel (`*.gm`), the graph model conforming to the metamodel (`*.grs`), rules (`*.grg`), and a script that configures the initial graph state and defines a simple rule execution strategy (`*.grs`). 
+In turn this means that BiGGer is able to process the signature, bigraph, rules and tracking maps specified in the Eclipse EMF Ecore format [@steinberg_EMFEclipseModeling_2008], which implements the EMOF standard [@ISO19508_2014]. 
+Refer to [www.bigraphs.org](www.bigraphs.org) on how to model EMOF-compliant bigraphs in Java, visually or via the dedicated domain-specific language [@grzelak_BigraphicalDomainspecificLanguage_2021]. 
 
-The functionality of BiGGer is offered via different interfaces suited for users of different backgrounds: programmatically in Java via the API, or by using the command-line tool. Object-oriented design forms the foundation of BiGGer, providing significant benefits to developers. This design paradigm enhances modularity and encapsulation, which in turn simplifies the process of extending and maintaining the software. That is, developers and students in the bigraph community benefit from the integration of BiGGer with other software systems relying on bigraph rewriting via an object-oriented API that supports the efficient execution of transformation rules on large bigraphs currently available in the literature.
+The functionality of BiGGer is offered via different interfaces suited for users of different backgrounds: programmatically in Java via the API, or by using the command-line tool.
+Developers and students benefit from the integration of BiGGer with other software systems relying on bigraph rewriting via an object-oriented API.
+BiGGer supports the efficient execution of transformation rules on large bigraphs currently available in the literature.
 
 Moreover, BiGGer is shipped with sample bigraphs and rules and detailed instructions, which are essential in facilitating a better understanding of BiGGer's capabilities and usage.
 
@@ -80,49 +83,6 @@ Moreover, BiGGer is shipped with sample bigraphs and rules and detailed instruct
 There are few practical solutions concerned with the bigraph matching problem for various kinds of bigraphs; a non-exhaustive presentation is the following. 
 For *binding bigraphs* (i.e., links have local scopes) by an inductive characterization of matching [@birkedal_MatchingBigraphs_2007; @damgaard_InductiveCharacterizationMatching_2013]; for *directed bigraphs* (which subsume *pure bigraphs*) [@bacci_DBtkToolkitDirected_2009]; for \emph{bigraphs with sharing} (i.e., the place graph is a directed acyclic graph) by using a SAT-based algorithm [@sevegnani_BigraphERRewritingAnalysis_2016]; for the pure case by [@miculan_CSPImplementationBigraph_2014] as a CSP, and further an adapted reduction of the problem for directed bigraphs to a CSP [@chiapperini_ComputingEmbeddingsDirected_2020]; and the work in [@gassara_ExecutingBigraphicalReactive_2019], which proposes a toolchain for bigraph matching that is conceptually most similar to our approach but not actively developed anymore and not as efficient as GrGen.NET.
 
-# [Background\label{sec:background}]()
-
-## Graphs and Graph Rewriting in Software Engineering
-
-In the software engineering communities it is widely acknowledged that graphs are appropriate as the underlying mathematical formalism for representing and analyzing software models, modeling languages, processes and systems; see, for example, [@konig_TutorialGraphTransformation_2018; @ehrig_FundamentalsAlgebraicGraph_2006; @heckel_GraphTransformationSoftware_2020]. 
-Graphs are able to represent arbitrary complex data structures, program flows, encode first-order logic and fundamentally serve as a tool for visually representing system states in an intuitive manner. The fact that we can think about visual diagrams as graphs explains the widespread use of such diagrammatical representations.
-
-Naturally, software evolves over time for a variety of reasons, including changing requirements, bug fixing, organizational reasons, performance optimization, security updates, or regulatory compliance, to mention a few.
-
-An approach to model and analyze the dynamics of software models and systems is by using an approach called *graph transformation systems*. Applications of graph transformation in software engineering are numerous, including model and program transformation, specification of the syntax and semantics of visual languages, formalizing software architectures, or for program refactoring.
-The usefulness of graph transformation in addressing various challenges in software development is extensively explicated in [@ehrig_FundamentalsAlgebraicGraph_2006].
-
-Especially the algebraic formalisms, i.e., *algebraic graph transformations systems*, prove valuable as a formal specification technique in distributed state-based systems.
-Through the application of so-called *graph transformation rules*, computations and transitions can be effectively described by local transformation of states, which are represented as graphs.
-A rule consists of a left-hand side, specifying the graph pattern that needs to be found in the host graph, and a right-hand side that describes how the matched graph elements are rewritten afterwards.
-Then, rules are applied to the current graph as long as the left-hand side occurs in the graph.
-In this way, a transition system can be created and expanded incrementally by repeating the procedure on all new states until no rule can be applied anymore.
-
-### Brief History
-
-The concept of graph rewriting originated from the study of *graph grammars*, where the main objective, similar to string and tree grammars, was to define the groups of graphs that can be generated from a set of *productions* [@milner_EmbeddingsContextsLink_2005].
-As explained in [@ehrig_FundamentalsAlgebraicGraph_2006], graph transformation has its origins in three distinct roots: the extension of Chomsky grammars to graph grammars, the adaptation of term rewriting to graph rewriting, and the shift from textual descriptions to visual modeling.
-However, this work employs so-called *bigraphical reactive systems*, which are an instance of the *reactive system theory* of Leifer and Milner [@leifer_DerivingBisimulationCongruences_2000; @milner_SpaceMotionCommunicating_2009] and can be classified to the more recent algebraic graph transformation approaches.
-
-## Bigraphs and Bigraphical Reactive Systems
-
-The range of graph classes is extensive. However, in software development multigraphs (i.e., graphs with parallel edges) are often preferred over trees, since they offer several significant advantages, when modeling software systems in which entities interact in a variety of ways—via function calls, data transfers, or module dependencies. 
-In contrast to trees, which naturally establish a hierarchical structure in which every node (with the exception of the root) has a single parent, graphs allow for arbitrary connections between nodes, thereby facilitating the depiction of more complex relationships. Moreover graph elements can be equipped with attributes for storing arbitrary data, thus, separating the structural information from the nonstructural one [@ehrig_FundamentalsAlgebraicGraph_2006].
-
-However, in this work, bigraphs are employed as devised by Robin Milner, which are fully axiomatized using category theory. For a full account on bigraphs we refer the reader to [@milner_SpaceMotionCommunicating_2009].
-Basically, bigraphs are a superposition of two substructures, where one is a forest called the *place graph*, and the other is a hypergraph, called the *link graph*. 
-They are independently defined and only share the same node-set.
-Typically, the place graph is employed to depict the spatial aspect of a system or model, while the link graph is utilized to describe the interaction and communication among entities.
-
-By definition, bigraphs are compositional structures and support two important operations, namely, *composition*, which nests one bigraph into another, and *juxtaposition*, which places two bigraphs side-by-side. 
-This facilitates the construction of larger structures from smaller ones.
-Therefore, bigraphs have special elements, called *interfaces*, which define whether two bigraphs can be actually composed.
-
-The notion of time-varying bigraphs, similarily to the classical algebraic graph rewriting approaches, can be gained, when they are "equipped" with so-called *reaction rules*.
-Such a construct is known as *bigraphical reactive system*.
-Informally, a bigraphical reactive system is a specification comprising a host bigraph (which can be regarded as the initial state of a system) together with a set of rules, and optionally also a rule execution strategy. 
-Moreover, *bigraphical predicates* (i.e., logical statements described as graphs) can be added to perform classical *model checking* [@baier_PrinciplesModelChecking_2008].
-
 # Acknowledgements
 
 Funded by the German Research Foundation (DFG, Deutsche Forschungsgemeinschaft) as part of Germany’s Excellence Strategy – EXC 2050/1 – Project ID 390696704 – Cluster of Excellence "Centre for Tactile Internet with Human-in-the-Loop" (CeTI) of Technische Universität Dresden.