Having a formal model of neural networks can greatly help in understanding and verifying their properties, behavior, and response to external factors such as disease and medicine. In this paper, we adopt a formal model to represent neurons, some neuronal graphs, and their composition. Some specific neuronal graphs are known for having biologically relevant structures and behaviors and we call them archetypes. These archetypes are supposed to be the basis of typical instances of neuronal information processing. In this paper we study six fundamental archetypes (simple series, series with multiple outputs, parallel composition, negative loop, inhibition of a behavior, and contralateral inhibition), and we consider two ways to couple two archetypes: (i) connecting the output(s) of the first archetype to the input(s) of the second archetype and (ii) nesting the first archetype within the second one. We report and compare two key approaches to the formal modeling and verification of the proposed neuronal archetypes and some selected couplings. The first approach exploits the synchronous programming language Lustre to encode archetypes and their couplings, and to express properties concerning their dynamic behavior. These properties are verified thanks to the use of model checkers. The second approach relies on a theorem prover, the Coq Proof Assistant, to prove dynamic properties of neurons and archetypes.

We firstly define an improved version of the spiking neuron model with dendrites introduced in [8] and we focus here on the fundamental mathematical properties of the framework. Our main result is that, under few simplifications with respect to biology, dendrites can be simply abstracted by delays. Technically, we define a method allowing to reduce neuron shapes and we prove that reduced forms define equivalence classes of dendritic structures sharing the same input/output spiking behaviour. Finally, delays by themselves appear to be a simple and efficient way to perform an abstract dendritic integration into spiking neurons without explicit dendritic trees. This overcomes an explicit morphology representation and allows exploring many equivalent configurations via a single simplified model structure.

In this paper, we present the synchronous approach as a new method for modeling neural architectures. The synchronous approach is initially used to design controllers for reactive real-time systems, and we explain how it fits well to our objective to design bio-inspired neuromorphic circuits for bio-hybrid experiments. We describe synchronous implementations of some neural models and validate our approach with the Brian simulator. We also compare the synchronous hardware code generated to a standard manually optimised code. And finally we discuss the next steps of our work.

Activity Recognition aims at recognizing and understanding sequences of actions and movements of mobile objects (human beings, animals or artefacts), that follow the predefined model of an activity. We propose to describe activities as a series of actions, triggered and driven by environmental events. Due to the large range of application domains (surveillance, safety, health care ...), we propose a generic approach to design activity recognition systems that interact continously with their environment and react to its stimuli at run-time. In our target applications, the data coming from sensors (video-cameras, etc.) are first processed to recognize and track objects and to detect low-level events. This low-level information is collected and transformed into higher level inputs to our activity recognition system. Such recognition systems must satisfy stringent requirements: dependability, real time, cost effectiveness, security and safety, correctness, completeness ... To enforce most of these properties our approach is to base the configuration of the system as well as its execution on formal techniques. We chose the synchronous approach which provides formal bases to perform static analysis, verification and validation, but also direct implementation. Several synchronous languages such as Lustre, Esterel, Scade and Signal [2] have been defined to describe synchronous automata. These languages are for expert users. We propose a new user-oriented language, named ADeL (Activity Description Language) to express activities and to automatically generate recognition automata. This language is easier to understand and to use by non computer scientists (e.g., physicians) while relying on formal semantics.

This article is threefold: (i) we define the first formal framework able to model dendritic integration within biological neurons, (ii) we show how we can turn continuous time into discrete time consistently and (iii) we show how a Lustre model checker can automatically perform proofs about neuron input/output behaviours owing to our framework. Our innovative formal framework is a carefully defined trade-off between abstraction and biological relevance in order to facilitate proofs. This framework is hybrid: inputs entering the synapses as well as the soma output are discrete signals made of spikes but, inside the dendrites, we combine signals quantitatively using real numbers. The soma potential is inevitably specified as a differential equation to keep a biologically accurate modelling of signal accumulation. This prevents from performing simple formal proofs. This has been our motivation to discretize time. Owing to this discretization, we are able to encode our neuron models in Lustre. Lustre is a particularly well suited flow-based language for our purpose. We also encode in Lustre a property of input/output equivalence between neurons in such a way that the model checker Kind2 is able to automatically handle the proof.

