Santucci Jean-François
email: santucci@univ-corse.fr

Capocchi Laurent
email: capocchi@univ-corse.fr

Visualization of Folktales on a Map by Coupling Dynamic DEVS Simulation within Google Earth

Keywords: DEVS, Discrete Event Simulation, Google Earth API, Dynamic variable structures

This paper deals with dynamic visualization of folktales on a map. The visualization is performed using a coupling of dynamic simulation with the google earth API. The simulation is based on the DEVS (Discrete EVent system Specification) formalism. We have defined a set of basic models to perform visualization of folktales using a software framework called DEVSimPy. DEVSimPy is a framework dedicated to DEVS modeling and simulation of complex systems. We also present in this paper a validation of the developed basic models based on folktales coming from the Corsican mythology.

INTRODUCTION

This paper deals with spatial visualization of folktales. This work is part of a global project concerning the study of myths according to the method defined by Claude Levi-Strauss (Levi-Strauss, 1955;Levi-Strauss,1969;Levi-Strauss,1971;Levi-Strauss,1978;Levi-Strauss,1981) when dealing with Structural Anthropology. The goal is to offer anthropologists the possibility to visualize on a map a dynamic progress of the story involved by a given myth. The visualization is based on a Discrete EVent system Specification simulation (DEVS) dynamically linked with the Google Earth API [START_REF] Brown | Hacking Google Maps and Google Earth[END_REF]. The interest of such a work for anthropologists is to be able to visualize a story stemming from a myth obtained after a DEVS structural anthropology simulation. From a computer science point of view the interest is to define a generic way to propose dynamic visualization of a given story. We choose to perform the dynamic features of the problem of visualization using the DEVS formalism. The spatial visualization on a map has been done using the Google Earth API. We describe in detail in this paper how a dynamic coupling between DEVS formalism and Google earth has been realized. The proposed approach has been implemented using the DEVSimPy framework in order to develop a dynamic library of DEVS models. We have validated this library using a story stemming from a myth belonging to the Corsican oral culture. This myth is a ""reference" myth according to the meaning of "reference" as Claude Levi Strauss has defined it in his Mythologiques Book Series (Levi-Strauss,1969;Levi-Strauss,1971;Levi-Strauss,1978;Levi-Strauss,1981). The outline of the paper is as follows: we first give the context of the research: which is the structural analysis of myths using DEVS formalism. We also introduce in this first section how the DEVS formalism has been used in order to perform myth transformation. The DEVSimPy framework is briefly presented. Section 3 deals with dynamic visualization of folktales. First an overview of the proposed approach is described. Then we explain how we implemented the simulation of variable dynamic structures which are used in order to perform dynamic visualization of folktales on a Google Earth map. Then we detail the description of the dynamic relationship between the DEVSimPy library of models and the Google Earth API. The validation of the proposed library is presented in section 4 before the concluding remarks and future work.

BACKGROUND

We present in this section the background of the work that is the main contribution of this paper. The dynamic visualization of folktales belongs to a method called Structural Anthropology (Levi-Strauss, 1955). We have developed a software approach based on DEVS formalism in order to perform Structural Anthropology. This software approach leans on the use of the DEVSimPy framework. We first briefly introduce in this section how to perform structural anthropology using a computer science approach. The DEVS formalism is summarized in sub-section 2.2. The DEVSimPy framework is detailed in sub-section 2.3 before the presentation in sub-section 2.4 of the DEVSimPy implementation of folktale transformations as defined by Claude Levi Strauss when dealing with Structural Anthropology.

Structural analysis of myths

The structural analysis of myths has been defined by Claude Levi Strauss in his books. He specially explained how to apply his method in his famous book series (Levi-Strauss,1969;Levi-Strauss,1971;Levi-Strauss,1978;Levi-Strauss,1981). The method leans on the concept of myth transformation. Myth transformation consists in performing the generation of myths from a first "reference" myth as Claude Levi Strauss calls it. The generation involves a set of basic transformations that are applied on the mythems of a given myth. A mythem has been defined in 1955 (Levi-Strauss,1955) as a sentence of a given myth composed by a term and a function. For example the following sentence:" the ogre lives near Casta" is described by the term "ogre" and the function "lives-near-Casta". All the sentences of a given myth can be expressed by a set of mythems. Then a set of transformations can be applied in order to generate a new myth. Seven basic transformations have been defined by Claude Levi-Strauss: homology, symmetry, opposition, homology, canonical formula, suppression of mythems, and addition of mythems. A set of work associating computer sciences and structural analysis of myth has been proposed in the past towards the objective of myth transformation modeling (Klein, Aeschlimann , Applebaum, Balsiger, Curtis, Foster, Kalish, Kamin, Lee, Price & Sasieder, 1997;Maranda,1967;[START_REF] Maranda | Analyse Quantitative et Qualitative de Mythes sur Ordinateur[END_REF][START_REF] Richard | Anthropologie et calcul[END_REF]. These works are attempts to formalize the analysis of tales developed by Claude Levi Strauss. These approaches are based on computer sciences in order to perform systematic myth transformations software. However all these attempts did not succeed in this task. In order to find a solution to this problem we have defined a software myth transformation approach based on the DEVS formalism which is summarized in sub-section 2.2. The structural anthropology of myth as defined by Claude Levi Strauss also proposes the analysis of a given myth according to his spatial representation in the landscape. Since it is issued from oral cultures, a myth is told and retold in front of people. Usually a myth involves a set of places well known by the people who are listening to the story. When the story is told, the landscape linked with the myth is mentally viewed by the listeners. In this paper we describe in detail how after having performed a set of myth transformation we are able to propose the dynamic visualization of a myth on a map using a computer.

DEVS formalism

We briefly introduce the DEVS formalism [START_REF] Zeigler | Theory of Modeling and Simulation[END_REF][START_REF] Zeigler | Multifaceted Modeling and Discrete Event Simulation[END_REF]Zeigler, Praehoffer & Kim, 2000). In the DEVS formalism, one must specify: 1) basic models from which larger ones are built, and 2) how these models are connected together in hierarchical fashion. An atomic model allows specifying the behavior of a basic element of a given system. Basic models (called Atomic Models) are defined by the following structure: AM = < X, S, Y, C, δ ext , δ int , λ, ta > Where,  X is the set of input values, An atomic model allows to specify the behavior of a basic element of a given system. Connections between different atomic models can be performed by a Coupled Model (CM) (Zeigler,1976 ;[START_REF] Zeigler | Multifaceted Modeling and Discrete Event Simulation[END_REF] A simulator is associated with the DEVS formalism in order to exercise coupled model's instructions to actually generate its behavior. The architecture of a DEVS simulation system is derived from the abstract simulator concepts [START_REF] Zeigler | Object-Oriented Simulation with Hierarchical, Modular Models[END_REF] associated with the hierarchical and modular DEVS formalism. In order to implement DEVS modeling and simulation we use the DEVSimPy framework presented in sub-section 2.3.

DEVSimPy Framework

DEVSimPy (stand for DEVS simulator in Python language) is a collaborative Modeling and Simualtion (M&S) software. It is used in order to model and simulate complex systems based on the DEVS formalism in Python programming language.

The initial idea of DEVsimPy is to develop a Graphical User Interface based on the wxPython library [START_REF] Sanner | Python: a programming language for software integration and development[END_REF] around the PyDEVS kernel [START_REF] Bolduc | The modeling and simulation package PythonDEVS for classical hierarchical DEVS[END_REF]. The DEVSIMPY framework provides a friendly interface for discrete event modelling and simulation by integrating the basic classes of the PyDEVS kernel. Figure 1 gives an example of the window interface. You may notice in figure 1 that the window is split into two parts:

 The left part allows the user to visualize the classes which can be instantiated (using a drag and drop). Two kinds of classes appear on figure 1: (i) Basic classes which correspond to the basic components of Discrete EVent Specification formalism and already defined in the classical PyDEVS kernel [START_REF] Bolduc | The modeling and simulation package PythonDEVS for classical hierarchical DEVS[END_REF]); (ii) classes which have been defined in the context of the proposed software for performing myth transformations and myth analysis which may be found under the Myths and Atomic Models (AM) folder.

 The right part (called a canevas) which is dedicated to the design of coupled models (also called diagrams in the following) with a simple drag and drop of classes belonging to the left part of the window. The created coupled model can be saved under a format allowing it to be easily reused and shared.

During the design of a DEVS coupling between several atomic or coupled DEVS models, errors can occur due to the difficulty to follow multiple links. Using DEVSimPy, this task becomes fast and easy. Indeed, it proposes the coupling between models by using the drag-and-drop. Moreover, the port numbers are displayed to facilitate the identification of ports.

DEVSimPy has several other advantages and most of them are inherited from DEVS formalism. First, atomic and coupled DEVS models are considered as black-boxes which have both graphical and the behavioural features that can be configurable by a user-friendly dialog. The modular and the hierarchic aspect of the DEVS formalism is also proposed in DEVSimPy. Since coupled models can be composed by atomic or/and coupled models, DEVSimPy proposes an easy way to visualize the components belonging to a coupled model and their interconnections by double clicking. Secondly, as it is defined by the DEVS formalism, there is no need to implement the simulator in DEVSimPy after the modeling step has been performed. After the modeling task, the simulator is automatically built by clicking on a simple button in the toolbar of DEVSimPy. Thus, a dialog appears allowing the user to choose some of the following options: the verbose mode, the simulation algorithm, the profiling mode and the final simulation time.

Another benefit of the use of DEVSimPy is the possibility to define a dynamic library of atomic and coupled models. Each model is stored in a tree view and is directly accessible by a Developer. When he would like to instantiate a model, he has just to use a drag-and-drop from the panel library to the canvas. When the simulation is performed, it is possible to suspend the process and change the behavior of model under simulation. The loading of a new library is performed dynamically and the modification is immediately operational when the simulation restart. Even better, it is possible to modify the code of model during the suspension of the simulation and to reload it before to restart the simulation process. This property is often used during the model-debugging phase.

When a Developer needs to implement a new functionality, which is required by a specific domain modeling, he can use a plug-in approach. DEVSimPy is based on an efficient system of plugin allowing the extension of functionality in a modular way. Overall, when the developer wants to visualize output data in a specific way or to debug models, he can create a plug-in based on the viewer model proposed in DEVSimPy.

Plug-ins are independent of the DEVSimPy kernel and there are managed through a specific dialog dedicated to their import, activation, deactivation or configuration. This plug-in approach is very interesting from the point of view o the developer view. The Developer can load or unload plug-in depending on the nature of the studied domain without having to define new atomic models that can pollute the library.

The myth modeling requires several atomic models due to the important number of transformation processes. Therefore, the number of coupling between these models is important and the use of DEVSimPy makes sense. Moreover, the analysis of the simulation results can be done with a specific plug-in in order to facilitate both the historic and the final interpretation of the transformation of the myths. The implementation of a data collector (or viewer) using a plug-in is easily done with DEVSimPy.

DEVS simulation for myth transformations

