dataesr/scientific-paragraphs-categorization huggingface dataset:
CauDEr first translates the airline example into Core Erlang  [5]. Then one can execute the program, either using a built-in scheduler, or using the log of an actual execution  [30]. Here, if we compile the program in the standard environment and execute the call main(), we get the following output: which is clearly incorrect since we only had three seats available. Seat sold! Seat sold! Seat sold! Seat sold! Agent1 done! Agent2 done! By using the logger and, then, loading both the program and the log into CauDEr (as described in  [30] ), we can replay the entire execution and explore the sequence of concurrent actions. Figure  4  shows the final state (on the left) and the sequence of concurrent actions (on the right), where process 63 is the main process, and processes 67 and 68 are the agents.
The application to debugging has been first proposed in  [14]  in the context of the toy functional language μOz. A related approach is Actoverse  [44] , for Akkabased applications. It provides many relevant features complementary to ours, such as a partial-order graphical representation of message exchanges. On the other side, Actoverse allows one to explore only some states of the computation, such as the ones corresponding to message sending and receiving. We also mention Causeway  [45] , which however is not a full-fledged debugger, but just a post-mortem traces analyser.
Related Work Process calculi, originally designed for the modelling of sequential and concurrent computation, have been applied to biochemical and biological systems. The main instances are the π-calculus  [34] , BioAmbients  [33] , the stochastic π-calculus  [30] , beta binders  [31]  and bioPEPA  [6]. Another way to model biochemical reactions is with rule-based formalisms such as BIOCHAM  [10] , the κ-calculus  [7] , and the BioNetGen Language (BNGL)  [9]. The formalisms κ and BNGL can be used to model interactions between proteins, while this is not possible in BIOCHAM. BNGL allows the use of molecule sites having the same name, which is not allowed in the κ-calculus. Most of the formalisms mentioned above do not explicitly represent reversibility. If an action is the reverse of another action performed before, there is no explicit knowledge of that in the model.
There are a number of software tools that can aid simulation and analysis for our formalisms. Regarding the Bonding Calculus, we can simulate various bonding descriptions by using an existing software platform called UPPAAL (as shown in  [1] ). For CCB, there is a simulation tool presented in  [14]. It allows a much closer form of representation of chemical notation than that possible with a typical programming language. Reversing Petri nets have been shown to be closely related to Coloured Petri Nets, as a subset of the former model has been encoded into the latter  [3]. Thus, an algorithmic translation can be implemented that transforms RPNs to CPNs in an automated manner using the transformation techniques discussed in  [3]. This allows RPNs to exploit tools such as CPNTools that support traditional models of Petri nets.
Related Work Reversibility has previously been investigated for self-reconfigurable robots. Self-reconfigurable, modular robots are distributed robotic devices that can autonomously change their physical shape  [13]. Self-reconfiguration from one shape to another is typically achieved through a specific sequence of actuation operations distributed across the modules of the robot. Automatically reversing the sequence of operations can bring the robot back to its initial shape, as has been experimentally demonstrated using the DynaRole reversible language  [10]. DynaRole however only allows simple sequences of operations to be reversed, which is suitable for reversing self-reconfiguration sequences, but lacks the generality needed to implement more complex behaviours. Initial ideas on generalising the DynaRole language to support a wider range of modular robot control scenarios retain the possibility of reversing distributed sequences  [8, 9] , but have neither been formalised nor experimentally demonstrated.
Last follows the declaration of the second operation apply and turn nut, which is not shown in detail, but has both a forwards and a reverse body, so forwards execution evaluates the forwards body in forwards operation("screwdriver_activate"). io(screwdriver, Switch::on). wait(0. 3). wait(screwingFinished). reverseWith("screwing_finished_backwards"); io(screwdriver, Switch::off). io(screwdriverBackwards, Switch::off); Fig. 3. Sample SCP-RASQ program (adapted from  [4] ). order, and reverse execution evaluates the reverse body in forwards order (i. e. , in the order written in the program). In practice it turned out to be more useful to rely on an internal DSL implemented in C++, using a model-driven approach that serialises the program to an XML structure that can subsequently be instantiated as the graph structure used by the reversible interpreter.
the data that a pointer is referring to may be allocated. This check is performed based on the memory addresses of the argument passed to avpush and the stack boundaries determined as part of the initialization of the Backstroke runtime library. In the presented model only C++ assignments are instrumented because no memory allocation happens in the event functions. The memory for the matrices is allocated in the initialization of the simulation, i. e. in the initialization function for each LP. The avpush function passes a reference to the memory section denoted by the respective expression as argument and stores a pair of the address (of the denoted memory location) and the value at that address in a queue in the Backstroke runtime library. It returns the very same address such that the code can execute as usual and perform the write access.
Adaptations of the ROSS Simulator for the FRC Paradigm For our evaluation we are using the same ROSS implementation as in  [7]. This version offers a commit method. Whenever an event is committed (during fossil collection) a commit function is called for the corresponding LP with the event as an argument. This is a time when non-reversible functions such as file I/O can be called safely. In particular, this is very useful for Backstroke, since commit time is the earliest known moment at which the state saved by the Backstroke instrumented forward code can be released, and memory deallocated by the forward event can be returned to the system. In addition to the commit methods, we extended ROSS to support a C++ class for the simulation time data structure, as opposed to the default double data type for representing time.
The Backstroke instrumented code with local variable optimization instruments 2n 2 memory operations (n 2 for the matrix multiplication, and another n 2 for copying the result into the destination memory). Since there are O(n 3 ) arithmetic operations, we expect the Backstroke instrumented code to incur negligible overhead for sufficiently large matrices. We performed the runs using matrix sizes ranging from 2 to 640. The simulations were run on an cluster with Infiniband interconnect and 2. 6GHz Intel Xeon E5-2670 cpus, 16 cores per node. We used the GNU g++ compiler with version 4. 9. 3, and the "-O3" optimization switches. In the evaluation results we see that Janus performs best for small matrix sizes, whereas the Backstroke generated incremental state saving code performs better the larger the matrix size becomes, with a cross-over point at the size of a matrix size of 20 and for a matrix size of 640 the performance becomes almost the same as the non-instrumented version of the original forward code.
The advantage of Janus generated forward/reverse code is that it does not need to store any additional data since the Janus implementation of the forward code is reversible. Saving memory is useful particularly in Time Warp simulations, since the amount of memory available dictates how much speculation can be performed. A challenge to implementing an algorithm in Janus is that it requires to writing assertions at the end of constructs that enable reverse execution to take the right execution path (i. e. reverse conditionals). In addition, reversibility may require algorithms that use inherently more operations than the most efficient ones available in traditional non-reversible computing.
7 to 4. 3. In a new experiment presented in  [7] , the model was run at a much bigger scale with 1536 × 1536 spins in 256 × 256 logical processes (LPs) and implemented using C++ Standard containers and algorithms and user-defined types. After the transformation by Backstroke the model was run for 2 time units, or a total of 47633718 events on LLNL's IBM BlueGene/Q supercomputer with 16 cores per node, using up to 8192 cores. This version showed a penalty of 2. 7. to 2. 9 in comparison to the hand-written reverse code. In  [16]  an autonomic system is presented that can utilize both an incremental and a full checkpointing mode. At run time both code variants are available and the system switches between the two variants, trying to select the more efficient checkpointing version. With our approach to incremental checkpointing we aim to reduce the number of instrumentations based on static analysis and offer a directive to the user for enabling or disabling the recording of data at runtime, allowing to also manually optimize instrumented code.
Results and Discussion The algorithm was tested using the raytracing Matlab tool Ilmprop  [9]  on a system composed of 64 omnidirectional antennas randomly distributed in space shown in Fig. 2(a). In all computations, channel state information (CSI) in matrix H was normalised to unit average energy over all antennas, users and subcarriers, following the practice from  [10]. 75 randomly distributed scatterers and one large obstacle are placed in the area with the distributed base station. The number of (randomly distributed) users with omnidirectional antennas varied variants of our proposed algorithm tend to outperform the centralised approach as the number of users grows. This in practice means that a single RPN suffices for networks with a relatively large expected number of users. The inherent reversibility of this problem and its solution generalises to the common problem of resource allocation in wireless networks, and sharing any pool of resources (power, frequency, etc.
This work has been partially supported by COST Action IC1405 on Reversible Computation -Extending Horizons of Computing. The second author has been partially supported by the French National Research Agency (ANR), project DCore n. ANR-18-CE25-0007. The third author has been partially supported by JSPS KAKENHI Grant Number JP17H01722. The last author has been partially supported by the EU (FEDER) and the Spanish MICINN/AEI under grant TIN2016-76843-C4-1-R and by the Generalitat Valenciana under grant Prometeo/2019/098 (DeepTrust).
Acknowledgement. The WG2 has been led by  Claudio Antares Mezzina and Rudolf Schlatte. For both of us, it has been an enormous honour to lead such WG, to organise the WG meetings and to interact with all the people involved in the working group. A witness of the liveness of the working group is the list of authors who happily contributed to this document. We would also thank  Irek Ulidowski  (chair) and  Ivan Lanese  (vice-chair) who wisely have led this  COST Action  and the  Management Committee (MC)  who appointed us as leader and co-leader (respectively) of this WG. Acknowledgments. This work has partially been supported by the  European Union  through the  COST Action IC1405  and the  LIT Secure and Correct System Lab  funded by the  State of Upper Austria. Acknowledgements. The authors acknowledge partial support of  COST Action IC1405 on "Reversible Computation -Extending Horizons of Computing ".
They are grateful to  Philipp Niemann , one of the reviewers, for many comprehensive remarks. Acknowledgements. Thanks to  Gabriel Ciobanu  for help in describing the related work on reversibility of massively parallel systems. Acknowledgments. This work was performed under the auspices of the  U. S. Department of Energy  by  Lawrence Livermore National Laboratory  under Contract  DE-AC52-07NA27344  and was supported by the  LLNL-LDRD Program  under Project No. 19-ERD-026. IM release number  LLNL-BOOK-780059. The authors acknowledge the partial support of  EU   COST Action  IC1405 on Reversible Computation-Extending Horizons of Computing. Acknowledgements. The work presented in this chapter was supported by the  COST Association  through the  IC1405 Action on Reversible Computation , as well as a grant from  Science Foundation Ireland (SFI)  co-funded under the  European Regional Development Fund  under Grant Number  13/RC/2077  and  European Union 's  Horizon 2020 programme  under the  Marie Sk lodowska-Curie  grant agreement No  713567.
I am grateful to my collaborators,  Prof Anna Philippou ,  Kyriaki Psara ,  Dr Julien de Rosny ,  Prof Mathias Fink , and  Dr Franco Bagnoli  for making this interdisciplinary research possible, and to  Konstantin Popovic  for the inspiring ideas. This work has been partially supported by  COST Action IC1405 on Reversible Computation -Extending Horizons of Computing , and partly by the  European Union 's  Horizon 2020 Research and Innovation Programme , under Grant Agreement no. 830943 , the  ECHO  project. This work was also supported by the  Ministry of Education, Science and Youth of Canton Sarajevo, Bosnia and Herzegovina  under Grant No. 11/05-14-27719-1/19  and partly by the  Horizon   2020 project OpenQKD  under grant agreement No. 857156.
Research structure Through a qualitative research approach based on primary and secondary data, we used multiple sources of evidence for the triangulation of data  (Yin, 2017) , and we organised the case study analysis into four phases. We collected information from (1) archival records and physical artefacts (e. g. digital platform characteristics) provided by the official website at https://www. saluber. me/, (2) personal interviews, (3) participant observations and (4) online documentation such as reports, statistical data and specialised press articles (Table  1 ). As a primary source of data, we conducted 15 interviews with the various actors involved in the network. Through a semi-structured questionnaire, we requested information on the three main Saluber actors (the founder, the platform developer and the key account manager), three intermediary centres, three carriers, two doctors, one physiotherapist and three customers who used the healthcare services (Table  2 ).
, 2018). The multiple data elements furnish a stronger demonstration and consistency of the key objectives of the case study. Although multiple sources of evidence (e. g. personal interviews and online documentation) are different and independent, their combination can be fundamental to scholars as complementary perspectives of the phenomenon may be produced. Therefore, personal interviews, archival records, media publications and other evidence were triangulated and analysed through a thematic analysis  (Braun and Clarke, 2006). We considered the research question to code, and we associated the emerging themes based on the space within each source of evidence (e. g. personal interview). The software NVivo 8 was implemented to identify the emerging themes through a word frequency analysis.
Big graphs are part of the movement of "Not Only SQL" databases (also called NoSQL) focusing on the relationships between data, rather than the values themselves. The data is stored in vertices while the edges model the interactions or relationships between these data. They offer flexibility in handling data that is strongly connected to each other. The analysis of a big graph generally involves exploring all of its vertices. Thus, this operation is costly in time and resources because big graphs are generally composed of millions of vertices connected through billions of edges. Consequently, the graph algorithms are expansive compared to the size of the big graph, and are therefore ineffective for data exploration. Thus, partitioning the graph stands out as an efficient and less expensive alternative for exploring a big graph.
They represent numerous exciting challenges related to high performance computing problems, where data scalability, program complexity and robustness hardware configurations play an important roles. Solving these problems can contribute to efficiently manage the new trend technologies such as big data (e. g. , dataViz), distributed systems (e. g. , Hadoop  [32]  and Spark  [35] ) or future communication networks (e. g. , 5G or IoT). Network analysis is widely used in various domains where experimenting relies on large-scale dataset structured as graph data and each information is stored in a vertex an the edges modelize interactions between vertices  [1]. The analysis of a large-scale network consists of exploring the properties associated with the edges and vertices of a graph. Given a large-scale network, the time complexity of the graph algorithms increases exponentially compared to the number of vertices.
Thus, to speed up the performance of graph algorithms, a distributed system should be used to speed up analytical tasks. This technique is widely used in NoSQL databases. It is effective because compared to the CAP theorem  [8] , it ensures the consistency and availability of data. Graph-oriented databases cannot guarantee all of the properties of the CAP theorem. Figure  1  shows that the partitioning of a graph ensures only the properties CP and CA of the CAP theorem: • Consistency and Availability (CA): since the graph data is stored on a distributed system, we cannot guarantee the availability and the consistency of the dataset across the cluster at each moment. • Consistency and Partition (CP): eventually the data stored on each partition must be consistent. • Availability and Partition (AP): to ensure fault tolerance, the vertices and/or edges must be replicated on the nodes of the cluster.
If a pair of vertices are connected by more than two edges then the graph is said to be a "multigraph". This form of graphs is more suitable for complex networks and is commonly used in NoSQL databases. An other special case of graphs is "hypergraphs", which are graphs with hyper edges connecting more than two vertices at the same time  [1]. Definition 2 (Sub-graph) Let Gr = (V r, Ed) be a graph, Gr = (V r , Ed ) is a sub-graph of Gr if and only if V r is a subset of V r and Ed is a subset of Ed. In other words, we obtain Gr by removing one or more vertices of Gr, as well as all the edges incident to these vertices. In the example below, the graph Gr = (V r , Ed ) in Figure  4  (b) is a sub-graph of Gr = (V r, Ed) because V r ⊂ V r and Ed ⊂ Ed. We obtain Gr by removing from Gr the vertex 4 and these adjacent edges  (1, 4) ,  (3, 4)  et  (4, 5).
Computational complexity The experimental tests were carried out on the Grid'5000 1  an open platform for cloud computing. It is dedicated exclusively to experimental tests involving high performance computations on parallel and distributed systems. This platform already incorporates big data platforms like Spark  [35] , GraphX  [21]  and Hadoop  [32]  and. The cluster allocated for the tests contains 10 nodes configured in a homogeneous manner (see Figure  6 ). The experimental tests were also carried out by changing the number of nodes. Each node is equipped with 240 GB SSD + 480 GB SSD + 4. 0 TB HDD, 140 GB of RAM, 10 Gbps + 100 Gbps of Omni-Path Ethernet cables and a 2 x Intel Xeon Gold 6130 (16 cores/ CPU). We adopted Ganglia  [23]  for monitoring the cluster's performance. We used benchmark data extracted from SNAP 2  a large network dataset collection.
The parameters used in the DPHV heuristic pseudo-code are described in the table below: • G = (V r, Ed): graph composed of set of vertex V r and edge Ed such that n = |V r| and m = |Ed|. • k: number of sub-graph of the graph Gr such that k > 2. It is a hyperparameter which impacts the execution time and the result optimality. • Gr i : sub-graph i, such as i ∈ [[1; k]] the weight of each partition is defined by w(Gr i ). • slave[i]: slave node which hosts the partition Gr i. • s i : vertex assigned to the partition Gr i , such as s i ∈ V r. We denote V r(s i ) the set of these adjacent vertices such that d(s i ) is its degree. • M : contains all the vertices that have been assigned to one of the k partitions. • Cut si (Gr i ): number of cut-edges generated by the assignment of the vertex s i in the partition Gr i.
Dataset To highlight the applicability and the performances of our heuristic. We have carried out experimental tests on different data sets. We also analyze the behavior of DPHV with respect to the variation in the number of partitions k. Then we make a comparison with benchmark models of existing distributed partitioning algorithms. The evaluation parameters highlighted are 1) the time complexity; 2) communication costs of the cluster, 3) the load balance and 4) the connectivity of the sub-graphs induced in each partition. Experimental tests were also carried out on the Grid'5000 cluster (see Section 3. 2). The DPHV program was written in Java and the different Jobs run on JVM 1. 8. We used two categories of datasets. The first category represents deterministic finite automata with explosion of states.
These data were extracted from the set of different conformance test models of various complex systems 3. These datasets correspond to the finite behavioral models of the test tools piloted by formal verification models for the performance of conventional test tasks: selection of test cases, prioritization, mutation tests, etc. The second category of datasets used represents the road network of Morocco collected from the OpenStreetMap (OSM) spatial database  4. It contains points, different types of roads and lanes between two points of interest. Each entity of the road network contains tags nested in each of these objects. The graph of the road network covers all types of road, including local roads. It contains directed and weighted edges to estimate distances/time of travel. We used QGIS Desktop 2.
18. 3 software and the JOSM (Java OpenStreetMap Editor) tool to extract the information. The filtering criteria are based on "osm tab" tags, we have extracted all the objects whose tag key corresponds to "highway". Table  3  presents the characteristics of the graphs extracted from the datasets. For each dataset, we present the number of vertices |V r|, the number of edges |Ed|, the diameter of the graph D and the clustering coefficient ACC.
Result analysis The study of the behavior of DPHV was carried out on osmMA dataset in order to better understand its complexity of our algorithm. We opted for this dataset because it is a complex network which puts all the evaluation parameters of our approach into competition. Figure  15  shows the behavior of DPHV compared to the number of partitions. Note that the variation of the number of partitions has a great impact on the behavior of DPHV. When the number of partitions increases, the algorithm tends to run slowly, which is quite logical since the time taken to partition a graph into (k + 1) partitions is significant than that of a k partitions. In addition for a high k, DPHV will spend more time evaluating a large number of vertices at each iteration. This greatly influences the time complexity but allows obtaining a better partition which minimizes cut-edges.