Activity Recognition aims at recognizing and understanding sequences of actions and movements of mobile objects (human beings, animals or artefacts), that follow the predefined model of an activity. We propose to describe activities as a series of actions, triggered and driven by environmental events. Due to the large range of application domains (surveillance, safety, health care ...), we propose a generic approach to design activity recognition systems that interact continously with their environment and react to its stimuli at run-time. In our target applications, the data coming from sensors (video-cameras, etc.) are first processed to recognize and track objects and to detect low-level events. This low-level information is collected and transformed into higher level inputs to our activity recognition system. Such recognition systems must satisfy stringent requirements: dependability, real time, cost effectiveness, security and safety, correctness, completeness ... To enforce most of these properties our approach is to base the configuration of the system as well as its execution on formal techniques. We chose the synchronous approach which provides formal bases to perform static analysis, verification and validation, but also direct implementation. Several synchronous languages such as Lustre, Esterel, Scade and Signal [2] have been defined to describe synchronous automata. These languages are for expert users. We propose a new user-oriented language, named ADeL (Activity Description Language) to express activities and to automatically generate recognition automata. This language is easier to understand and to use by non computer scientists (e.g., physicians) while relying on formal semantics.

In this paper we formalize Boolean Probabilistic Leaky Integrate and Fire Neural Networks as Discrete-Time Markov Chains using the language PRISM. In our models, the probability for neurons to emit spikes is driven by the difference between their membrane potential and their firing threshold. The potential value of each neuron is computed taking into account both the current input signals and the past potential value. Taking advantage of this modeling, we propose a novel algorithm which aims at reducing the number of neurons and synaptical connections of a given network. The reduction preserves the desired dynamical behavior of the network, which is formalized by means of temporal logic formulas and verified thanks to the PRISM model checker.

Many important and critical applications such as surveillance or healthcare require some form of (human) activity recognition. Activities are usually represented by a series of actions driven and triggered by events. Recognition systems have to be real time, reactive, correct, complete, and dependable. These stringent requirements justify the use of formal methods to describe, analyze, verify, and generate effective recognition systems. Due to the large number of possible application domains, the researchers aim at building a generic recognition system. They choose the synchronous approach because it has a well-founded semantics and it ensures determinism and safe parallel composition. They propose a new language to represent activities as synchronous automata and they supply it with two complementary formal semantics. First a behavioral semantics gives a reference definition of program behavior using rewriting rules. Second, an equational semantics describes the behavior in a constructive way and can be directly implemented. This paper focuses on the description of these two semantics and their relation.

Activity recognition is important for security and safety in many domains, such as surveillance and health care. We propose to describe activities as a series of actions, triggered and driven by environmental events. We rely on synchronous automata to describe such activities. We chose the synchronous paradigm because it has a well-founded semantics and it ensures determinism and parallel composition. Moreover, we already developed tools that can be adapted to activity recognition. In this report we propose a new synchronous language to express synchronous automata, that relies on a formal semantics and that al- lows us to perform model-checking proofs, to compile activities into equation systems, and to automatically generate the corresponding recognition code.

Activity recognition aims at recognizing and understanding the movements, actions, and objectives of mobile objects. These objects can be humans, animals, or simple artefacts. Many important and critical applications such as surveillance or health care require some form of (human) activity recognition. Existing languages can be used to describe models of activities, but they are difficult to master by non computer scientists (ex: doctors). In this paper, we present a new language dedicated to end users, to describe their activities. We call it ADeL (Activity Description Language). This language is intended to be part of a complete recognition system. Such a system has to be real time, reactive, correct, and dependable. We choose the synchronous approach because it respects these characteristics, it ensures determinism and safe parallel composition, and it allows verification of systems using model-checking. Relying on the synchronous approach, we supply our language with two complementary formal semantics and we provide it with two formats: textual and graphical. This paper focuses on the description of the ADeL language.

In the literature, neuronal networks are often represented as graphs where each node symbolizes a neuron and each arc stands for a synaptic connection. Some specific neuronal graphs have biologically relevant structures and behaviors and we call them archetypes. Six of them have already been characterized and validated using formal methods. In this work, we tackle the next logical step and proceed to the study of the properties of their couplings. For this purpose, we rely on Leaky Integrate and Fire neuron modeling and we use the synchronous programming language Lustre to implement the neuronal archetypes and to formalize their expected properties. Then, we exploit an associated model checker called kind2 to automatically validate these behaviors. We show that, when the archetypes are coupled, either these behaviors are slightly modulated or they give way to a brand new behavior. We can also observe that different archetype couplings can give rise to strictly identical behaviors. Our results show that time coding modeling is more suited than rate coding modeling for this kind of studies.

The development and debugging of a wireless protocol are complex tasks that many face in the industry and academia. This paper aims at facilitating those tasks by proposing a simulation framework that is capable of verifying and validating a protocol stack at binary level. This simulation framework is based on the co-simulation of QEMU and SystemC, which are interfaced through TLMu. An observer module was developed to analyze the traffic in the simulated network, which contains protocol properties modeled in Light Esterel to check that the frame exchanges comply with the protocol properties, in order to validate the protocol implementation. We describe the development of the simulation framework and its node models capable of executing the protocol’s binary stack. We then explain the modeling of protocol properties in Light Esterel and their insertion in the simulation framework. Finally, we test the OCARI protocol for wireless sensor networks in the simulation framework.