We present the software framework we used in order to implement the DEVS models required to perform myths transformation. The DEVS modeling process we develop is based on the three following steps:

 DEVS modeling of a mythem  Data structure for representing a set of mythems (that is to say a myth)  DEVS modeling of the transformation of a myth based on the application of the seven basic transformations In order to represent a tale belonging to a set of variants of a myth we model the structure of a tale using a coupled model of the DEVS formalism. The coupled model is composed by a set of atomic models corresponding to the different parts of the tale. At the latest level we are using atomic models of the DEVS formalism in order to model the narrative structures of the tale. Each atomic model refers to a basic element of Claude Levi Strauss theory: the mythem involving two variables: a and x. A tale is therefore split into mythems and stores in a text file. The beginning of the story is described through the following four sentences called mythems described in figure 2 We consider a set of folktales issued from Corsican mythology. Corsica is an island of the Mediterranean area where more than 6000 years ago megaliths emerged all over the island territory. These megaliths are signs that define a sacred space linked with a very old mythology. A set of folktales that are linked with the landscape of the Corsican Island has been generated using our approach. The next step is the visualization on a map of a given myth belonging to the set of myths already generated. This step is the main contribution of this paper and explained in section 3 while its validation is presented in section 4.

DYNAMIC VISUALIZATION OF FOLKTALES

The goal is to offer the possibility to dynamically visualize on a map the unfolding of a given myth.

The myth under study is obtained using the myth transformation software presented in section 2. In this section after having pointed out the interest of such a study for the anthropologists we detail the proposed approach. We particularly explain how we have been able to deal with: (i) DEVS variable dynamic structures, (ii) an association of the Google Earth API and (iii) the DEVSimpY framework and dynamic visualization using Google Earth API.

Interest and proposed approach

The study of folktales is an important task belonging to the anthropologist domain. As we presented in section 2.1 one of the main contributor to this kind of study is Claude Levi Strauss. We summarized in section 2 how we have been able to help anthropologist to perform structural analysis using a computer. Once a set of myths belonging to the same geographical region has been generated using the structural analysis method, it is common for an anthropologist to study each myth individually. This study leans on a two kinds of analysis: analysis of a given myth according to the notion of codes as defined by Claude Levi Strauss in his Mythologiques book series (Levi-Strauss,1969;Levi-Strauss,1971;Levi-Strauss,1978;Levi-Strauss,1981); analysis of a given myth according to its contextualization in the landscape. In this paper we focus on the second type of analysis. The goal is:

 to visualize the unfolding of a folktale own to the story skeleton  to sequence the story on a map which summarizes the flow of events. We decide to combine the simulation of models involved in the DEVSimPy framework (see section 2.3) with some features of the Google Earth API in order to perform the dynamic visualization of a given folktale on a map. The following problems have been solved in order to implement this proposed approach:

-simulation of variable dynamic structures using DEVSimPy -activation of google earth from the DEVSimPY framework -dynamic refreshment on the map while the story skeleton is being simulated.

DEVS modelling overview

In order to perform the dynamic visualization of a folktale we have defined a DEVS modeling scheme by implementing the following set of specific atomic models: (1) Viewergen; (2) SIGviewer; (3) MythVisu; (4) PointMyth We also defined a coupled model called MythVariant that is used as the initial variable structure, which will evolve when a new mythem has to be visualized on a map. Figure 5

Variable dynamic structures

In order to perform dynamic visualization of a given myth we had to implement a way to perform DEVS simulation of variable dynamic structures. In order to deal with the modeling of dynamic variable structure system a set of scholars have proposed in the recent past to extend the DEVS formalism (Barros,1997;Hu, Zeigler,Mittal,2005;Baati, Frydman, Giambiasi, 2007a;Baati, Frydman, Giambiasi, 2007b ;[START_REF] Hui | A Simulation Algorithm for Dynamic Structure DEVS Modeling[END_REF][START_REF] Barros | Dynamic structure multiparadigm modeling and simulation[END_REF]. The proposed implementation leans on the definition of a special coupled model involving a classical atomic model usually called Supervisor component (Baati,Frydman,Giambiasi, 2007a ;Baati,Frydman,Giambiasi, 2007b) which drives the dynamic structure discrete event system modifications and coupled models representing the set of potential structures.

Our approach supports changes in structure by the introduction of a special atomic model that keeps in its internal state the structure of a network of models. Changes in the state are automatically mapped into changes in structure. We have called MythVisu the special atomic model in charge of the management of dynamic variable structures in the case of this application. Finally the DEVS ta function is coded through the timeAdvance method of the atomic model MythVisu (lines 38 and 39) and consists in returning the current value of the state variable sigma. We have detailed in this sub-section how to manage dynamic variable structures using the DEVSimPy framework. This concept of dynamic variable structures is used in order to dynamically modify the coupled model MythVariant every time an event corresponding to the detection of a new mythem occurs. In sub-section 3.4 and 3.5 we describe in detail how we have been able to link the dynamic evolution of the coupled model MythVariant with a dynamic visualization of mythems on a map. This visualization leans on the use of the Google earth API.

Google Earth invocation

The Google earth invocation leans on the two following atomic models: PointMyth and SIGViewer. The link between the DEVSimPy software and google earth is performed through a KML (Keyhole Markup Language) file (Google Inc, 2007). KML is a specialized type of XML that enables to build and organize points, lines and other information on a google earth map. The δ ext function of the SIGviewer atomic model allows the management of the placement of marks on google earth using a KML file as it may be seen below: Furthermore the dynamic visualization will be performed using the plug-in view_myth of DEVSimPy. This plug-in allows the user to associate the initialization of the software which will be concerned with the dynamic visualization. The user has to choose between Google Earth and Google Map as it may be seen in figure 8.

Dynamic visualization

The dynamic visualization of the placement of points on the map is realized by setting a refreshment of the KML file associated with the SIGviewer atomic model like described above. The file is modified every time an event is sent to the SIGviewer atomic model own to the δ ext function presented in sub-section 3.4. The detection of an event is performed through the statement pointed out line 3 of the previously detailed code of δ ext : msg = self.peek(activePort). Then the KML file is modified according to the code presented above in sub-section 3.4 (form line 6 to line 25). Furthermore the KML file can be checked by the Google Earth API periodically in order to have dynamic refreshment by enabling the auto-update function of the Google Earth API. Using this option the KML file source is regularly reloaded at an interval that we have specify. The modification of the KML file is performed during the DEVS simulation of the overall DEVS modelling presented in sub-section 3.2. However one of the main interests of the proposed approach is to offer the possibility of a dynamic printing on a map the unfolding of a folktale. We therefore have to perform a step-to-step simulation in order to activate the refreshment of the KML file associated with the SIGViewer using the previously introduced method. We use a special plug-in called Blink belonging to the DEVSimPy features allowing to perform a step-to-step simulation as described in figure 9. Using the Forward button of the Blink Logger window we are able to control the generation of the KML file. By setting an appropriate period of refreshment (for example 10 second) the user is able to see the placement of every mythem on the screen and read the required information concerning the folktale as it is described in the next section.

VALIDATION

In order to validate the previously DEVS models we consider a set of myths belonging to the Corsican mythology. We detail the validation of the first myth of this set. This myth is untitled U Lurcu which means the ogre in Corsican language. The twenty mythems belonging to this folktale are given in figure 10. They are expressed in Corsican language.

As presented in sub-section 2.4, each mythem is composed by a term and a function. Furthermore each mythem is numerated. There are therefore two ways of using the simulation: (i) by selecting the step-to-step simulation -the user has in this case chosen the Blink plug-in as seen in sub-section 3.5 and is able to discover the unfolding of the myth interactively by clicking on the forward button; (ii) by performing a complete simulation and own to the enumeration of the generated points on the map the user is able to read the unfolding of the myth on the map by clicking on the different points of the story one after the other. The main interest for an anthropologist is to be able to visualize how the story takes place in its natural environment. Since the places of the myth very often correspond to sacred places of the considered territory it is very important for an anthropologist to see how they are linked together through the unfolding of a myth.

CONCLUSIONS

We have presented in this paper set an approach to dynamically visualize the unfolding of a folktale. This work is part of a multi-disciplinary research concerning Structural anthropology of myths and computer science: the goal is to offer a software approach to help an anthropologist to perform Claude Levi Strauss myth analysis method. This method is based on the concept of mythem. Each folktale (or myth) is decomposed into a set of mythems which are the basic elements of a given story. The proposed approach leans on an association of the DEVS formalism and the Google Earth API. We have detailed the set of DEVS models which has been defined in order to: (i) dynamically read a text file containing the story where each line of the file corresponds to a mythem ; (ii) dynamically print on a map each mythem using the Google Earth API. We introduced a software framework called DEVSimPy which has been used in order to implement the set of DEVS models required in order to perform the dynamic visualization of myths. We also described the validation of these DEVS model using a concrete folktale belonging to the Corsican mythology. The future work will consist in deeply collaborating with an anthropologist in order to model the 813 myths defined by Claude Levi Strauss in his Mythologiques Series and a set of more than 200 myths coming from the Corsican Mythology and known by the anthropologist. Our future work will also concern the dynamic simulation of a given myth in a 3D environment.

S:

  is the set of sequential states,  Y: is the set of output values,  δ int , is the internal transition function dictating state transitions due to internal events,  δ ext the external transition function dictating state transitions due to external input events.  λ is the output function generating external events at the output, and  ta is the time-advance function which allows to associate a life time to a given state.

  : CC = < X, Y, D, {M d / d є D}, IC,EIC, EOC> Where,  X is the set of input values,  Y is the set of output values,  D is the set of model references, that is to say a set of names associated to the model's components {M d / d є D} is the set of coupled model's components, with d being in D. These components are either atomic or coupled DEVS model,  IC, EIC and EOC define the coupling structure in the coupled system (IC defines the internal coupling, transforming a component's output into another component's input within the coupled model ; EIC is the set of external input coupling, which connects the inputs of a coupled model to components inputs; EOC is the set of external output coupling A coupled model, tells how to couple (connect) several component models together to form a new model. This latter model can itself be employed as a component in a larger coupled model, thus giving rise to hierarchical construction.

Figure 1 :

 1 Figure 1: The DEVSimPy framework interface PyDEVS is an API of the modeling and simulation algorithms of DEVS implemented in python language. It is used in the software ATOM3 (De Lara & Vangheluwe, 2011). WxPython is a blending of the wxWidgets C++ class library with the Python programming language.The DEVSIMPY framework provides a friendly interface for discrete event modelling and simulation by integrating the basic classes of the PyDEVS kernel. Figure1gives an example of the window interface. You may notice in figure1that the window is split into two parts: The left part allows the user to visualize the classes which can be instantiated (using a drag and drop). Two kinds of classes appear on figure1: (i) Basic classes which correspond to the basic components of Discrete EVent Specification formalism and already defined in the classical PyDEVS kernel (Bolduc & Vangheluwe, 2001); (ii) classes which have been defined in the context of the proposed software for performing myth transformations and myth analysis which may be found under the Myths and Atomic Models (AM) folder. The right part (called a canevas) which is dedicated to the design of coupled models (also called diagrams in the following) with a simple drag and drop of classes belonging to the left part of the window. The created coupled model can be saved under a format allowing it to be easily reused and shared.During the design of a DEVS coupling between several atomic or coupled DEVS models, errors can occur due to the difficulty to follow multiple links. Using DEVSimPy, this task becomes fast and easy. Indeed, it proposes the coupling between models by using the drag-and-drop. Moreover, the port numbers are displayed to facilitate the identification of ports.

. 1 .

 1 The ogre named Orcu knows the secret of fabrication of the Corsican cheese using some milk. 2. The shepherds are jealous of the Orcu because of this secret. 3. The ogre is captured because of an ingenious trap. 4. The shepherds ask for the secret of fabrication of the cheese.

Figure 2 :

 2 Figure 2: The four first mythems of a Corsican folktale.

Figure 3

 3 presents the DEVS modeling scheme allowing to generate a set of myths belonging to the Corsican Mythology. In order to obtain the visualization of the set of transformations concerning the myths already generated starting from the reference myth we used a graph representation. Graph visualization is a way of representing the relations between myths as diagrams where nodes are labelled with a given myth and oriented arcs between two nodes represents the fact that the successor node of the arc corresponds to a myth which has been generated from the myth corresponding to the predecessor node of the same arc. The graph representing the set of transformations obtain from the simulation of the DEVS model described in figure3is given in figure4. The generated myths have been validated by the anthropologist specialized in Corsican Culture.

Figure 3 :

 3 Figure 3: overview of the coupled model allowing the generation of s set of myths from an initial myth.

Figure 4 :

 4 Figure 4: Resulting graph describing the transformations of myths after simulation of the DEVS model of figure 3

Figure 5 :

 5 Figure 5: DEVS modelling for dynamic visualization

  presents the DEVS modeling scheme involving four DEVS models: the three atomic models (Viewergen, MythVisu and SiGviewer) as well as the coupled model MythVariant. Furthermore instances of the PointMyth atomic model will be dynamically added into the MythVariant coupled model when a new mythem is encountered by reading a myth.The inter-connection between the four DEVS models is given in figure5. The goal of the atomic model called ViewerGen consists in: (i) scanning a text file corresponding to the given myth under study and generated as presented in sub-section 2.4; (ii) sending a message on its output for every mythem belonging to the given myth, where the message contains the term and the function involved in the mythem as well as the location of each of the mythems belonging to the myth. This information is located in the two files associated to the ViewerGen atomic model as seen on figure6(the files can be loaded using the two attributes: filename (term and function of the mythems) and filename2 (location of each mythem). The Viewergen atomic model is connected to the MythVisu atomic model which is in charge of the management of variable dynamic structures: for each message received on its input port, the MythVisu atomic model is able to add an instance of the PointMyth atomic model in the MythVariant coupled model. A message containing the location of the point associated with the current mythem (as well as the term and the function involved by the mythem) is then sent to the SIGviewer atomic model. The implementation of the MythVisu atomic model is detailed in sub-section 3.3.

Figure 6 :

 6 Figure 6: Properties of the MythVisu atomic model.

Figure 7

 7 Figure 7: Illustration of the MythVariant coupled model The class MythVisu described above points out five methods corresponding to the four basic functions of an atomic model and the constructor method of the class (called __init__ ) which consists in initializing the all attributes of the component (cf. the code above from line 2 to line 8). The DEVS δ int , function of the atomic model MythVisu is coded through the intTransition method (described in lines 10 and 11) and consists in assigning the current value of the state variable sigma to infinity in order to indicate that the atomic model is waiting for an external event. The DEVS δ ext , function of the atomic model MythVisu is coded through the extTransition method (cf. from line 13 to 31) which mainly consists in generating new atomic models in the associated coupled model called MythVariant. The DEVS λ function is coded through the outputFnc method of the atomic model MythVisu -from line 33 to 36) and consists in sending a message on the output port of the atomic model own to the statement of line 36: self.poke(self.OPorts[0],self.msg)

  1def extTransition(self): 2 activePort = self.myInput.keys()[0] 3 msg = self.peek(activePort) 4 point = msg.value[0] 5 kml_tree = KML.KML_Tree(self.fn) 6 ### if there is no Folder, we create 7 ###it with a add_placemark(….) 25 kml_tree.write(self.fn) 26 self.state['sigma'] = 0

Figure 8 :

 8 Figure 8: ViewMyth plug-in initialisation

Figure 9 :

 9 Figure 9: Step-to-step simulation of the generation of points on the map.

Figure 10 :

 10 Figure 10: the twenty mythems in Corsican language of the folktale under test

Figure 11 :

 11 Figure 11: Screenshot of the result of generation on the map of the points involved in the folktale under test


L Capocchi
email: capocchi@univ-corse.fr

J F Santucci
email: santucci@univ-corse.fr

B Poggi
email: bpoggi@univ-corse.fr

C Nicolai
email: cnicolai@univ-corse.fr

DEVSimPy:A Collaborative Python Software for Modeling and Simulation of DEVS Systems

Keywords: Modeling, Simulation, Collaborative softwares, Discrete event systems, Hydraulic systems, Software libraries

The Modeling and Simulation (M&S) of complex systems leans on the collaboration between different actors coming from specific domains. These actors have to communicate through an efficient software in order to improve the M&S process. We therefore propose in this article a collaborative M&S software framework called DEVSimPY. We point out the use of DEVSimPy through a concrete case study: hydraulic network management.

I. INTRODUCTION

The design of models for the simulation of complex systems is a task requiring a lot of time to be achieved. One way to speed up this task is to develop methodologies for: (i) deriving and using reusable design components; (ii) developing collaborative modeling and simulation. Recently a set of research work has been oriented towards this direction. We can highlight that traditional modeling and simulation approaches are mono-disciplinary in style, in that the simulation software development concerns only one application domain. However simulating complex systems, in which the viability of the simulation software depends on the close coupling between different disciplines, therefore calls for a more multidisciplinary approach. In the same time, computer simulations have been becoming increasingly complex and require efficient system simulation framework. Furthermore increasing size and geographical separation of design data and teams has created a need for network-based design environments [START_REF] Praehofer | Building Reusable Simulation Components[END_REF][START_REF] Filho | GroupSim: A collaborative environment for discrete event simulation software development for the World Wide Web[END_REF][START_REF] Van Der Zee | Developing participative simulation models: framing decomposition principles for joint understanding‖[END_REF]. Usually modeling and simulation tools are associated with libraries of reusable modeling components that will make the description of the models and also their validation much easier [START_REF] Balci | Developing a Library of Reusable Model Components by Using the Visual Simulation Environment[END_REF][START_REF] Breunese | Libraries of Reusable Models: Theory and Application[END_REF][START_REF] Meyer | Reusable Software -The Base Object-Oriented Component Libraries‖[END_REF]. Storing models in a common generic library has several benefits. First, the genericity of this storage service can be offered to various modeling and simulation environments. Second, a common library allows environments to share information so they can interact each other, and third, several users can share modeling components. This last point is the most important since it allows a modelling and simulation team enabling an efficient collaborative work. Modeling and Simulation applications of today and tomorrow will be increasingly based on three fundamental technologies: object orientation, Collaborative Design and Internet (especially the World Wide Web):

 object orientation allows applications to be viewed in terms of natural objects,  collaborative testing help,  and the Web allows to access resources located all around the world. A Web-based access is a very interesting perspective for a generic modeling and simulation components library, since it allows a userfriendly remote access using a simple web browser. Three distinct levels of communication with a Computer Modeling and Simulation framework have to be considered. At the higher level of communication, a domain specialist interacts with the Computer Modeling and Simulation framework in order to define an environment contributing to the solution of a certain class of problems related to a given domain. We call this environment an application system and the person who defines it an Application Builder. His role is to define appropriate models for the class of applications, specify appropriate processing tools and establish problem resolution strategies adapt to his class of applications. At the lower, an application system is activated by a user (called the Final User) in order to solve a particular problem. The role of the Final User is to supply the problem description and other relevant information to the application system. The remaining level correspond to the Framework Builder, who: (i) is familiar with the internal software structures of the Computer Aided Design framework and (ii) is in charge of the creation and management of the different libraries involved in application domains.

In this paper we propose to develop a Collaborative Modeling and Simulation Framework based on DEVS (Discrete Event Specification) simulations. The DEVS formalism introduced by Zeigler [START_REF] Zeigler | Theory of Modeling and Simulation[END_REF] provides a means of specifying the behavior of a given system. It provides a formal representation of discrete event systems capable of mathematical manipulation just as differential equations serve this role. One of the main interests in DEVS formalism is the fact that it allows an explicit separation between the modeling and simulation part. This means that we can define the model representing the behavior of a given system without having to consider the simulation phase. The definition of an efficient collaborative modeling and simulation framework raises a set of problems. The first type of problems concerns the manipulation of the basic elements (atomic models, coupled models and test benches). It is a very important part of simulation models Design. The elements are normally defined in terms of concepts which are specific to the class of applications for which the model is used. These definitions are stored in a library. When an element occurs in a model description, its definition is copied from the library and placed in the context of the model. Thus an element once defined and placed in the library, can be used as often as required without having to be redefined. The second type of problems to solve is to propose the management of software design errors using a web based access. The idea is that the final user could have the possibility to automatically refer to the Application Builder when a model design error happens and in the same way that the Application Builder could refer the Framework Builder when a software framework error happens. The last type of problems to be solved concerns the ways to share both atomic models, coupled models and testing developments.

We describe in this article an object-oriented framework called DEVSimPy allowing to propose solution to the three types of problem previously mentioned. Furthermore this environment provides a user-friendly interface for creating DEVS models. The simulation is performed by running the PyDEVS simulator [START_REF] Bolduc | The modeling and simulation package PythonDEVS for classical hierarchical DEVS[END_REF]. The originality of our approach lies in the facts that it is based on a strong notion of genericity of use. We have already validated the use of the proposed approach in the framework of the simulation of a complex system: the software simulation of the management of a hydraulic network. The design of the software leans on the collaboration of several specialists in charge of different part of the common library of models to be defined : (i) a specialist of the development of mathematical modelling in charge of the simulation of the behaviour of dams, (ii) a specialist of spatial data modelling in charge of the simulation of data related to geographic information systems, (iii) a specialist of discrete event modelling in charge of the simulation of the hydraulic Engineer strategies and (iv) a specialist of learning based models in charge of the simulation of predictive systems as rainfall or water consumption. These four types of specialists will be able to collaborate within the proposed software framework as representing each of them an Application Builder. We will point out how the DEVSimPY framework has been used in order to define a software simulation of the hydraulic network system.

The paper is organized as follows. Section 2 presents the basics of our work: the DEVSimPy framework. Section 3 first introduces the complex application case: the simulation of an hydraulic network management. We then points out how the DEVSimPy framework has been used in order to perform a simulation model of such complex system. Finally, section 4 concludes the paper and provides some perspectives of work.

II. DEVSIMPY M&S SOFTWARE

A. Initial idea

In this section we present a software framework dedicated to DEVS modeling and simulation. This framework is being developed at University of Corsica using the Python Language. The SPE (Sciences Pour l'Environnement) laboratory of the University of Corsica is specialized in the field of environmental systems modeling based on DEVS formalism. DEVS is a mathematical formalism allowing modeling and simulation of discrete event systems in hierarchical and modular way [START_REF] Zeigler | Theory of Modeling and Simulation[END_REF]. In the DEVS formalism, one must specify: 1) basic models from which larger ones are built (they are called atomic models), and 2) how these models are connected together in hierarchical fashion (to obtain coupled models). The SPE team has published several works on extensions of the DEVS formalism responding to problems from different application areas as:

• the simulation of forest fires,

• the behavioral test of digital circuits,

• the behavioral simulation of hydraulic network,

• the simulation of sensor networks,

• the simulation of myths and legends,

• … When a member of SPE team has to define a DEVS model of a system, he always uses a generic and reusable approach. The choice of the best programming language used in order to implement the model depends on factors in relation with the nature of the system. In recent years, the PyDEVS library has been increasingly used in the SPE laboratory due to its simplicity of use and also because it is coded in Python [START_REF] Sanner | Python: a programming language for software integration and development[END_REF]. Python is an object-oriented programming language known to be clear and readable, fast to learn, reusable and portable on multiple platforms. PyDEVS provides an API allowing the user to model and simulate DEVS models in Python code. This API is used in the excellent multi-modeling GUI software named ATOM3 [START_REF] Lara | AToM3: A Tool for Multi-formalism and Meta-modelling[END_REF] which allows to use several formalisms without focusing on DEVS.

The initial idea of DEVSimPy (Python Simulator for DEVS models) project is to provide a GUI based on PyDEVS API in order to facilitate both the coupling and the reusability of PyDEVS models. It is a user-friendly interface for collaborative modeling and simulation of DEVS systems implemented in Python. With DEVSimPy the modeler can:

 model a DEVS system and save it into a library,  edit the DEVS model during the simulation,  import existing library of models,  automatically simulate/analyze the system,  …

DEVSimPy is an open source project under GPL V3 license and the SPE research laboratory team supports its development. It uses the wxPython graphic library, the Python Language and the PyDEVS API (Fig. 1). It can be downloaded from http://code.google.com/p/devsimpy/.

Figure 1. DEVSimPy Layer View

B. DEVSimPY features

DEVSimPy has been built to facilitate collaboration of researchers during the DEVS modeling. Indeed, DEVSimPy final users (Fig. 2) can develop and maintain libraries of generic components. The libraries can be stored on the hard disk or network to improve sharing. In addition, the components belonging to dynamic libraries are compressed files that contain the behavior and graphic of the models. This approach keeps the separation between the behavior and the view of the models. So DEVSimPy framework builder improves the sharing of component libraries making an easy manipulation. The M&S kernel has been build by the DEVSimPy application builder in order to make possible the simulation of models based on the components.

Figure 2. DEVSimPy actors and collaborations

When a final user debugs its models, an error can occurs. The framework and application builders have developed two error managers (Fig. 2). These modules provide to the final users an easy way to correct their models or to send emails to the authors of the models. If the error occurs in the kernel, the GUI error reporter sends emails to DEVSimPy developers.

1) Sharing Component Dynamic Libraries

In DEVSimPy, libraries are directories that contain components represented by files. Users can create libraries which can be stored on a local hard disk or on an external http server. Thus, there is two ways to share components: read-only when the shared library is stored on an http server and read/write when the shared library is stored on the hard disk.

This mode of sharing allows to create two collaborative approaches depending on the nature of DEVSimPy users: developer for the read/write access or single user for read-only access. DEVSimPy has a library manager with a specific interface that offers several features (import, activation, deactivation,...). All imports of new libraries in DEVSimPy are done through this interface. The user can also view the libraries already imported with their information such as size, location and file name.

2) Handling components and diagrams

A library is composed by files used in order to instanciate components. These components must be portable and easily usable in DEVSimPy. That is why they are constructed from compressed files that contain: a behavioral/structural file for atomic/coupled DEVS model and a graphic file. In this way, there is a separation between behavior (structure) and representation of models.

DEVSimPy has two file extensions depending on the nature of the described components:

• .amd for atomic models: This compressed file consists of a behavior (devs transition functions) and a graphic file (color, shape ,...).

• .cmd for coupled models: This file consists of a file defining a structure (list of DEVS models, coupling between DEVS models,...) and a graphic file. The behavioral or structural files have a file extension ".py" and the graphic files a ".dat".

DEVSimPy was built to facilitate files handling and sharing implemented in PyDEVS. Therefore, a component can be an uncompressed python file. In this case, its representation is automatic in DEVSimPy. However, the user can export it in .amd or .cmd file in order to customize and save its graphic.

To facilitate the use of components, DEVSimPy allows automatic documentation templates. A management system can automatically generate model documentation from python source code. DEVSimPy also offers the debugging of models before the simulation with the possibility of modifying the source code using an embedded code editor.

An error manager is implemented in DEVSimPy in order to inform (mainly by email) developers of an error in the software kernel. This module manages also errors coming from the simulation of models by sending an email to the authors. Its also possible to edit the code source in order to correct the errors.

Another way to have a good collaboration between all actors of the modeling is to use a plugins approach. In fact, each specialist of the domain can in an easy way make a code extension (usually called plugin) that can help the final user in the manipulation of the models. For example, developers can write plugins that show the simulation results in graphs. DEVSimPy is based on a powerful plugin architecture managed by a specific interface allowing activation/desactivation and setting of all installed plugins.

When the user manipulates several components it builds a diagram. These sets of interconnected components can be stored in a compressed file with the .dsp (for DESVSimPy) file extension. Collaboration for a modeling project can be effected through the exchange of such files.

In summary, using DEVSimPy the developer can share components in an efficient way. It can also ask a user to test the simulation models sending both the http link of the component library (or compressed libraries) used by the models and the .dsp file representing the full model.

3) Facilitating the simulation process