This article presents a new simulation framework for wireless sensor networks based on QEMU and SystemC that aims at validating the binary code of wireless protocols by checking that the protocol's implementation complies with its property specifications during simulation. We describe the development of the model of a node's precise hardware platform capable of executing the protocol's binary code using TLMu, a QEMU wrapper that integrates into SystemC. Our simulation framework incorporates high abstraction level node models and highly detailed node models in a wireless network model based on SystemC. An observer module is added to the simulation framework to analyze exchanged frames and detect protocol property violations. Through our experimental study, we show the correct functionality of our hardware platform model through comparison with real frame exchange traces and the verification of one of the protocol's properties during simulation.

There exists many ways to connect two, three or more neurons together to form different graphs. We call archetypes only the graphs whose properties can be associated with specific classes of biologically relevant structures and behaviors. These archetypes are supposed to be the basis of typical instances of neuronal information processing. To model different representative archetypes and express their temporal properties, we use a synchronous programming language dedicated to reactive systems (Lustre). The properties are then automatically validated thanks to several model checkers supporting data types. The respective results are compared and depend on their underlying abstraction methods.

AUTSEG is an automatic test set generator for embedded reactive systems. It automatically generates exhaustive testsets and allows to check safety properties of the tested system. A first version of AUTSEG has been initially designed for programs dealing with Boolean inputs and outputs. We present in this paper an extension of this tool called AUTSEG V2 to handle symbolic numeric data processing that provides more expressive and concrete tests of the system. To this end, we have developed a new library called superior linear decision diagrams (SupLDD) built on top of linear decision diagrams (LDD) library. This allows symbolic computation of system data while improving system verification (Determinism, Death sequences) and identifying all possible test cases. Our tool characterizes the system preconditions by numeric constraints to derive automatically the symbolic test cases using a backtracking operation. We demonstrate the application of AUTSEG V2 on an industrial example.

The Internet of Things (IoT) connects sensors, actuators and autonomous objects interacting with each other. These devices are represented by web services. Web services composition often involves conflicts between systems having access to shared devices. In our component-based middleware, our solution allows managing access to shared devices, by generating specific constraint components which guarantee the respect of some predefined composition and adaptation constraints. IoT environments are dynamic; our solution ensures adaptation to its changes by using new generated constraint components and inhibitors to deal with the appearance and disappearance of devices/applications. The main contribution in this work is the definition of a new language DCL (Description Constraint Language) that helps to generate our constraint components by describing generic constraints that must be verified on accesses to shared devices. The whole approach and its associated tools rely on the synchronous paradigm, since it has a well-established formal foundation allowing automatic proofs, and interface with most model-checkers. We can then prove and guarantee a safe composition at runtime for our IoT applications.

One of the biggest challenges in hardware and software design is to ensure that a system is error-free. Small errors in reactive embedded systems can have disastrous and costly consequences for a project. Preventing such errors by identifying the most probable cases of erratic system behavior is quite challenging. In this paper, we introduce an automatic test set generator called AUTSEG. Its input is a generic model of the target system, generated using the synchronous approach. Our tool finds the optimal preconditions for restricting the state space of the model. It only works locally on significant subspaces. Our approach exhibits a simpler and efficient quasi-flattening algorithm than existing techniques and a useful compiled form to check security properties and reduce the combinatorial explosion problem of state space. To illustrate our approach, AUTSEG was applied to the case of a transportation contactless card.

In this article, we study several relevant algebraic frameworks to define synchronous language semantics. Synchronous languages are quite dedicated to design critical embedded applications. Thus, verification and compilation is challenging and should rely on mathematical semantics. We study multi-valued algebras as foundation for semantics definition and we show that a 4-valued algebra with a bilattice structure is well suited to our concern. With this approach we can define semantics offering both the generation of models where verification techniques apply, and separated compilation means.

In this paper, we study the modular compilation of imperative synchronous programs. We rely on a formal framework well suited to perform compilation and formal validation of systems. In practice, we design and implement a special purpose language (LE) and its execution equational semantics that allows the modular compilation of programs into software and hardware targets (C code, Vhdl code, FPGA synthesis, Verification tools). We show the correctness of this semantics, and we introduce a new algorithm to check program causality with respect to our modular approach. Relying in this formal approach, we defined a toolkit dedicated to the compilation and the verification of reactive applications. MOTS-CLES : langages synchrones, methodes formelles, compilation separee, verification