Like with DEVS, DEVSimPy simulation algorithms are is automatically generated. Once the model has been built, simulation can be start by clicking on a simple button. A dialog appears giving access to several options like the verbose simulation, the choice of simulation algorithm, the choice of profiling simulation and the final simulation time.

The simulation process is build with a threading approach. Each simulation is generated from a model and several simulations can be performed in parallel. This parallel simulation engine embedded in DEVSimPy is an advantage because user can simulate several behaviors from a single model. Moreover, several simulations can be performed in a concurrent way from several different models. In this way, sharing data is possible between each model.

DEVSimPy allows to go further by using the dynamic simulation property allowing the change of the model behavior during the simulation. Whichever the simulation time, the user can suspend the simulation and edit the code of models in order to modify their behaviors. An another way to do it, is to replace the python file describing the model behavior. In both case, the simulation process can then restart with the new behaviors without any alterations. This aspect is one of the most important aspects because the user can interact with the behavior of models without waiting the end of the simulation.

Another simulation tool proposed by DEVSimPy is the profiling. The modeler can perform the simulation with a profiling option for measuring where models consume resources, including CPU time and memory. Each diagram can be profiled and DEVSimPy save their profiling results in separate files. Profiling can be painfully slow and the user should use it with precautions.

Two types of errors manager are proposed in DEVSimPy. The first one is dedicated to the errors coming from DEVsimPy kernel code. The second manages the errors coming from the code of the models. The latter is interesting from the standpoint of user because the user is informed when a syntax error occurs in the code. The error checking is possible in many case: before the simulation, during the coding of models and during the importation of libraries. When an error is detected, DEVSimPy offers a specific dialog asking to the user if he wants to correct this error.

Finaly, DEVSimpy is composed by several models that are dedicated to the view of events and states (QuickScope, MessageViewer, EventViewer). These models are stored in library and can be used by the user irrespective of the study domain. Their main goal is to help the developer to validate models or to analyze the intermediate signals and events under the modeling process.

III. CASE STUDY: HYDRAULIC NETYWORK M &S

A. Description

The members of the SPE team from University of Corsica are collaborating on a modeling and simulation tool. Our goal is to improve the hydraulic network located in the south of the Corsica Island. Our work comes within the scope of a European cross-border project. The main difficulty is to make an easy collaboration between different specialists in different fields. This scientific sphere can be: computing, mathematics, physics, hydrology and management. The application builders need to communicate and to study the hydraulic network to get realistic behavioral specifications (inputs of the system). With these specifications they can build a determinist model. This one can be simulated to propose an optimization of hydraulic network management (output of the system).

Figure 3. Scheme of the Hydraulic network under study

On Fig. 3 we can see a global system view to model. Outcome of analysis is this plan which represents the general network behavior. Some component like dams, intakes, water link are clearly identifiable and are essential to find optimization at the end of simulation. We have defined three simulation scenarios:

 Maximize water-generated electricity: As you can see on Fig. 3 the network has a power station. This electrical production represents a loss of water but it saves a considerable amount of money.  Minimize pumping between dams: The water demand increases faster during the tourist season. This brings about water pumping to carry out supplying customers with water.  Improve the floodgates management (minimal pressure, stock distribution): A minimal pressure needs to be supported over the hydraulic network. It depends on the water stock and floodgate turning on. Our goal is to allow simulation of complex scenarios and help the decision-maker to take the best choice according to collected data (weather, consumption, stocks). The system modeling is complex and includes some type of sub-systems:

 Data system based on statistic tools like neuronal networks or data mining.

 Behavioral system based on literal or oral description from the expert.  Mathematical system based on equation and mathematical formula like differential equation or final state automata. All these sub-systems are complementary and we would like to use them to build a global system that is coherent with the real hydraulic network functioning as we describe. The collaboration on this project is the key of success and the software DEVSimpy is collaboration oriented.

B. Collaborative M&S Process

The development of a discrete-event modeling and simulation software requires the collaboration of different actors at the main following three steps [START_REF] Ho | Collaborative Work in Domain-Specific Discrete Event Simulation Software Development: Fleet Anti-air Defense Simulation Software[END_REF]: (i) Specification task, (ii) Model Design and (iii) simulation and validation. In this sub-section we point out how the DEVSimPy software framework has been used in order to deal with the case study presented above.

1) Specification Task

The specification task concerns the definition of modeling objectives and requirements analysis. We have performed this first step without any help of the DEVSimPy framework since this task has to elaborate the modeling objectives and requirements without any link with the DEVS formalism. The result of this first step has been obtained after a set of meetings with the Hydrologic Engineers. The result consists in a list of literal descriptions of basic behavior of the different parts composing the overall system under study and presented in section III.A.

2) Model Design Task

This task concerns the design of the set of DEVS models which will be integrated under an overall coupled model. We have to define which models have to be created and how they have to be interconnected. This resulting interconnection is then simulated. The implementation has been performed using the DEVSimpy framework. We have used the framework in order to facilitate the design of the basic models and their interconnection when dealing with the DEVS simulation of the Hydraulic Network described in sub-section III.A. The implementation has been facilitated by the following three features of the DEVSimPy framework: (i) automatic documentation of the code, (ii) the development of libraries and (iii) the automatic generation of code.

The self-documentation of the code is performed during code creation of the models. The application builders have the possibility to add comments by respecting Epytext markup language formalism [START_REF] Loper | Epydoc: API documentation extraction in Python[END_REF]. These comments can be parsed by the Epydoc engine and are used to generate a fulfilled centralized and structured documentation.

The development of libraries allows the Application Builder to offer a set out-context of atomic or coupled models that can easily be inserted in a global simulation models. In the case of the considered application (simulation of an hydraulic network), four different specialists are required in order to define the basic elements : (i) a specialist of the development of mathematical modelling describing the behaviour of dams, (ii) a specialist of spatial data modelling related to geographic information systems, (iii) a specialist of discrete event modelling concerning the hydraulic Engineer strategies and (iv) a specialist of learning based models associated with predictive systems as rainfall or water consumption. Each of them has defined a set of basic atomic models (saved as .amd files) and coupled models (saved as .cmd) that are going to be interconnected in an overall coupled model: (i) the first specialist has defined 6 atomic models (stored as .amd in the library) -pumping atomic model, electrical Power Station atomic model, dam behaviour atomic model, water releases atomic model, pipeline atomic model, valve behaviour atomic model; (ii) the second one has defined three atomic modelspoint atomic model, line atomic model and polygon atomic model; the third one has defined three atomic models corresponding to the different scenarios involved by the management of an hydraulic networkturbine management atomic model, pumping management atomic model and valve management atomic model; and finally the last specialist has defined two atomic modelsrainfall prevision atomic model, water consumption atomic model.

In order to facilitate the use of these atomic models we have defined a set of coupled models stored in the library under the .cmd format. These coupled models have been obtained by interconnection of some of the previously mentioned atomic models: dam location coupled model, and dam behaviour coupled model.

A third kind of element can be stored in the library: the .dsp models. They correspond to validation scenarios that the different specialists can defined in order to test their respective models. Furthermore the final user can also defined a .dsp model corresponding to the actual water network he has to simulate in order to obtained information concerning its management. The part 3 of section III.B will detail this simulation and validation process The last feature offered by DEVSimPy in order to help the Application Builder to design the models to be stored in the library is the automatic code generation tool. DEVSimPy offers the possibility to automatically generate a set of parts of code corresponding to repetitive coding. For example the code corresponding to the checking of arrival of an event is automatically generated on demand of the Application Builder.

3

) Simulation and Validation Task

In this part we show the simulation results through the QuickScope atomic model in three points: (1) Asinao water flow output, Electrical Power station output and the dam output.

The use of the QuickScope atomic model allows to validate the signal form of the water flow in the system. The simulation time step is the week and the context of the simulation is as follows (Fig. 4): the water flow of catchment basin 'Asinao' decreases between the week 1 and 30 and increases between the week 30 and 52. The electrical Power atomic model is operational if the level of water flow coming from Asiano is bottom at 50000 m3/week. In the other case the dam retains the water.

The three following figures (Fig. 4, Fig. 5, Fig. 6) show the operations of the system and validate its behavior. Fig. 4 represents the variation of water coming from the catchment basin 'Asinao'. Fig. 5 represents the Hydropower generate by the electrical power station depending on the data of the Asinao water flow (Fig. 4). Fig. 6 represents the filling up of the dam. When the dam is stable, the electrical micro-central is indeed operational.

IV. CONCLUSIONS AND FUTURE WORK

We introduced in this paper our approach for the definition of a collaborative modeling and simulation framework: DEVSimPY. This tool enables the reusability and sharing of modeling components, an efficient management of different kinds of errors and a friendly test process of the designed models. The proposed framework allows the model designer to perform its model design very quickly, once models have been introduced in a library. We provided also this user with a set of APIs allowing him to process his models through some web-based APIs and graphical interfaces accessible using the DEVSimPy framework.

Our approach has been validated in the framework of a concrete and complex domain: the simulation of an hydraulic network management.

We have three main perspectives of work. The next step will be to develop the possibility to associate several kinds of simulation associated with the library stored models. The second perspective is to define a meta-language in order to help the models design. Finally, we want to study how to manage and maintain with the most efficiency a distribution of simulation models over a network and over multiple hosts.

Figure 4 .Figure 5 .Figure 6 :

 456 Figure 4. Asinao water flow [m3/week]


J Ér Ôme Coville

Juan D Ávila
email: jdavila@dim.uchile.cl

AND SALOM É Mart Ínez

EXISTENCE AND UNIQUENESS OF SOLUTIONS TO A NON-LOCAL EQUATION WITH MONOSTABLE NONLINEARITY

Let J ∈ C(R), J ≥ 0, R J = 1 and consider the nonlocal diffusion operator M[u] = J ⋆ u -u. We study the equation

where f is a KPP type non-linearity, periodic in x. We show that the principal eigenvalue of the linearization around zero is well defined and a that a nontrivial solution of the nonlinear problem exists if and only if this eigenvalue is negative. We prove that if, additionally, J is symmetric then the non-trivial solution is unique.

Introduction

Reaction-diffusion equations have been used to describe a variety of phenomena in combustion theory, bacterial growth, nerve propagation, epidemiology, and spatial ecology [START_REF] Fisher | The Genetical Theory of Natural Selection. A Complete Variorum Edition[END_REF][START_REF] Fife | Mathematical Aspects of Reacting and Diffusing Systems[END_REF][START_REF] Kanel | Certain problems on equations in the theory of burning[END_REF][START_REF] Murray | Mathematical Biology. I. An Introduction[END_REF]. However, in many situations, such as in population ecology, dispersal is better described as a long range process rather than as a local one, and integral operators appear as a natural choice. Let us mention in particular the seminal work of Kolmogorov, Petrovsky, and Piskunov [START_REF] Kolmogorov | Étude de l'équation de la diffusion avec croissance de la quantité de matière et son application à un problème biologique[END_REF], who in 1937 introduced a model for the dispersion of gene fractions involving a nonlocal linear operator and a nonlinearity of the form u(1 -u), which many authors now call a KPP-type nonlinearity.

Nonlocal dispersal operators usually take the form M[u] = R N k(x, y)u(y)dyu(x), where k ≥ 0 and R N k(y, x)dy = 1 for all x ∈ R N . They have been mainly used in discrete time models [START_REF] Kot | Dispersal data and the spread of invading organisms[END_REF], while continuous time versions have also been recently considered in population dynamics [START_REF] Hutson | The evolution of dispersal[END_REF][START_REF] Lutscher | The effect of dispersal patterns on stream populations[END_REF]. Steady state and travelling wave solutions for single equations have been studied in the case k(x, y) = J(x -y), with J even, for some specific reaction nonlinearities in [START_REF] Bates | Traveling waves in a convolution model for phase transitions[END_REF][START_REF] Coville | Propagation speed of travelling fronts in non local reactiondiffusion equations[END_REF][START_REF] Chmaj | Homoclinic solutions of an integral equation: Existence and stability[END_REF][START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF][START_REF] Carr | Uniqueness of travelling waves for nonlocal monostable equations[END_REF][START_REF] Schumacher | Travelling-front solutions for integro-differential equations. I[END_REF].

In this work we restrict ourselves to one dimension and take k(x, y) = J(x -y).

We are interested in the existence/nonexistence and uniqueness of solutions of the following problem:

M[u] + f (x, u) = 0 in R, (1.1)
where f (x, u) is a KPP-type nonlinearity, periodic in x, and M[u] := J ⋆ u -u. We assume that J satisfies J ∈ C(R), J ≥ 0, R J = 1, (1.3) there exist a < 0 < b such that J(a) > 0, J(b) > 0.

(1.4) On f we assume that

                   f ∈ C(R × [0, ∞))
and is differentiable with respect to u, for each u, f (•, u) is periodic with period 2R,

f u (•, 0) is Lipschitz,
f (•, 0) ≡ 0 and f (x, u)/u is decreasing with respect to u, there exists M > 0 such that f (x, u) ≤ 0 for all u ≥ M and all x.

(1.5)

The model example of such a nonlinearity is

f (x, u) = u(a(x) -u),
where a(x) is periodic and Lipschitz. In a recent work, Berestycki, Hamel, and Roques [START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF] studied the analogue of (1.1) with a divergence operator in a periodic setting. More precisely, they considered -∇ • (A(x)∇u) = f (x, u), x ∈ R N , u ≥ 0, (1.6) where A(x) is a symmetric matrix of class C 1,α , periodic with respect to all variables and uniformly elliptic, and f is C 1 and satisfies (1.5). They showed existence of nontrivial solutions provided the linearization of the equation around zero has a negative first periodic eigenvalue.

We prove the following result.

Theorem 1.1. Assume J satisfies (1.3), (1.4) and f satisfies (1.5). Then there exists a nontrivial, periodic solution of (1.1) if and only if

λ 1 (M + f u (x, 0)) < 0,
where λ 1 is the principal eigenvalue of the linear operator -(M + f u (x, 0)) in the set of 2R-periodic continuous functions. Moreover, if λ 1 ≥ 0, then any nonnegative bounded solution is identically zero.

To prove Theorem 1.1, we first need to show that the principal periodic eigenvalue of -(M + f u (x, 0)) is well defined. Let us introduce some notation:

C per (R) = {u : R → R | u is continuous and 2R-periodic}, C 0,1 per (R) = {u : R → R | u is Lipschitz and 2R-periodic}. Theorem 1.2. Suppose a(x) ∈ C 0,1 per (R). Then the operator -(M + a(x)) has a unique principal eigenvalue λ 1 in C per (R); that is, there is a unique λ 1 ∈ R such that M[φ 1 ] + a(x)φ 1 = -λ 1 φ 1 in R (1.7) admits a positive solution φ 1 ∈ C per (R). Moreover, λ 1 is simple, that is, the space of C per (R) solutions to (1.7) is one dimensional.
In [START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF] the authors proved that (1.6) has at most one nontrivial bounded solution, and that it has to be periodic. A similar result is true for the nonlocal problem (1.1), but this time we need J to be symmetric, that is,

J(x) = J(-x) for all x ∈ R. (1.8)
Note, however, that for the existence result, Theorem 1.1, we do not need this condition.

Theorem 1.3. Assume J satisfies (1.3), (1.4), (1.8) and f satisfies (1.5). Let u be a nonnegative, bounded solution to (1.1) and let λ 1 be the principal eigenvalue of the operator -(M + f u (x, 0)) with periodic boundary conditions.

(a) If λ 1 < 0, then either u ≡ 0 or u ≡ p, where p is the positive periodic solution of Theorem

1.1. (b) If λ 1 ≥ 0, then u ≡ 0.
Part (b) of the preceding theorem is already covered in Theorem 1.1 and does not depend on the symmetry of J.

When f is independent of x and satisfies (1.5), the principal eigenvalue of -(M + f ′ (0)) is given by λ 1 = -f ′ (0) and φ 1 is just a constant. Thus in this case Theorem 1.1 says that a bounded, nonnegative, nontrivial solution exists if and only if f ′ (0) > 0, and this solution is just the constant u 0 such that f (u 0 ) = 0. Assuming that J is symmetric, Theorem 1.3 then implies that the constant u 0 is the unique solution in the class of nonnegative, bounded functions.

Recently, considering a nonperiodic nonlinearity f , Berestycki, Hamel, and Rossi [START_REF] Berestycki | Liouville-type results for semilinear elliptic equations in unbounded domains[END_REF] analyzed the analogue of Theorem 1.3 for general elliptic operators in R N , finding sufficient conditions that ensure existence and uniqueness of a positive bounded solution. It is natural to ask whether the periodicity of f and the symmetry of J are crucial hypotheses in Theorem 1.3. We believe that this is the case, since a general nonlocal operator such as (1.2) may contain a transport term, and a standing wave connecting the steady states of the system could appear. We shall investigate further this issue in a forthcoming work.

Hypothesis (1.4) implies that the operator M satisfies the strong maximum principle. Suppose, for instance, that J satisfies (1.3), (1.4). If u ∈ C(R) satisfies M[u] ≥ 0 in R, then u cannot achieve a global maximum without being constant (see [START_REF] Coville | Maximum principles, sliding techniques and applications to nonlocal equations[END_REF]). However, we will need the following version.

Theorem 1.4. Assume J satisfies (1.3), (1.4)

and let c ∈ L ∞ (R). If u ∈ L ∞ (R) satisfies u ≤ 0 a.e. and M[u] + c(x)u ≥ 0 a.e. in R, then ess sup K u < 0 for all compact K ⊂ R or u = 0 a.e. in R.
If f satisfies the stronger hypothesis that, for any x, f (x, u) is concave with respect to u, then actually the periodic solution p of Theorem 1.1 is continuous. To see this notice that from the strong maximum principle, Theorem 1.4, J ⋆p > 0 in R. The concavity of f with respect to u implies that for any x the map u → u -f (x, u) is strictly increasing whenever u -f (x, u) > 0. Then from the continuity of J ⋆ p and (1.1), which can be rewritten as in the form J ⋆ p = p -f (x, p), we deduce that p is continuous.

In section 2 we review some spectral theory and give the argument of Theorem 1.2. Then we prove Theorem 1.1 in section 3 and the uniqueness result, Theorem 1.3(a), in section 4. We leave for an appendix a proof of Theorem 1.4.

Some spectral theory

In this section we deal with the principal eigenvalue problem (1.7). Before stating our result, let us recall some basic spectral results for positive operators due to Edmunds, Potter, and Stuart [START_REF] Edmunds | Noncompact positive operators[END_REF] which are extensions of the Krein-Rutmann theorem for positive noncompact operators.

A cone in a real Banach space X is a nonempty closed set K such that for all x, y ∈ K and all α ≥ 0 one has x + αy ∈ K, and if x ∈ K, -x ∈ K, then

x = 0. A cone K is called reproducing if X = K -K. A cone K induces a partial ordering in X by the relation x ≤ y if and only if x -y ∈ K. A linear map or operator T : X → X is called positive if T (K) ⊆ K. The dual cone K * is the set of functionals x * ∈ X * which are positive, that is, such that x * (K) ⊂ [0, ∞).
If T : X → X is a bounded linear map on a complex Banach space X, its essential spectrum (according to Browder [START_REF] Browder | On the spectral theory of elliptic differential operators[END_REF]) consists of those λ in the spectrum of T such that at least one of the following conditions holds: (1) the range of λI -T is not closed, (2) λ is a limit point of the spectrum of T , (3) ∪ ∞ n=1 ker((λI -T ) n ) is infinite dimensional. The radius of the essential spectrum of T , denoted by r e (T ), is the largest value of |λ| with λ in the essential spectrum of T . For more properties of r e (T ) see [START_REF] Nussbaum | The radius of the essential spectrum[END_REF].

Theorem 2.1 (Edmunds, Potter, and Stuart [START_REF] Edmunds | Noncompact positive operators[END_REF]). Let K be a reproducing cone in a real Banach space X, and let T ∈ L(X) be a positive operator such that T p (u) ≥ cu for some u ∈ K with u = 1, some positive integer p, and some positive number c.

Then if c 1 p > r e (T ), T has an eigenvector v ∈ K with associated eigenvalue ρ ≥ c 1 p
and T * has an eigenvector v * ∈ K * corresponding to the eigenvalue ρ.

A proof of this theorem can be found in [START_REF] Edmunds | Noncompact positive operators[END_REF]. If the cone K has nonempty interior and T is strongly positive, i.e., u ≥ 0, u = 0 implies T u ∈ int(K), then ρ is the unique λ ∈ R for which there exists nontrivial v ∈ K such that T v = λv and ρ is simple; see [START_REF] Zeidler | Nonlinear Functional Analysis and Its Applications. I. Fixed-Point Theorems[END_REF].

Proof of Theorem 1.2. For convenience, in this proof we write the eigenvalue problem

M[u] + a(x)u = -λu in the form L[u] + b(x)u = µu, (2.1)
where

L[u] = J ⋆ u, b(x) = a(x) + k, µ = -λ + 1 + k, and k > 0 is a constant such that inf [-R,R] b > 0. Observe that L : C per(R) → C per (R) is compact (C per (R) is endowed with the norm u L ∞ ([-R,R]) ). Indeed, let u n ∈ C per (R) be a bounded sequence, say u n L ∞ ([-R,R]) ≤ B. Let ǫ > 0 and let A be large enough so that |x|≥A J ≤ ǫ. Since J is uniformly continuous in [-R -2A, R + 2A] there is δ > 0 such that |J(z 1 ) -J(z 2 )| ≤ ǫ 2(A+R) for z 1 , z 2 ∈ [-R -2A, R + 2A] with |z 1 -z 2 | ≤ δ. Then for x 1 , x 2 ∈ [-R, R], |L[u n ](x 1 ) -L[u n ](x 2 )| ≤ R |J(x 1 -y) -J(x 2 -y)| |u n (y)| dy ≤ 2Bǫ + B R+A -R-A |J(x 1 -y) -J(x 2 -y)| dy ≤ 3Bǫ.
This shows that L[u n ] is equicontinuous, and therefore by the Arzelà-Ascoli theorem, L[u n ] is relatively compact.

Let us now establish some useful lemma.

Lemma 2.2. Suppose b(x) ∈ C 0,1 (R) is 2R-periodic, b(x) > 0, and let σ := max [-R,R] b(x).
Then there exist p ∈ N, δ > 0, and u ∈ C per (R), u ≥ 0, u ≡ 0, such that

L p u + b(x) p u ≥ (σ p + δ)u.
Observe that the proof of Theorem 1.2 will then easily follow from the above lemma. Indeed, if the lemma holds, then since u and b are nonnegative and L is a positive operator, we easily see that

(L + b(x)) p [u] ≥ L p [u] + b(x) p u ≥ (σ p + δ)u.
Using the compactness of the operator L, we have r e (L + b(x)) = r e (b(x))=σ, and thus (σ p + δ) 1 p > r e (L+ b(x)) and Theorem 2.1 applies. Finally, we observe that the principal eigenvalue is simple since the cone of positive 2R-periodic functions has nonempty interior and, for a sufficiently large p, the operator (L + b) p is strongly positive.

Let us now turn our attention to the proof of the above lemma. Proof of Lemma 2.2. Recall that for p ∈ N \ {0}, J ⋆ p u := J ⋆ (J ⋆ p-1 u) is well defined by induction and satisfies J ⋆ p u = J p ⋆ u with J p defined as follows:

J p := J ⋆ J ⋆ • • • ⋆ J ⋆ J p times .
By (1.4) it follows that there exists p ∈ N such that inf (-2R-1,2R+1) J p > 0. Using the definition of L, a short computation shows that

L p [u] := R -R J p (x, y)u(y) dy with J p (x, y) = k∈Z J p (x + 2kR -y).
Following the idea of Hutson et al. [START_REF] Hutson | The evolution of dispersal[END_REF], consider now the following function:

v(x) := η(x) b p (x0)-b p (x)+γ in Ω 2ǫ := (x 0 -2ǫ, x 0 + 2ǫ), 0 elsewhere, where x 0 ∈ (-R, R) is a point of maximum of b(x), ǫ > 0 is chosen such that (x 0 -2ǫ, x 0 + 2ǫ) ⊂ (-R, R)
, γ is a positive constant that we will define later on, and η is a smooth function such that 0

≤ η ≤ 1, η(x) = 1 for |x -x 0 | ≤ ǫ, η(x) = 0 for |x -x 0 | ≥ 2ǫ. Let us compute L p [v] + b p (x)v -σ p v: L p [v] + b p (x)v -σ p v = x0+ǫ x0-ǫ J p (x, y) dy b p (x 0 ) -b p (y) + γ + Ω2ǫ\Ωǫ J p (x, y)v(y) dy + (b p (x) -b p (x 0 ))v ≥ x0+ǫ x0-ǫ J p (x, y) dy b p (x 0 ) -b p (y) + γ + (b p (x) -b p (x 0 ))v ≥ x0+ǫ x0-ǫ J p (x, y) dy b p (x 0 ) -b p (y) + γ -1. Using that inf (-2R-1,2R+1) J p > 0, it follows that J p (x, y) ≥ c > 0 for x, y ∈ (-R, R). Hence x0+ǫ x0-ǫ J p (x, y) dy b p (x 0 ) -b p (y) + γ ≥ c x0+ǫ x0-ǫ dy k|x 0 -y| + γ ,
where k is the Lipschitz constant for b p . Using this inequality in the above estimate yields

L p [v] + b p (x)v -σ p v ≥ c x0+ǫ x0-ǫ dy k|x 0 -y| + γ -1.
Therefore we have

L p [v] + b p (x)v -(σ p + δ)v ≥ 2c k log 1 + kǫ γ -1 -δv ≥ 2c k log 1 + kǫ γ -1 - δ γ .
Choosing now γ > 0 small so that 2c k log (1 + kǫ γ ) -1 > 1 2 and δ = γ 4 , we end up with

L p [v] + b p (x)v -(σ p + δ)v ≥ 1 4 > 0.

Existence of solutions

Proof of Theorem 1.1. We follow the argument developed by Berestycki, Hamel, and Roques in [START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF].

First assume that λ 1 < 0. From Theorem 1.2 there exists a positive eigenfunction

φ 1 such that M[φ 1 ] + f u (x, 0)φ 1 = -λ 1 φ 1 ≥ 0. Computing M[ǫφ 1 ] + f (x, ǫφ 1 ), it follows that M[ǫφ 1 ] + f (x, ǫφ 1 ) = f (x, ǫφ 1 ) -f u (x, 0)ǫφ 1 -λ 1 ǫφ 1 = -λ 1 ǫφ 1 + o(ǫφ 1 ) > 0.
Therefore, for ǫ > 0 small, ǫφ 1 is a periodic subsolution of (1.1). By definition of f , any constant M sufficiently large is a periodic supersolution of the problem.

Choosing M so large that ǫφ 1 ≤ M and using a basic iterative scheme yields the existence of a positive periodic solution u of (1.1).

Let us now turn our attention to the nonexistence setting and assume that λ 1 ≥ 0. Let u be a bounded nonnegative solution of (1.1). Observe that γφ 1 is a periodic supersolution for any positive γ. Indeed,

M[γφ 1 ] + f (x, γφ 1 ) < M[γφ 1 ] + f u (x, 0)γφ 1 ≤ -λ 1 γφ 1 ≤ 0.
Since φ 1 ≥ δ for some positive δ we may define the following quantity:

γ * := inf{γ > 0|u ≤ γφ 1 }.
We have the following claim.

Claim 3.1. γ * = 0.
Observe that we end the proof of the theorem by proving the above claim. Proof of the claim. Assume that γ * > 0. Since

v := u -γ * φ 1 satisfies v ≤ 0 in R and M[v] + c(x)v ≥ 0 in R, where c(x) = f (x,u)-f (x,γ * φ1) v
by the strong maximum principle, Theorem 1.4, we have the following possibilities:

• either u ≡ γ * φ 1 , or • there exists a sequence of points (x n ) n∈N such that |x n | → +∞ and lim n→+∞ γ * φ 1 (x n ) -u(x n ) = 0.
In the first case we get the following contradiction:

0 = M[γ * φ 1 ] + f (x, γ * φ 1 ) < M[γ * φ 1 ] + f u (x, 0)γ * φ 1 ≤ 0.
Hence γ * = 0.

In the second case we argue as follows. Let (y n ) n∈N be a sequence of points satisfying, for all n, y n ∈ [-R, R] and x n -y n ∈ 2RZ. Up to extraction of a subsequence, y n → ȳ. Now consider the following sequence of functions u n := u(. + x n ), φ n := φ 1 (. + x n ), and w n := γ * φ n -u n so that w n > 0 in R. Since M is translation invariant and f is periodic, u n and φ n > 0 satisfy

M[u n ] + f (x + y n , u n ) = 0 in R, M[γ * φ n ] + f u (x + y n , 0)γ * φ n ≤ 0 in R.

It follows that

J ⋆ w n ≤ a n (x)w n , where

a n (x) = 1 - γ * f u (x + y n , 0)φ n -f (x + y n , u n ) γ * φ n -u n .
Since w n > 0 we see that a n is well defined and a n ≥ 0. Using that f (x, u)/u is nonincreasing with respect to u we have f (x, γ * φ n ) ≤ γ * f u (x, 0)φ n . This implies

γ * f u (x + y n , 0)φ n -f (x + y n , u n ) γ * φ n -u n ≥ f (x + y n , γ * φ n ) -f (x + y n , u n ) γ * φ n -u n ≥ -C. Thus 0 ≤ a n ≤ C + 1 in R for all n,
with C independent of n. Observe that

J ⋆ w n (0) = a n (0)(γ * φ 1 (x n ) -u(x n )) → 0, which implies R J(-y)w n (y) dy → 0 as n → +∞.
Similarly,

J ⋆ J ⋆ w n (0) = J ⋆ (a n w n )(0) = R J(-y)a n (y)w n (y) dy, but R J(-y)a n (y)w n (y) dy ≤ a n L ∞ R J(-y)w n (y) dy → 0. Hence J ⋆ J ⋆ w n (0) = R (J ⋆ J)(-y)w n (y) dy → 0 as n → +∞. Defining J k := J ⋆ • • • ⋆ J k times ,
we see that for any fixed k ∈ N, R J k (-y)w n (y) dy → 0 as n → +∞.

By (1.4) the support of J k increases to all of R as k → +∞. Thus we may find a new subsequence such that w n → 0 a.e. in R as n → +∞. Since φ 1 is periodic and continuous, φ n (x) → φ(x) uniformly with respect to x, where φ(x) = φ(x + ȳ). Hence ū(x) = lim n→+∞ u n (x) exists a.e. and is given by ū(x) = γ * φ . By dominated convergence, ū is a solution to

M[ū] + f (x + ȳ, ū) = 0,
while by uniform convergence

M[γ * φ] + f u (x + ȳ, 0)γ * φ ≤ 0 in R.
Since ū = γ * φ it follows that f (x + ȳ, γ * φ) ≡ f u (x + ȳ, 0)γ * φ. This contradicts the fact that f (x, u)/u is decreasing in u. Hence, γ * = 0.

Uniqueness when J is symmetric

Throughout this section we assume that J is symmetric. For the proof of Theorem 1.3 we follow the ideas in [START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF].

Proof of Theorem 1.3. Part (b) of this theorem is contained in Theorem 1.1 so we concentrate on part (a).

Let p denote the positive periodic solution to (1.1) constructed in Theorem 1.1 and let u ≥ 0, u ≡ 0 be a bounded solution. We will prove that u ≡ p.

We show first that u ≤ p. Set

γ * := inf{γ > 0 | u ≤ γp}.
Note that γ * is well defined because u is bounded and p is bounded below by a positive constant. We claim that γ * ≤ 1.

Suppose that γ * > 1 and note that u ≤ γ * p. By Theorem 1.4 either u ≡ γ * p or ess inf K (γ * p -u) > 0 for all compact K ⊂ R. The first possibility leads to f (x, γ * p) = γ * f (x, p) for all x ∈ R, which is not possible if γ * > 1. In the second case there exists a sequence (x n ) n∈N such that |x n | → +∞ and lim n→+∞ γ * p(x n )u(x n ) = 0. Let (y n ) n∈N be a sequence satisfying y n ∈ [-R, R] and x n -y n = k n 2R for some k n ∈ Z. We may assume that y n → ȳ. Let u n := u(. + x n ), which satisfies

M[u n ] + f (x + y n , u n ) = 0. Let w n = γ * p(. + y n ) -u n ≥ 0. Then w n > 0 in R and J ⋆ w n = a n (x)w n ,
where

a n (x) = 1 - γ * f (x + y n , p(x + y n )) -f (x + y n , u n (x)) γ * p(x + y n ) -u n (x) .
Since w n > 0 we deduce that a n is well defined and a n ≥ 0. Using that f (x, u)/u is nonincreasing with respect to u and the fact that γ * > 1, we have f (x, γ * p) ≤ γ * f (x, p). This implies

γ * f (x, p) -f (x, u) γ * p -u ≥ f (x, γ * p) -f (x, u) γ * p -u ≥ -C. Thus 0 ≤ a n ≤ C + 1 in R for all n, with C independent of n. Observe that J ⋆ w n (0) = a n (0)(γ * p(y n ) -u(x n )) = a n (0)(γ * p(x n ) -u(x n )) → 0, which implies R J(-y)w n (y) dy → 0 as n → +∞. Similarly, J ⋆ J ⋆ w n (0) = J ⋆ (a n w n )(0) = R J(-y)a n (y)w n (y) dy, but R J(-y)a n (y)w n (y) dy ≤ a n L ∞ R J(-y)w n (y) dy → 0. Hence J ⋆ J ⋆ w n (0) = R (J ⋆ J)(-y)w n (y) dy → 0 as n → +∞. Defining J k := J ⋆ • • • ⋆ J k times , we see that for all k ∈ N, R J k (-y)w n (y) dy → 0 as n → +∞.
Hypothesis (1.4) implies that the support of J k converges to all of R as k → +∞. Therefore, for a subsequence, w n → 0 a.e. in R as n → +∞. Since p is periodic, for possibly a new subsequence p(x+y n ) → p(x+ ȳ) a.e. Hence, ū(x) = lim n→+∞ u n (x) exists a.e. and by dominated convergence, ū is a solution to

M[ū] + f (x + ȳ, ū) = 0. (4.1)
But since w n → 0 a.e. we have ū = γ * p(• + ȳ). Thus γ * p(• + ȳ) is a solution to (4.1), which is impossible for γ * > 1 as argued before.

The proof that p ≤ u is analogous, but a key point is to prove first that under the conditions of Theorem 1.3 any nontrivial, nonnegative solution is bounded below by a positive constant. This is the content of Proposition 4.1.

Proposition 4.1. Assume that J satisfies (1.3), (1.4), and (1.8), f satisfies (1.5), and that the operator -(M -f u (x, 0)) has a negative principal periodic eigenvalue. Suppose that u is a nonnegative, bounded solution to (1.1). Then u ≡ 0 or there exists a constant c > 0 such that u(x) ≥ c for all x ∈ R. The basic tool to prove Proposition 4.1, following an idea in [START_REF] Berestycki | Analysis of the periodically fragmented environment model. I. Species persistence[END_REF], is to study the principal eigenvalue of the linearized operator in bounded domains. More precisely, let Ω = (-r, +r) and a : Ω → R be Lipschitz. We consider the eigenvalue problem in Ω with "Dirichlet boundary condition" in the following sense:

       M[ϕ] + a(x)ϕ = -λϕ in Ω, ϕ(x) = 0 for all x ∈ Ω, ϕ| Ω is continuous. (4.2)
We show that the principal eigenvalue for (4.2) exists and converges to the principal periodic eigenvalue as r → +∞. The first step is to establish variational characterizations of these eigenvalues, which is the argument that requires the symmetry of J. Lemma 4.2. Let Ω ⊂ R be a bounded open interval. Assume that J satisfies (1.3), (1.4), and (1.8), and let a : Ω → R be Lipschitz. Then there exists a smallest λ 1 such that (4.2) has a nontrivial solution. This eigenvalue is simple and the eigenfunctions are of constant sign in Ω. Moreover,

λ 1 = min ϕ∈C(Ω) -Ω (M[ ϕ] + a(x)ϕ)ϕ Ω ϕ 2 , (4.3)
where ϕ denotes the extension by 0 of ϕ to R and the minimum is attained.

The statement and the proof are analogous to those of Theorem 3.1 in [START_REF] Hutson | The evolution of dispersal[END_REF] except that here we do not assume that J(0) > 0. A different formula for the principal eigenvalue with a Dirichlet boundary condition appears in [START_REF] Chasseigne | Asymptotic behavior for nonlocal diffusion equations[END_REF], where it is used to characterize the rate of decay of solutions to a linear evolution equation.

Proof. Define the operator X

[ϕ] = Ω J(x -y) ϕ(y) dy for ϕ ∈ C(Ω). Then X : C(Ω) → C(Ω) is compact. Let c 0 > 0 be such that inf Ω a(x) + c 0 > 0 and define a = a + c 0 . The eigenvalue problem (4.2) is equivalent to the following: find ϕ ∈ C(Ω) and λ ∈ R such that X[ϕ] + aϕ = (-λ + 1 + c 0 )ϕ in Ω.
A calculation similar to Lemma 2.2 shows that there exists an integer p, u ∈ C(Ω), and δ > 0 such that

(X + a) p u ≥ max Ω a p + δ u in Ω. (4.4)
Using Theorem 2.1 we deduce that the operator X + a has a unique principal eigenvalue ρ > 0 and a principal eigenvector

ϕ 1 ∈ C(Ω). Let λ = 1 + c 0 -ρ so that X[ϕ 1 ] + a(x)ϕ 1 = (1 -λ)ϕ 1 .
From (4.4) we deduce that σ + defined by

σ + = sup ϕ∈C(Ω) Ω (X[ϕ] + a(x)ϕ)ϕ Ω ϕ 2 (4.5)
satisfies

σ + ≥ 1 -λ > max Ω a. (4.6)
Now, using the same argument as in [START_REF] Hutson | The evolution of dispersal[END_REF] we deduce that the supremum in (4.5) is achieved. Indeed, it is standard [START_REF] Brezis | Analyse Fonctionnelle. Théorie et Applications[END_REF] that the spectrum of X + a(x) is to the left of σ + and that there exists a sequence ϕ n ∈ C(Ω) such that ϕ n L 2 (Ω) = 1 and (X + a(x) -σ + )ϕ n L 2 (Ω) → 0 as n → +∞. By compactness of X : L 2 (Ω) → C(Ω) for a subsequence, lim n→+∞ X[ϕ n ] exists in C(Ω). Then, using (4.6), we see that ϕ n → ϕ in L 2 (Ω) for some ϕ and (X +a)ϕ = σ + ϕ. This equation implies ϕ ∈ C(Ω), and hence σ + is a principal eigenvalue for the operator X and by uniqueness of this eigenvalue we have σ + = 1 -λ. Lemma 4.3. Assume that J satisfies (1.3), (1.4), and (1.8) and that a : R → R is a 2R-periodic, Lipschitz function. Then the principal eigenvalue of the operator We claim that inf

-(M + a(x)) in C per (R) is given by λ 1 (a) = inf ϕ L 2 (R) =1 - R (M[ϕ] + a(x)ϕ)ϕ (4.7) = min ϕ∈Cper(R) - R -R (M[ϕ] + a(x)ϕ)ϕ R -R ϕ 2 . ( 4
ϕ L 2 (R) =1 - R (M[ϕ] + a(x)ϕ)ϕ ≤ λ 1 (a).
Indeed, for r > 0 let η r ∈ C ∞ 0 (R) be such that 0 ≤ η r ≤ 1, η r (x) = 1 for |x| ≤ r, η r (x) = 0 for |x| ≥ r + 1. It will be sufficient to show that

lim r→+∞ R (M[φ 1 η r ] + aφ 1 η r )φ 1 η r R (φ 1 η r ) 2 = -λ 1 (a).
|M[φ 1 ](x) -M[φ 1 η r ]| ≤ φ 1 L ∞ |x-z|≥r |J(z)| dz ≤ φ 1 L ∞ |z|≥(1-θ)r
R (M[φ 1 η r ] + aφ 1 η r )φ 1 η r R (φ 1 η r ) 2 + λ 1 (a) ≤ C(1 -θ) + o(1),
which proves (4.10).

To establish (4.7) it remains to verify that

λ 1 (a) ≤ -R (M[ϕ] + a(x)ϕ)ϕ R ϕ 2
for all ϕ ∈ C c (R).

λ 1 (a) ≤ - 2kR -2kR (M[ϕ k ] + a(x)ϕ k )ϕ k 2kR -2kR ϕ 2 k = -R (M[ϕ k ] + a(x)ϕ)ϕ R ϕ 2 . (4.17)
For |x| ≤ kR we have

|M[ϕ k ](x) -M[ϕ](x)| ≤ ϕ L ∞ |y|≥2kR |J(x -y)| dy ≤ ϕ L ∞ |z|≥kR |J(z)| dz. Hence lim k→+∞ R (M[ϕ k ] + a(x)ϕ)ϕ = R (M[ϕ] + a(x)ϕ)ϕ. (4.18)
Thanks to (4.17) and (4.18), we conclude the validity of (4.15). Moreover, the applications y → λ r,y and y → ϕ r,y are periodic. The periodicity of the application y → ϕ r,y is understood as follows: ϕ r,y+2R (x) = ϕ r,y (x -2R). Proof. For convenience we write λ r = λ r,y and let ϕ r be a positive eigenfunction of (4.2) in Ω r .

By the variational characterization (4.3) we see that r → λ r is nonincreasing, and hence lim r→+∞ λ r exists. Moreover, using (4.7) we have

λ r ≥ λ 1 (a) for all r > 0. (4.19) Let φ 1 ∈ C per (R) be a positive eigenfunction of -(M + a(x)) with eigenvalue λ 1 (a) normalized such that R -R φ 2 1 = 2R. Let η r ∈ C ∞ 0 (R) be such that 0 ≤ η ≤ 1, η r (x) = 1 for |x -y| ≤ r -1, η r (x) = 0 for |x -y| ≥ r
and such that η r C 2 (R) ≤ C with C independent of r. Arguing in the same way as in the proof of Lemma 4.3 we obtain

lim r→+∞ R (M[φ 1 η r ] + aφ 1 η r )φ 1 η r R (φ 1 η r ) 2 = -λ 1 (a). Since λ r ≤ -R (M[φ 1 η r ] + aφ 1 η r )φ 1 η r R (φ 1 η r ) 2 we conclude that lim r→+∞ λ r ≤ λ 1 (a).
This and (4.19) prove the desired result.

Let us now show the periodicity of the applications y → λ r,y and y → ϕ r,y . Replace y by y+2R in the above problem (4.2) and let us denote by λ r,y+2R and ϕ r,y+2R the corresponding principal eigenvalue and the associated positive eigenfunction: M[ϕ r,y+2R ] + a(x)ϕ r,y+2R = -λ r,y+2R ϕ r,y+2R in B r (y + 2R).

We take the following normalization: Thus, λ r,y+2R is a principal eigenvalue of the problem (4.2) with Ω r,y = B r (y). Hence, by uniqueness of the principal eigenvalue we have λ r,y = λ r,y+2R and ψ = γϕ r,y for some positive γ. Using the normalization, it follows that γ = 1. Therefore, ϕ r,y (x) = ϕ r,y+2R (x + 2R); in other words ϕ r,y+2R (x) = ϕ r,y (x -2R). is uniform with respect to y ∈ R, since λ r,y is continuous in y.

Proof of Proposition 4.1. Let u ≥ 0 be a bounded solution to (1.1) such that u ≡ 0. By the strong maximum principle (Theorem 1.4) we must have inf K u > 0 for compact sets K ⊂ R.

(1) for any closed interval I one has lim sup ǫ→0 sup I u ǫ < 0, or (2) for some closed interval I one has lim sup ǫ→0 sup I u ǫ = 0. If case (1) occurs, we see that for all closed intervals I we have ess sup I u < 0. Assume case (2) holds. Let I be a closed interval and ǫ n → 0 be such that lim n→+∞ u ǫn (x n ) = 0, where x n ∈ I is such that sup I u ǫn = u ǫn (x n ). Integrating (A.1) from x n -ǫ n to x n + ǫ n and dividing by 2ǫ n , we have This shows that u = 0 a.e. in x -supp(J). Now, for any x 1 in the interior of x -supp(J) we have J ⋆ u(x 1 ) ≥ 0, which shows that u = 0 a.e. in x -2supp(J), where 2supp(J) = supp(J) + supp(J). Note that assumption (1.4) implies that k supp(J) covers all of R as k → +∞, where k supp(J) is defined inductively as (k -1) supp(J) + supp(J). Repeating the previous argument we deduce that u = 0 a.e. in R.

(1. 2 )

 2 Date: October 31, 2006.

1

 1

. 8 )

 8 Proof. By Theorem 1.2 we know that there exists a unique principal eigenvalue λ 1 (a) of the operator -(M + a) in C per (R). Let φ 1 ∈ C per (R) denote a positive eigenfunction associated with λ 1 (a). We normalize φ 1 such thatR M[ϕ] + a(x)ϕ)ϕ R -R ϕ 2is also an eigenvalue of -(M + a) on C per (R) with a positive eigenfunction. By uniqueness of the principal eigenvalue, λ 1 (a) = λ 1 (a).

  η r ) 2 = 2r + O(1) as r → +∞. (4.11) Let 0 < θ < 1. Then

1 =

 1 |J(z)| dz for all |x| ≤ θr = o(1) uniformly for all |x| ≤ θr. (4.12) We split the integral R (M[φ 1 η r ] + aφ 1 η r )φ 1 η r = |x|≤θr . . . dx + |x|≥θr . . . dx. (4.13) Using η r (x) = 1 for |x| ≤ θr and (4.12) we see that |x|≤θr (M[φ 1 η r ] + aφ 1 η r )φ 1 η r = |x|≤θr (M[φ 1 η r ] + aφ 1 )φ 1 = |x|≤θr (M[φ 1 ] + aφ 1 + o(1))φ -2θλ 1 (a)r + o(r) as r → +∞. The second integral in (4.13) is bounded by |x|≥θr(M[φ 1 η r ] + aφ 1 η r )φ 1 η r ≤ C(1 -θ)r.(4.14) Thus from (4.11)-(4.14) we conclude that

(4. 15 )-kR ϕ 2 ,

 152 By uniqueness of the principal eigenvalue we haveλ 1 (a) = inf ϕ∈Cper(Ω k ) -kR -kR (M[ϕ] + a(x)ϕ)ϕ kR (4.16)whereΩ k = (-kR, kR) for k ≥ 1and C per (Ω k ) is the set of continuous 2kR-periodic functions on R. Fix ϕ ∈ C c (R) and consider k large enough so that supp(ϕ) ⊆ Ω k . Consider now ϕ k the 4kR-periodic extension of ϕ. Since ϕ k ∈ C per (Ω 2k ), (4.16) yields

Lemma 4 . 4 .

 44 Assume J satisfies (1.3), (1.4), and (1.8) and that a : R → R is a 2R-periodic, Lipschitz function. Let λ r,y be the principal eigenvalue of (4.2) for Ω r,y = B r (y) and let λ 1 (a) denote the principal eigenvalue of -(M + a(x)) in C per (R). Then lim r→+∞ λ r,y = λ 1 (a).

Ω r,y+2R ϕ 2 r

 2 ,y+2R (x) dx = 1.Let us defined ψ(x) := ϕ r,y+2R (x + 2R) for any x ∈ B r (y). A short computation shows thatM[ψ](x) = M[ϕ] r,y+2R (x + 2R).Therefore, using the periodicity of a(x), we haveM[ψ](x) + a(x + 2R)ψ(x) = λ r,y+2R ψ in B r (y),M[ψ](x) + a(x)ψ(x) = λ r,y+2R ψ in B r (y).

Remark 4 . 5 .

 45 The proof of Lemma 4.4 yields the slightly stronger conclusion that the convergence lim r→+∞ λ r,y = λ 1 (a)

J

  ⋆ u ǫn (x n ) ≥ u ǫn (x n )cu ≤ -c L ∞ u ǫn (x n ) → 0. Hence lim inf n→+∞ J ⋆ u ǫn (x n ) ≥ 0.We may assume that x n → x ∈ I. Then by dominated convergence,J ⋆ u ǫn (x n ) = R J(x n -y)u ǫn (y) dy → R J(x -y)u(y) dy.

Departamento de Ingeniería Matemática, Universidad de Chile Blanco Encalada -2120, 5 PISO, Santiago -Chile

Given y ∈ R and r > 0 we write Ω r,y = (y -r, y +r), λ r,y the principal eigenvalue of -(M + f u (x, 0)) with Dirichlet boundary condition in Ω r,y as in (4.2), and ϕ r,y a positive Dirichlet eigenfunction normalized so that Ωr,y ϕ 2 r,y = 1.

Since the principal eigenvalue λ 1 := λ 1 (f u (x, 0)) of -(M + f u (x, 0)) with periodic boundary conditions is negative by hypothesis, by Lemma 4.4 and Remark 4.5 we may fix r > 0 large enough so that λ r,y < λ 1 /2 for all y ∈ R.

Note that for x ∈ Ω r,y ,

We claim that

This proves the proposition because there is a positive constant c such that ϕ r,y (y) ≥ c for all y ∈ R since the application y → ϕ r,y is periodic and ϕ r,y (y) > 0 for any y ∈ [-2R, 2R]. Now, to prove (4.21) fix y ∈ R and set γ * = sup{ γ > 0 / γϕ r,y ≤ u in R}.

Since inf K u > 0 for compact sets K ⊂ R and ϕ r,y has compact support we see that γ * > 0. Assume that γ * < γ 0 . Then by (4.20), γ * ϕ r,y is a subsolution of (1.1) while u is a solution. By the strong maximum principle (Theorem 1.4) either γ * ϕ r,y ≡ u in R or inf K (u-γ * ϕ r,y ) > 0 for compact sets K ⊂ R. The former case is impossible because u is strictly positive, while the latter case yields a contradiction with the definition of γ * . It follows that γ * ≥ γ 0 as desired.

Appendix

In this appendix we give a short proof of Theorem 1.4. We assume that J satisfies (1. Then u ǫ is continuous in R, u ǫ ≤ 0, and u ǫ → u a.e. as ǫ → 0. There are two cases: