Francesca Bugiotti

Luca Cabibbo

Paolo Atzeni

Riccardo Torlone

Database Design for NoSQL Systems

The popularity of NoSQL database systems is rapidly increasing, especially to support nextgeneration web applications. However, given the high heterogeneity existing in this world, where more than fifty systems are available, database design is usually based on best practices and guidelines which are strictly related to the selected system.

We propose a database design methodology for NoSQL systems with initial activities that are independent of the specific target system. The approach is based on NoAM (NoSQL Abstract Model), a novel abstract data model for NoSQL databases, which exploits the commonalities of various NoSQL systems and is used to specify a system-independent representation of the application data. We show how this intermediate representation can be implemented in target NoSQL databases, taking into account their specific features.

Overall, the methodology aims at supporting scalability, performance, and consistency, as needed by next-generation web applications.

Introduction

NoSQL database systems are today an effective solution to manage large data sets distributed over many servers. A primary driver of interest in NoSQL systems is their support for nextgeneration web applications, for which relational DBMSs are not well suited. These are simple OLTP applications for which (i) data have a structure that does not fit well in the rigid structure of relational tables, (ii) access to data is based on simple read-write operations, (iii) scalability and performance are important quality requirements, and a certain level of consistency is also desirable [START_REF] Cattell | Scalable SQL and NoSQL data stores[END_REF][START_REF] Pramodkumar | NoSQL Distilled[END_REF].

More than fifty NoSQL systems exist [START_REF] Stonebraker | Stonebraker on NoSQL and enterprises[END_REF], each with different characteristics. They can be classified into a few main categories [START_REF] Cattell | Scalable SQL and NoSQL data stores[END_REF], including key-value stores, document stores, and extensible record stores. In any case, heterogeneity is highly problematic to application developers [START_REF] Stonebraker | Stonebraker on NoSQL and enterprises[END_REF], even within each category.

Currently, database design for NoSQL systems is usually based on best practices and guidelines [START_REF] Katsov | NoSQL data modeling techniques[END_REF], which are specifically related to the selected system [START_REF] Rathore | HBase: On designing schemas for column-oriented datastores[END_REF][START_REF] Hamrah | Data modeling at scale[END_REF][START_REF] Patel | Cassandra data modeling best practices[END_REF], with no systematic methodology. Several authors have observed that the development of high-level methodologies and tools supporting NoSQL database design are needed [START_REF] Atzeni | The relational model is dead, SQL is dead, and I don't feel so good myself[END_REF][START_REF] Badia | A call to arms: revisiting database design[END_REF][START_REF] Mohan | History repeats itself: sensible and NonsenSQL aspects of the NoSQL hoopla[END_REF]. Indeed, different alternatives on the organization of data in NoSQL databases exist, with significant consequences on major quality requirements, including scalability, performance, and consistency [START_REF] Katsov | NoSQL data modeling techniques[END_REF].

In this paper, we present a design methodology for NoSQL databases that has initial activities that are independent of the specific target system. The approach is based on NoAM (NoSQL Abstract Model), a novel abstract data model for NoSQL databases. NoAM exploits the observations that the various NoSQL systems share similar modeling features. An important insight is that each NoSQL system offers efficient, atomic, and scalable access operations on "data access units" at a certain granularity. Given the application data and the desired data access patterns, the methodology we propose uses NoAM to specify an intermediate, system-independent data representation. The implementation in target NoSQL systems is then a final step, with a translation that takes into account their peculiarities.

The design methodology is intended to support scalability, performance, and consistency, as needed by next-generation web applications. To this end, a major observation is that it is useful to arrange application data in aggregates [START_REF] Evans | Domain-Driven Design[END_REF][START_REF] Helland | Life beyond distributed transactions: an apostate's opinion[END_REF], that is, groups of related data, with a complex value, representing units of data access and atomic manipulation. Aggregates can then be managed in the various NoSQL systems, as their "data access units" are compatible with the features of aggregates. This way, the efficient, atomic, and scalable data access operations can support performance, consistency, and scalability of simple read-write operations over the aggregates of the application.

In accordance with the above observations, the NoAM approach is based on the following main activities:

• conceptual data modeling, to identify the various entities and relationships thereof needed in an application;

• aggregate design, to group related entities into aggregates;

• aggregate partitioning, where aggregates are partitioned into smaller data elements;

• high-level NoSQL database design, where aggregates are mapped to the NoAM intermediate data model, according to the identified partitions; We point out that only the implementation depends on the target datastore. The paper is organized as follows: Section 2 provides an overview of our contribution. Section 3 presents the various data models that we use in our approach. Section 4 discusses conceptual modeling and aggregate design. Section 5 introduces data representation strategies for aggregates in our abstract data model. Section 6 presents some guidelines to partition aggregates and discusses data representations further. Section 7 describes how data representations can be implemented in target NoSQL systems. Section 8 illustrates a case study of NoSQL database design. Section 9 discusses related work. Finally, Section 10 draws some conclusion.

Overview

Let us consider, as a running example, an application for an on-line social game. This is a typical scenario in which the use of a NoSQL database is suitable.

The methodology starts, as it is usual in database design, by building a conceptual representation of the data of interest. For example, our application should manage various types of objects, including players, games, and rounds. A few representative objects are shown in Figure 1. (There, boxes and arrows denote objects and relationships between them, respectively; please ignore, for now, colors and closed curves.)

Our methodology has the goal of designing a "good" representation of these application data in a target NoSQL database. In general, different alternatives are possible, but they are not equivalent in supporting performance, scalability, and consistency. A "wrong" database representation can lead to performance that are worse by an order of magnitude, and to the inability to guarantee atomicity of important operations.

The methodology proceeds by identifying aggregates. Each aggregate is a group of related application objects that should be accessed and/or manipulated together. This activity is relevant to support scalability and consistency, as aggregates provide a natural unit for sharding and atomic manipulation of data in distributed environments [START_REF] Helland | Life beyond distributed transactions: an apostate's opinion[END_REF][START_REF] Evans | Domain-Driven Design[END_REF] are players and games, as shown by closed curves in Figure 1. Note that the rounds of a game are nested within the game itself. In general, aggregates can be considered as complex-value objects [START_REF] Abiteboul | Foundations of Databases[END_REF], as shown in Figure 2.

The following activity consists in partitioning aggregates, if needed, into smaller elements to better support the performance of certain operations. Consider a player that completes a round in a game she is playing. In order to update the underlying database, there would be two alternatives: (i) the addition of the round just completed to the aggregate representing the game; (ii) a complete rewrite of the whole game. The former is clearly more efficient. This fact suggests that it is useful to decompose aggregates into smaller data access units, according to the granularity of some important operations. In our example, we represent each round of a game as a separate data unit.

The next steps of the methodology are based on an abstract data model for NoSQL databases. This is a distinguishing feature of our approach: we use a data representation that refers to NoSQL databases but it is still independent of the actual systems. Indeed, the NoAM model defines abstractions of the common data modeling features provided by the various NoSQL systems. These abstractions are based on the observation that NoSQL systems offer: (i) atomic operations on units of data access and distribution (corresponding to records/rows in extensible record stores, documents in document stores, and groups of key-value pairs in key-value stores), and (ii) data access operations on portions of such units (columns in extensible record stores, fields in document stores, and individual key-value pairs in key-value stores). Accordingly, the NoAM abstract data model has (i) blocks, which are units of data access and distribution. Then, a block is a collection of (ii) entries, each of which associates a key with a (possibly complex) value. Blocks have their own keys and are grouped in collections.

The approach continues by representing aggregates and their smaller data access units into blocks and entries of the NoAM abstract model. This mapping is justified by the fact that aggregates in the application should be managed as data access and distribution units -and that blocks represent data modeling elements provided by NoSQL databases that are, indeed, data access and distribution units. For example, Figure 3 shows a possible representation of the aggregates of Figure 1 in terms of the NoAM data model. There, outer boxes denote blocks representing aggregates, while inner boxes show entries. As mentioned before, the same data {game: "Game:2345", opponent: "Player:mary"} Player/rick/-/games [START_REF] Abiteboul | Foundations of Databases[END_REF] {game: "Game:7425", opponent: "Player:ann"} Player/rick/-/games [START_REF]DynamoDB[END_REF] {game: "Game:1241", opponent: "Player:johnny"} Game/2345/-/id 2345 Game/2345/-/firstPlayer "Player:mary" Game/2345/-/secondPlayer "Player:rick" Game/2345/-/rounds [0] {moves: ..., comments: ...} Game/2345/-/rounds [START_REF] Abiteboul | Foundations of Databases[END_REF] {moves: ..., actions: ..., spell: ...} can be represented in different ways. Compare, for example, Figure 3 with Figures 6 and7 later. We also propose design guidelines to select a suitable data representation, by taking into account the data access patterns required by the application.

In the last step, the selected data representation in the NoAM abstract model is implemented using the specific data structures of a target datastore. For example, if the target system is a keyvalue store, then each entry is mapped to a distinct key-value pair, while blocks correspond to groups of key-value pairs, sharing part of the key. Figure 4 shows how the NoAM database of Figure 3 can be mapped to Oracle NoSQL. An implementation can be considered "effective" if aggregates are indeed turned into units of data access and distribution. The implementation shown in Figure 3 is effective in this sense, by the use we make of Oracle NoSQL keys, which control distribution and atomicity of operations. If the target system is an extensible-record store, such as DynamoDB [START_REF]DynamoDB[END_REF], then each block is mapped to an item and each of its entries is mapped to an attribute of the item, as shown in Figure 5.

Data Models

In our approach, data are represented using various data models, at four different layers: (i) at the application level, data are organized as application objects; (ii) application objects are grouped into aggregates, which are complex-value objects; (iii) aggregates are represented in a system-independent way, according to the NoAM abstract data model for NoSQL databases; rounds [START_REF] Abiteboul | Foundations of Databases[END_REF] rounds [START_REF]DynamoDB[END_REF] 2345 Player:mary Player:rick { moves: ..., comments: ... } { moves: ..., actions: ..., spell: ... } (iv) finally, the abstract database representation is mapped to the specific data modeling elements of a selected target NoSQL system. This section describes these data models, in a bottom-up order.

NoSQL Database Models

NoSQL database systems organize their data according to quite different data models. They usually provide simple read-write data-access operations, which also differ from system to system. Despite this heterogeneity, a few main categories can be identified according to the modeling features of these systems [START_REF] Cattell | Scalable SQL and NoSQL data stores[END_REF][START_REF] Pramodkumar | NoSQL Distilled[END_REF]: key-value stores, extensible record stores, document stores, plus others that are beyond the scope of this paper.

In a key-value store, a database is a schemaless collection of key-value pairs, with data access operations on either individual key-value pairs or groups of related pairs (e.g., sharing part of the key). The key (or part of it, thereof) controls data distribution.

In an extensible record store, a database is a set of tables, each table is a set of rows, and each row contains a set of attributes (or columns), each with a name and a value. Rows in a table are not required to have the same attributes. Data access operations are usually over individual rows, which are units of data distribution and atomic data manipulation.

In a document store, a database is a set of documents, each having a complex structure and value. Documents can be organized in document collections. Data access operations are usually over individual documents, which are units of data distribution and atomic data manipulation.

The NoAM Abstract Data Model

NoAM (NoSQL Abstract Data Model) is a novel data model for NoSQL databases that exploits the commonalities of the data modeling elements available in the various NoSQL systems and introduces abstractions to balance their differences and variations.

A first observation is that all NoSQL systems have a data modeling element that is a data access and distribution unit. By "data access unit" we mean that the NoSQL system offers operations to access and manipulate an individual unit at a time, in an atomic, efficient, and scalable way. By "distribution unit" we mean that each unit is entirely stored in a server of the cluster, whereas different units are distributed among the various servers. With reference to major NoSQL categories, this element is: (i) a record/row, in extensible record stores; (ii) a document, in document stores; or (iii) a group of related key-value pairs, in key-value stores.

In NoAM, we have a construct that models a data access and distribution unit. It is called a block. Specifically, a block represents a maximal data unit for which atomic, efficient, and scalable access operations are provided. Indeed, while the access to an individual block can be performed in an efficient way in the various systems, the access to multiple blocks can be quite inefficient. In particular, NoSQL systems do not provide an efficient "join" operation.

Moreover, most NoSQL systems provide atomic operations only over single blocks and do not support the atomic manipulation of a group of blocks. For example, MongoDB [START_REF]MongoDB[END_REF] provides only atomic operations over individual documents, whereas Bigtable does not support transactions across rows [START_REF] Chang | Bigtable: A distributed storage system for structured data[END_REF].

A second common feature of NoSQL systems is the ability to access and manipulate just a component of a data access unit (i.e., of a block). This component is: (i) a column, in extensible record stores; (ii) a field, in document stores; or (iii) an individual key-value pair, in key-value stores. In NoAM, a smaller data access unit is called an entry.

Finally, most NoSQL databases provide a notion of collection of data access units. For example, a table in extensible record stores or a document collection in document stores. In NoAM, a collection of data access units is called a collection.

According to the above observations, the NoAM data model is defined as follows.

• A NoAM database is a set of collections. Each collection has a distinct name.

• A collection is a set of blocks. Each block in a collection is identified by a block key, which is unique within that collection.

• A block is a non-empty set of entries. Each entry is a pair ek, ev , where ek is the entry key (which is unique within its block) and ev is its value (either complex or scalar), called the entry value.

Figure 3 shows a sample NoAM database. In the figure, inner boxes show entries, while outer boxes denote blocks. Collections are shown as groups of blocks.

Note that entry values can be complex values. The practice of storing a complex value as an individual data element is common to various NoSQL systems; examples are Protocol Buffers [START_REF] Shute | F1: A distributed SQL database that scales[END_REF] and Avro schemas [START_REF]Oracle NoSQL Database[END_REF].

In summary, NoAM describes in a uniform way the features of many NoSQL systems, and so can be effectively used, as we will show later, for an intermediate representation in the design process.

Aggregate Data Model

In the context of next-generation web applications, it is useful to consider application data organized in aggregates [START_REF] Evans | Domain-Driven Design[END_REF]. Intuitively, each aggregate is a "chunk" of related data, with a complex value and a unique identifier, which is intended to represent a unit of data access and manipulation for an application. Moreover, to support scalability, aggregates should also govern data distribution, as suggested by best practices in the design of scalable applications [START_REF] Helland | Life beyond distributed transactions: an apostate's opinion[END_REF][START_REF] Evans | Domain-Driven Design[END_REF]. An important intuition in our approach is that each aggregate can be conveniently mapped to a NoAM block, which is also a unit of data access and distribution (Section 3.2). Aggregates and blocks are however distinct concepts, since they belong, respectively, to the application and the database levels.

Let us now illustrate the terminology we use to describe data at the aggregate level. An application dataset includes a number of aggregate classes, each having a distinct name. The extent of an aggregate class is a set of aggregate objects (or, simply, aggregates). Each aggregate has a complex value and an identifier (which is unique within the aggregate class the object belongs to). Complex values [START_REF] Abiteboul | Foundations of Databases[END_REF] are built using basic values (e.g., numbers and strings), references to aggregates (of the form C : id, where C is an aggregate class and id is the identifier of an aggregate), records, and collections. We assume that the complex value of each aggregate is, at the top level, a record. We also assume that, for each aggregate class, there exists a top-level field to hold a basic value as the identifier for the aggregates in that class. References are used to represent (unidirectional) relationships between aggregates.

Application Data Model

At the application level, we assume that data are modeled in a conceptual way [START_REF] Batini | Conceptual Database Design: An Entity-Relationship Approach[END_REF][START_REF] Evans | Domain-Driven Design[END_REF], using an object-based data model, in terms of entities, value objects, and relationships. An entity is a persistent object that has independent existence and is distinguished by a unique identifier. A value object is a persistent object which is mainly characterized by its value, without an own identifier.

Conceptual Modeling and Aggregate Design

In our approach, conceptual modeling is performed in a standard way. See, for example, [START_REF] Batini | Conceptual Database Design: An Entity-Relationship Approach[END_REF]. Following Domain-Driven Design (DDD [START_REF] Evans | Domain-Driven Design[END_REF]), which is a widely followed object-oriented methodology, we assume that the outcome of this activity is a conceptual UML class diagram, defining the entities, value objects, and relationships of the application (see Section 3.4). Thus, the remainder of this section focuses on aggregate design.

The design of aggregates has the goal of identifying the classes of aggregates for an application, and various approaches are possible. For example, this activity is described by DDD [START_REF] Evans | Domain-Driven Design[END_REF]. After a preliminary conceptual design phase, entities and value objects are grouped into aggregates. Each aggregate has an entity as its root, and it can also contain many value objects. Intuitively, an entity and a group of value objects are used to define an aggregate having a complex structure and value.

The relevant decisions in aggregate design involve the choice of aggregates and of their boundaries. In our approach, this activity is driven by the data access patterns of the application operations, as well as by scalability and consistency needs [START_REF] Evans | Domain-Driven Design[END_REF]. Specifically, we consider individual aggregates as the units on which atomicity must be guaranteed [START_REF] Helland | Life beyond distributed transactions: an apostate's opinion[END_REF] (with eventual consistency for update operations spanning multiple aggregates [START_REF] Pritchett | BASE: An ACID alternative[END_REF]). In general, it is indeed the case that most real applications require only operations that access individual aggregates [START_REF] Cattell | Scalable SQL and NoSQL data stores[END_REF][START_REF] Chang | Bigtable: A distributed storage system for structured data[END_REF]. Each aggregate should be large enough so as to include all the data required by a relevant data access operation. (Please note that NoSQL systems do not provide a "join" operation, and this is a main motivation for clustering each group of related application objects into an aggregate.) Furthermore, to support strong consistency (that is, atomicity) of update operations, each aggregate should include all the data involved by some integrity constraints or other forms of business rules [START_REF] Vernon | Implementing Domain-Driven Design[END_REF]. On the other hand, aggregates should be as small as possible; small aggregates reduce concurrency collisions and support performance and scalability requirements [START_REF] Vernon | Implementing Domain-Driven Design[END_REF].

Thus, aggregate design is mainly driven by data access operations. In our running example, the online game application needs to manage various collections of objects, including players, games, and rounds. Figure 1 shows a few representative application objects. (There, boxes and arrows denote objects and links between them, respectively. An object having a colored top compartment is an entity, otherwise it is a value object.) When a player connects to the application, all data on the player should be retrieved, including an overview of the games she is currently playing. Then, the player can select to continue a game, and data on the selected game should be retrieved. When a player completes a round in a game she is playing, then the game should be updated. These operations suggest that the candidate aggregate classes are players and games. Figure 1 also shows how application objects can be grouped in aggregates. (There, a closed curve denotes the boundary of an aggregate.)

As we mentioned above, aggregate design is also driven by consistency needs. Assume that the application should enforce a rule specifying that a round can be added to a game only if some condition that involves the other rounds of the game is satisfied. An individual round cannot check, alone, the above condition; therefore, it cannot be an aggregate by itself. On the other hand, the above business rule can be supported by a game (comprising, as an aggregate, its rounds).

In conclusion, the dataset for our application consists of aggregate classes Player and Game, as shown in Figures 1 and2.

Data Representation in NoAM

In our approach, we use the NoAM data model (Section 3.2) as an intermediate model between application datasets of aggregates (Section 3.3) and NoSQL databases (Section 3.1). This issue is discussed in this section and in the following Section 6.

An application dataset can be represented by a NoAM database as follows. We represent each aggregate class by means of a distinct collection, and each aggregate object by means of a block. We use the class name to name the collection, and the identifier of the aggregate as block key. The complex value of each aggregate is represented by a set of entries in the corresponding block. For example, the application dataset of Figures 1 and2 can be represented by the NoAM database shown in Figure 3. The representation of aggregates as blocks is motivated by the fact that both concepts represent a unit of data access and distribution, but at different abstraction levels. Indeed, NoSQL systems provide efficient, scalable, and consistent (i.e., atomic) operations on blocks and, in turn, this choice propagates such qualities to operations on aggregates.

In general, an application dataset can be represented by a NoAM database in several ways. The various data representations for a dataset differ in the choice of the entries used to represent the complex value of each aggregate. This section is devoted to the discussion of basic data representation strategies, which we illustrate with respect to the example described in Figure 2. Additional and more flexible data representations will be discussed in Section 6.

A simple data representation strategy, called Entry per Aggregate Object (EAO), represents each individual aggregate using a single entry. The entry key is empty. The entry value is the whole complex value of the aggregate. The data representation of the aggregates of Figure 2 according to the EAO strategy is shown in Figure 6.

Another data representation strategy, called Entry per Top-level Field (ETF), represents each aggregate by means of multiple entries, using a distinct entry for each top-level field of the complex value of the aggregate. For each top-level field f of an aggregate o, it employs an entry having as value the value of field f in the complex value of o (with values that can be complex themselves), and as key the field name f . Figure 7 shows the data representation of the aggregates of Figure 2 according to the ETF strategy.

As a comparison, we can observe that the EAO data representation uses a block with a single entry to represent the Player object having username mary, while the ETF representation needs a block with four entries, corresponding to fields username, firstName, lastName, and games. Moreover, blocks in EAO do not depend on the structure of aggregates, while blocks in ETF depend on the top-level structure of aggregates (which can be "almost fixed" within each class).

Aggregate Partitioning

The general data representation strategies introduced in the previous section can be suited in some cases, but they are often too rigid and limiting. For example, none of the above strategies leads to the data representation shown in Figure 3. The main limitation of such general data representations is that they refer only to the structure of aggregates, and do not take into account the data access patterns of the application operations. Therefore, these strategies are not usually able to support the performance of these operations. This motivates the introduction of aggregate partitioning, which we discuss in this section. We first need to introduce a preliminary notion of access path, to specify a "location" in the structure of a complex value. Intuitively, if v is a complex value and v ′ is a value (possibly complex as well) occurring in v, then the access path ap for v ′ in v represents the sequence of "steps" that should be taken to reach the component value v ′ in v. More precisely, an access path ap is a (possibly empty) sequence of access steps, ap = p 1 p 2 . . . p n , where each step p i identifies a component value in a structured value. Furthermore, if v is a complex value and ap is an access path, then ap(v) denotes the component value identified by ap in v.

For example, consider the complex value v mary of the Player aggregate having username mary shown in Figure 2. Examples of access paths for this complex value are firstName and games [0].opponent. If we apply these access paths to v mary , we access values Mary and Player:rick, respectively.

A complex value v can be represented using a set of entries, whose keys are access paths for v. Each entry is intended to represent a distinct portion of the complex value v, characterized by a location in its structure (the access path, used as entry key) and a value (the entry value). Specifically, in NoAM we represent each aggregate by means of a partition of its complex value v, that is, a set E of entries that fully cover v, without redundancy. Consider again the complex value v mary shown in Figure 2. A possible entry for v mary is the pair games[0].opponent, Player:rick . We have already applied the above intuition in Section 5. For example, the ETF data representation (shown in Figure 7) uses field names as entry keys (which are indeed a case of access paths) and field values as entry values.

Aggregate partitioning can be based on the following guidelines (which are a variant of guidelines proposed in [START_REF] Batini | Conceptual Database Design: An Entity-Relationship Approach[END_REF] in the context of logical database design):

• If an aggregate is small in size, or all or most of its data are accessed or modified together, then it should be represented by a single entry.

• Conversely, an aggregate should be partitioned in multiple entries if it is large in size and there are operations that frequently access or modify only specific portions of the aggregate.

• Two or more data elements should belong to the same entry if they are frequently accessed or modified together.

• Two or more data elements should belong to distinct entries if they are usually accessed or modified separately.

The application of the above guidelines suggests a partitioning of aggregates, which we will use to guide the representation in the target database.

For example, in our sample application, consider the operations involving games and rounds. When a player selects to continue a game, data on the selected game should be retrieved. When a player completes a round in a game she is playing, then the aggregate for the game should be updated. To support performance, it is desirable that this update should be implemented in the database just as an addition of a round to a game, rather than a complete rewrite of the whole game. Thus, data for each individual round is always read or written together. Moreover, data for the various rounds of a game are read together, but each round is written separately. Therefore, each round is a candidate to be represented by an autonomous entry. These observations lead to a data representation for games shown in Figure 3. However, apart from rounds, the remaining data for each game comprises just a few fields, which can be therefore represented together in a single entry. This further observation leads to an alternative data representation for games, shown in Figure 8.

Implementation

In this section, we show how a NoAM data representation can be implemented in a target NoSQL database. Given that NoAM generalizes the features of the various NoSQL systems, ǫ id:2345, firstPlayer:Player:mary, secondPlayer:Player:rick rounds [0] moves : . . . , comments : . . . rounds [START_REF] Abiteboul | Foundations of Databases[END_REF] moves : . . . , actions : . . . , spell : . . . while keeping their major aspects, it is rather straightforward to perform this activity. We have implementations for various NoSQL systems, including Cassandra, Couchbase, Amazon Dy-namoDB, HBase, MongoDB, Oracle NoSQL, and Redis. For the sake of space, we discuss the implementation only with respect to a single representative system for each main NoSQL categories. Moreover, with reference to the same aggregate objects of Figures 1 and2 we will sometimes show only the data for one aggregate. Similar representations can be obtained for the other aggregates of the running example.

Key-Value Store: Oracle NoSQL

Oracle NoSQL [START_REF]Oracle NoSQL Database[END_REF] is a key-value store, in which a database is a schemaless collection of keyvalue pairs, with a key-value index. Keys are structured; they are composed of a major key and a minor key. The major key is a non-empty sequence of strings. The minor key is a sequence of strings. Each element of a key is called a component of the key. On the other hand, each value is an uninterpreted binary string. A data representation D for a dataset can be implemented in Oracle NoSQL as follows. We use a key-value pair for each entry ek, ev in D. The major key is composed of the collection name C and the block key id, while the minor key is a proper coding of the entry key ek (recall that ek is an access path, which we represent using a distinct key component for each of its steps). An example of key is /Player/mary/-/firstName, where symbol / components, and symbol -separates the major key from the minor key. The value associated with this key is a representation of the entry value ev; for example, Mary. The value can be either simple or a serialization of a complex value, e.g., in JSON.

The retrieval of a block can be implemented, in an efficient and atomic way, using a single multiGet operation -this is possible because all the entries of a block share the same major key. The storage of a block can be implemented using various put operations. These multiple put operations can be executed in an atomic way -since, again, all the entries of a block share the same major key.

For example, Figures 9(a) and 9(b) show the implementation of the EAO and ETF data representations, respectively, in Oracle NoSQL. Moreover, Figure 4 shows the implementation of the data representation of Figure 3.

An implementation can be considered effective if aggregates are indeed turned into units of data access and distribution.

The effectiveness of this implementation is based on the use we make of Oracle NoSQL keys, where the major key controls distribution (sharding is based on it) and consistency (an operation involving multiple key-value pairs can be executed atomically only if the various pairs are over a same major key).

More precisely, a technical precaution is needed to guarantee atomic consistency when the selected data representation uses more than one entry per block. Consider two separate op- erations that need to update just a subset of the entries of the block for an aggregate object. Since aggregates should be units of atomicity and consistency, if these operations are requested concurrently on the same aggregate object, then the application would require that the NoSQL system identifies a concurrency collision, commits only one of the operations, and aborts the other. However, if the operations update two disjoint subsets of entries, then Oracle NoSQL is unable to identify the collision, since it has no notion of block. We support this requirement, thus providing atomicity and consistency over aggregates, by including in each update operation the access to a distinguished entry of the block for an aggregate object; in particular, this could be the entry that includes the identifier of the aggregate, or a specific "version" field.

Extensible Record Store: DynamoDB

Amazon DynamoDB [START_REF]DynamoDB[END_REF] is a NoSQL database service provided on the cloud by Amazon Web Services (AWS). DynamoDB is an extensible record store. A database is organized in tables. A table is a set of items. Each item contains one or more attributes, each with a name and a value (or a set of values). Each table designates an attribute as primary key. Items in a same table are not required to have the same set of attributes -apart from the primary key, which is the only mandatory attribute of a table. Thus, DynamoDB databases are mostly schemaless.

DynamoDB guarantees atomicity at the item level. Distribution is also operated at the item level, and controlled by a specific portion of primary keys.

The implementation of a NoAM database in DynamoDB can be based on a distinct table for each collection, and a single item for each block. The item contains a number of attributes, which can be defined from the entries of the block for the item.

We now show how to implement a NoAM data representation D in DynamoDB. Consider a block b in a collection C having block key id. According to D, one or multiple entries are used within each block. We will use all the entries of a block b to create a new item in a table for b. Specifically, we proceed as follows: (i) the collection name C is used as a DynamoBD table name; (ii) the block key id is used as a DynamoBD primary key in that table; (iii) the set of entries (key-value pairs) of a block b is used as the set of attribute name-value pairs in the item for b (a serialization of the values is used, if needed). For example, Figure 5 shows the implementation of the NoAM database of Figure 3.

The retrieval of a block, given its collection C and block key id, can be implemented by performing a single getItem operation, which retrieves the item that contains all the entries of the block. The storage of a block can be implemented using a putItem operation, to save all the entries of the block, in an atomic way. It is worth noting that, using operation getItem, it is also possible to retrieve a subset of the entries of a block. Similarly, using operation updateItem, it is also possible to update just a subset of the entries of a block, in an atomic way. This implementation is also effective, since DynamoDB controls distribution and atomicity with reference to items.

Document Store: MongoDB

MongoDB [START_REF]MongoDB[END_REF] is an open-source, document-oriented data store. In MongoDB, a database is made of collections of documents. Each document is a structured document, that is, a complex value, a set of field-value pairs, which can comprise simple values, lists, and even nested documents. A main document is a top-level document with a unique identifier, represented by a special field id. Documents are schemaless, as each document can have its own attributes, defined at runtime. Specifically, MongoDB documents are based on BSON (Binary JSON), a variant of the popular JSON format.

According to our approach, a natural implementation for a NoAM database in MongoDB can be based on a distinct MongoDB collection for each collection of blocks, and a single main document for each block. The document for a block b can be defined as a suitable JSON/BSON serialization of the complex value of the entries in b, plus a special field to store the block key id of b, as required by MongoDB, { id:id}.

Specifically, with reference to a NoAM data representation D, consider a block b in a collection C having block key id. If b contains just an entry e, then the documento for b is just a serialization of e. Otherwise, if b contains multiple entries, we use all the entries in block b to create a new document. Specifically, we proceed by building a document d for b as follows: (i) the collection name C is used as the MongoDB collection name; (ii) the block key id is used for the special top-level id field { id:id} of d; (iii) then, each entry in the block b is used to fill a (possibly nested) field of document d. See Figure 10.

The retrieval of a block, given its collection C and key id, can be implemented by per-

¡ ¡¡ ¡ ¡¢ ¡ £¡ ¡ £¢ ¡ ¤¡ ¡ ¤¢ ¡ ¥¡ ¡ ¥¢ ¡ ¦¡ ¡ ¦¢ ¡ ¢¡ £ ¤ ¦ ¨£ § ¥¤ §¦ £¤¨¤¢ § ¢£¤ Game Retrieval © (a) Game Retrieval ! ! " " # # $ $ ! " $ % !& #" &$ !"% " & !"
Round Addition forming a find operation, to retrieve the main document that represents all the block (with its entries). The storage of a block can be implemented using an insert operation, which saves the whole block (with its entries), in an atomic way. It is worth noting that, using other MongoDB operations, it is also possible to access and update just a subset of the entries of a block, in an atomic way. An alternative implementation for MongoDB is as follows. Each block b is represented, again, as a main document for b, but using a distinct top-level field-value pair for each entry in the NoAM data representation. In particular, for each entry (ek, ev), the document for b contains a top-level field whose name is a coding for the entry key (access path) ek, and whose value is either an atomic value or an embedded document that serializes the entry value ev. For example, according to this implementation, the data representation of Figure 3 leads to the result shown in Figure 11.

Experiments

We will now discuss a case study of NoSQL database design, with reference to the running example introduced in Section 2. For the sake of simplicity, we just focus on the representation and management of aggregate objects for games.

Data for each game include a few scalar fields and a collection of rounds. The important operations over games are: (1) the retrieval of a game, which should read all the data concerning the game; and (2) the addition of a round to a game.

Assume that, to manage games, we have chosen a key-value store as the target system. The candidate data representations are: (i) using a single entry for each game (as shown in Figure 6, in the following called EAO); (ii) splitting the data for each game in a group of entries, one for each round, and including all the remaining scalar fields in a separate entry (as shown in Figure 8, called ROUNDS).

We expect that the first operation (retrieval of a game) performs better in EAO, since it needs to read just a key-value pair, while the second one (addition of a round to a game) is favored by ROUNDS, which does not require to rewrite the whole game.

We ran a number of experiments to compare the above data representations in situations of different application workloads. Each game has, on average, a dozen rounds, for a total of about 8KB per game. At each run, we simulated the following workloads: (a) game retrievals only (in random order); (b) round additions only (to random games); and (c) a mixed workload, with game retrieval and round addition operations, with a read/write ratio of 50/50. We ran the experiments using different database sizes, and measured the running time required by the workloads. The target system was Oracle NoSQL, deployed over Amazon AWS on a cluster of four EC2 servers.

The results are shown in Figure 12. Database sizes are in gigabytes, timings are in milliseconds, and points denote the average running time of a single operation. The experiments confirm the intuition that the retrieval of games (Figure 12(a)) is always favored by the EAO data representation, for any database size. On the other hand, the addition of a round to an existing game (Figure 12(b)) is favored by the ROUNDS data representation. Finally, the experiments over the mixed workload (Figure 12(c)) show a general advantage of ROUNDS over EAO, which however decreases as the database size increases. Overall, it turns out that the ROUNDS data representation is preferable.

We also performed other experiments on a data representation that does not conform to the design guidelines proposed in this paper. Specifically, a data representation that divides the rounds of a game into independent key-value pairs, rather than keeping them together in a same block, as suggested by our approach. In this case, the performance of the various operations worsens by at least an order of magnitude. Moreover, with this data representation it is not possible to update a game in an atomic way.

Overall, these experiments show that: (i) the design of NoSQL databases should be done with care as it affects considerably the performance and consistency of data access operations, and (ii) our methodology provides an effective tool for choosing among different alternatives.

Related Work

To the best of our knowledge, this is the first proposal of a general, system-independent approach to the design of NoSQL databases. Indeed, although several authors have observed that the development of methodologies and tools supporting NoSQL database design is demanding [START_REF] Atzeni | The relational model is dead, SQL is dead, and I don't feel so good myself[END_REF][START_REF] Badia | A call to arms: revisiting database design[END_REF][START_REF] Mohan | History repeats itself: sensible and NonsenSQL aspects of the NoSQL hoopla[END_REF], this topic has been not explored yet from a general point of view. The only examples are some on-line papers, usually published in blogs of practitioners, that discuss best practices and guidelines for modeling NoSQL databases, such as [START_REF] Katsov | NoSQL data modeling techniques[END_REF][START_REF] Olier | Database design using key-value tables[END_REF]. Some papers are suited only for specific systems, e.g., [START_REF] Rathore | HBase: On designing schemas for column-oriented datastores[END_REF][START_REF] Hamrah | Data modeling at scale[END_REF][START_REF] Patel | Cassandra data modeling best practices[END_REF]. None of them tackles the problem from a general perspective, as we do in this paper.

Our approach takes inspiration from Domain Driven Design [START_REF] Evans | Domain-Driven Design[END_REF], a widely followed objectoriented approach that includes a notion of aggregate. Also [START_REF] Helland | Life beyond distributed transactions: an apostate's opinion[END_REF] advocates the use of aggregates (there called entities) as units of distribution and consistency. We also propose, for efficiency purposes, to partition aggregates into smaller units of data access and manipulation.

In [START_REF] Baker | Megastore: Providing scalable, highly available storage for interactive services[END_REF] the authors propose entity groups, a set of entities that, similarly to our aggregates, can be manipulated in an atomic way. They also describe a specific mapping of entity groups to Bigtable [START_REF] Chang | Bigtable: A distributed storage system for structured data[END_REF]. Our approach is based on a more abstract database model, NoAM, and is system independent, as it is targeted to a wide class of NoSQL systems.

In [START_REF] Atzeni | The relational model is dead, SQL is dead, and I don't feel so good myself[END_REF] it has been observed that the availability of a high-level representation of the data remains a fundamental tool for developers and users, since it makes understanding, managing, accessing, and integrating information sources much easier, independently of the technologies used. The present paper responds to these needs.

Conclusion

In this paper, we have proposed a comprehensive methodology for the design of NoSQL databases. The approach relies on an aggregate-oriented view of application data, an intermediate systemindependent data model for NoSQL datastores, and finally an implementation activity that takes into account the features of specific systems.

Our approach is targeted to the typical applications that can benefit from NoSQL technologies. Therefore we aimed at supporting the typical requirements of scalability (aggregates are units of distribution), consistency (aggregates are units of atomic consistency), and performance (by allowing data access to specific portions of aggregates).

Currently, we are developing a tool that provides a common programming interface towards different NoSQL systems, to access them in a unified way, in the spirit of SOS [START_REF] Atzeni | Uniform access to non-relational database systems: The SOS platform[END_REF]. The tool uses an internal representation based on NoAM, and it also supports the design approach presented in this paper. We believe that database designers can greatly benefit from such a tool, as we envision the use of the framework to tune the choice of the data representation in a flexible way, as well as to select the most suitable target NoSQL system.

Figure 1 :

 1 Figure 1: Sample application objects

Figure 4 :

 4 Figure 4: Implementation in Oracle NoSQL for the sample database of Figure 3

Figure 5 :

 5 Figure 5: Implementation in DynamoDB for the sample database of Figure 3 (abridged)

Figure 8 :

 8 Figure 8: An alternative data representation for games (ROUNDS)

Figure 9 :

 9 Figure 9: Implementation in Oracle NoSQL

Figure 11 :

 11 Figure 11: Alternative implementation in MongoDB

Figure 12 :

 12 Figure 12: Experimental results

Game:2345, opponent : Player:rick games[1] game : Game:2611, opponent : Player:ann

	Player
		username	"mary"
		firstName	"Mary"
	mary	lastName	"Wilson"
	games[0] username firstName score game : rick "rick" "Ricky" 42 lastName "Doe"	Game 2345	id firstPlayer secondPlayer rounds[0] rounds[1]	2345 Player:mary Player:rick moves : ..., comments : ... moves : ..., actions : ..., spell : ...
		games[0]	game : Game:2345, opponent : Player:mary
		games[1]	game : Game:7425, opponent : Player:ann
		games[2]	game : Game:1241, opponent : Player:johnny
			Figure 3: A sample database in the abstract model
			key (/major/key/-/minor/key)	value
			Player/mary/-/username	"mary"
			Player/mary/-/firstName	"Mary"
			Player/mary/-/lastName	"Wilson"
			Player/mary/-/games[0]	{game: "Game:2345", opponent: "Player:rick"}
			Player/mary/-/games[1]	{game: "

Game:2611", opponent: "Player:ann"}

	Player/rick/-/username	"rick"
	Player/rick/-/firstName	"Ricky"
	Player/rick/-/lastName	"Doe"
	Player/rick/-/score	42
	Player/rick/-/games[0]


Maxime Colmant

Mascha Kurpicz

Pascal Felber

Loïc Huertas

Romain Rouvoy

Anita Sobe

BitWatts: A Process-level Power Monitoring Middleware

à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

BitWatts


Ludovic Goudenège
email: goudenege@math.cnrs.fr

Luigi Manca
email: luigi.manca@u-pem.fr

Asymptotic properties of stochastic Cahn-Hilliard equation with singular nonlinearity and degenerate noise

Keywords: AMS 2000 subject classifications. 60H15, 60H07, 37L40 ergodicity, Cahn-Hilliard, stochastic partial differential equations, singular nonlinearity, degenerate noise

come

Introduction and main results

The Cahn-Hilliard-Cook equation is a model to describe phase separation in a binary alloy (see [START_REF] Cahn | On spinodal decomposition[END_REF], [START_REF] Cahn | Free energy of a nonuniform system. i. interfacial free energy[END_REF] and [START_REF] Cahn | Spinodal decomposition: a reprise[END_REF]) in the presence of thermal fluctuations (see [START_REF] Cook | Brownian motion in spinodal decomposition[END_REF] and [START_REF] Langer | Theory of spinodal decomposition in alloys[END_REF]). It takes the form

     ∂ t u = - 1 2 ∆ (∆u -ψ(u)) + ξ, on Ω ⊂ R n , ∇u • ν = 0 = ∇(∆u -ψ(u)) • ν, on ∂Ω, (0.1)
where t denotes the time variable and ∆ is the Laplace operator. Also u ∈ [-1, 1] represents the ratio between the two species and the noise term ξ accounts for the thermal fluctuations. The nonlinear term ψ has the double-logarithmic form

ψ : u → θ 2 ln 1 + u 1 -u -θ c u, (0.2)
where θ and θ c are temperatures with θ < θ c . The unknown u represents the concentration of one specie with respect to the second one. In the deterministic case, the equation is obtained as a gradient in H -1 (Ω) of the free energy

E(u) = Ω 1 2 |∇u| 2 + Ψ(u) dx
where Ψ is an antiderivative of ψ. Since the gradient is taken in H -1 (Ω), a fourth order equation is obtained. A key point is that the average Ω u dx is conserved.

The deterministic equation where ψ is replaced by a polynomial function has first been studied (see [START_REF] Cahn | Free energy of a nonuniform system. i. interfacial free energy[END_REF], [START_REF] Langer | Theory of spinodal decomposition in alloys[END_REF] and [START_REF] Novick-Cohen | Nonlinear aspects of the Cahn-Hilliard equation[END_REF]). The drawback of a polynomial nonlinearity is that the solution is not constrained to remain in the physically relevant interval [-1, 1]. Singular nonlinear terms, such as the logarithmic nonlinearity considered here, remedy this problem. Such non smooth functions ψ have also been considered (see [START_REF] Blowey | The Cahn-Hilliard gradient theory for phase separation with nonsmooth free energy. I. Mathematical analysis[END_REF] and [START_REF] Debussche | On the Cahn-Hilliard equation with a logarithmic free energy[END_REF]).

Phase separation has been analyzed thanks to this model: see for example the survey [START_REF] Novick-Cohen | The Cahn-Hilliard equation: mathematical and modeling perspectives[END_REF], and the references therein, or others recent results on spinodal decomposition and nucleation in [START_REF] Bates | The dynamics of nucleation for the Cahn-Hilliard equation[END_REF][START_REF] Blömker | Second phase spinodal decomposition for the Cahn-Hilliard-Cook equation[END_REF][START_REF] Grant | Spinodal decomposition for the Cahn-Hilliard equation[END_REF][START_REF] Maier-Paape | Spinodal decomposition for the Cahn-Hilliard equation in higher dimensions. I. Probability and wavelength estimate[END_REF][START_REF] Maier-Paape | Spinodal decomposition for the Cahn-Hilliard equation in higher dimensions: nonlinear dynamics[END_REF][START_REF] Sander | Monte Carlo simulations for spinodal decomposition[END_REF][START_REF] Sander | Unexpectedly linear behavior for the Cahn-Hilliard equation[END_REF][START_REF] Wanner | Maximum norms of random sums and transient pattern formation[END_REF].

The noise term accounts for thermal fluctuations and is a commonly accepted model now. This stochastic equation has also been first studied in the case of a polynomial nonlinearity (see [START_REF] Blömker | Spinodal decomposition for the Cahn-Hilliard-Cook equation[END_REF][START_REF] Blömker | Phase separation in stochastic Cahn-Hilliard models[END_REF][START_REF] Cardon-Weber | Cahn-Hilliard stochastic equation: existence of the solution and of its density[END_REF][START_REF] Cardon-Weber | Cahn-Hilliard stochastic equation: strict positivity of the density[END_REF][START_REF] Da Prato | Stochastic Cahn-Hilliard equation[END_REF][START_REF] Elezović | On the stochastic Cahn-Hilliard equation[END_REF]). Again, with a polynomial nonlinear term the solutions do not remain in [-1, 1] in general. It is even worse in the presence of noise since any solution leaves this interval immediately with positive probability.

Since the Cahn-Hilliard equation is a gradient flow in H -1 (Ω), it is natural to consider a noise which is a cylindrical Wiener process in this space (i.e. the spatial derivative of a space-time white noise). Another justification of this choice for the noise is that the stochastic equation has still a gradient structure and an explicit invariant measure is known.

Unfortunately, if the dimension n is larger than 1, it is not difficult to see that with such a noise, even for the linear equation, the solutions have negative spatial regularity and it does not seem possible to treat the nonlinearity. Finally, it is not expected that the singularity of logarithmic nonlinear term is strong enough to prevent the solution from exiting the interval [-1, 1]. It has been rigorously proved in [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF] that a nonlinear term of the form ln u is not strong enough to ensure that solutions remain positive and a reflection measure has to be added.

The stochastic heat equation with reflection, i.e. when the fourth order operator is replaced by the Laplace operator, is a model for the evolution of random interfaces near a hard wall. It has been extensively studied in the literature (see [START_REF] Dalang | Hitting properties of parabolic s.p.d.e.'s with reflection[END_REF], [START_REF] Funaki | Fluctuations for ∇φ interface model on a wall[END_REF], [START_REF] Giacomin | Equilibrium fluctuations for ∇φ interface model[END_REF], [30] [35], [START_REF] Zambotti | Integration by parts on δ-Bessel bridges, δ > 3 and related SPDEs[END_REF] and [START_REF] Zambotti | Fluctuations for a ∇φ interface model with repulsion from a wall[END_REF]). The two-walls case has been treated in [START_REF] Otobe | Stochastic partial differential equations with two reflecting walls[END_REF]. Essential tools in these articles are the comparison principle and the fact that the underlying Dirichlet form is symmetric so that the invariant measure is known explicitly.

However, no comparison principle holds for fourth order equations and new techniques have to be developed. Equation (0.1) has been studied in [START_REF] Debussche | Conservative stochastic Cahn-Hilliard equation with reflection[END_REF] with a single reflection and when no nonlinear term is taken into account. The reflection is introduced to enforce positivity of the solution. It has been shown in [START_REF] Zambotti | Fluctuations for a conservative interface model on a wall[END_REF] that a conservative random interface model close to one hard wall gives rise to this fourth-order stochastic partial differential equation with one reflection. Various techniques have been introduced to overcome the lack of comparison principle. Moreover, as in the second order case, an integration by part formula for the invariant measure has been derived. Then, in [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF], a singular nonlinearity of the form u -α or ln u has been considered. Existence and uniqueness of solutions have been obtained and using the integration by parts formula as in [START_REF] Zambotti | Integration by parts on δ-Bessel bridges, δ > 3 and related SPDEs[END_REF], it has been proved that the reflection measure vanishes if and only if α ≥ 3. In particular, as mentioned above, for a logarithmic nonlinearity, the reflection is active. For a double singular nonlinearity of the form (0.2), thanks to a delicate a priori estimate on the L 1 norm of the nonlinearity, the authors have obtained uniqueness and existence.

In this article, we do not consider that the noise is a cylindrical Wiener process in H -1 . In this case the equation has not the desired gradient structure and the technics developed in [START_REF] Debussche | Stochastic Cahn-Hilliard equation with double singular nonlinearities and two reflections[END_REF], [START_REF] Debussche | Conservative stochastic Cahn-Hilliard equation with reflection[END_REF] and [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF] are not any more valid. However the choice of smooth-enough space-time noise permits to work with an Itô's formula. Following the approach of [START_REF] Debussche | Stochastic Cahn-Hilliard equation with double singular nonlinearities and two reflections[END_REF], we shall consider the problem with a polynomial approximation of the nonlinearity ψ. We obtain a priori estimates on the approximated solutions which are sufficient to prove tightness.

Unfortunately, due to the degenerate noise, we are not able to show that the approximated solutions are tight in C([0, T ] × [0, 1]; [-1, 1]) and, as consequence, we are not able to characterise the limit process X(t, x) as a solution of some stochastic partial differential equation.

Despite of this, we discuss about the asymptotic properties of the transition semi-group P t associated to this process. The main result of the paper consist in Theorems (3.1) and (3.2), where we show that P t is ergodic and admits a unique invariant measure. The ergodicity result is obtained by assuming that the noise acts on the space spanned by the first eigenvectors of the laplacian (see (3.2), (3.3)) ; this property is sometimes called essentially elliptic (see [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF], [START_REF] Hairer | A theory of hypoellipticity and unique ergodicity for semilinear stochastic PDEs[END_REF]).

The paper is organised as follows : in the next section we introduce notations and the approximated problem ; in section 2 we obtain some a priori estimate and the convergence of the approximated process to the limit process as well as the associated transition semigroup ; in section 3 we discuss about the ergodicity properties of the transition semigroup.

Preliminaries

We denote by •, • the scalar product in L 2 (0, 1); A is the realization in L 2 (0, 1) of the Laplace operator with Neumann boundary condition, i.e.

D(A) = Domain of A = {h ∈ W 2,2 (0, 1) : h (0) = h (1) = 0}
where W 2,2 (0, 1) is the classical Sobolev space. Remark that A is self-adjoint on L 2 (0, 1) and we have a complete orthonormal system of eigenvectors (e i ) i∈N in L 2 (0, 1) for the eigenvalues (λ i ) i∈N . We denote by h the mean of h ∈ L 2 (0, 1)

h = 1 0 h(θ)dθ.
We remark that A is invertible on the space of functions with 0 average. In general, we define

(-A) -1 h = (-A) -1 (h -h) + h.
For γ ∈ R, we define (-A) γ by classical interpolation. We set V γ := D((-A) γ/2 ). It is endowed with the classical seminorm and norm

|h| γ = +∞ i=1 (-λ i ) γ h 2 i 1/2 , h γ = |h| 2 γ + h2 1/2 , for h = i∈N h i e i . | • | γ is associated to the scalar product (•, •) γ . To lighten notations, we set (•, •) := (•, •) -1 and H := V -1 .
The average can be defined in any V γ by h = (h, e 0 ). It plays an important role and we often work with functions with a fixed average c ∈ R. We define

H c = {h ∈ H : h = c} for all c ∈ R.
We denote by B b (H c ) the space of all Borel bounded functions The covariance operator of the noise is an operator B such that

Tr γ := Tr √ B(-A) γ √ B *
is finite for some γ ∈ R which will be precise after. Moreover we assume √ Be 0 = 0 in order to ensure the conservation of average.

For λ ∈ R, we define:

f (u) :=                +∞, for all u ≤ -1, ln 1 -u 1 + u + λu, for all u ∈ (-1, 1), -∞, for all u ≥ 1,
and the following antiderivative F of -f :

F (u) = (1 + u) ln(1 + u) + (1 -u) ln(1 -u) - λ 2 u 2 , for all u ∈ (-1, 1). Let X(•, •) stand for a function on [0, T ] × [0, 1]
. With these notations, we rewrite (0.1) in the abstract form:

             dX = - 1 2 A (AX + f (X) + η --η + ) dt + √ B dW, (1 + X), η -O T = (1 -X), η + O T = 0, X(0, •) = x for x ∈ H, (1.1)
where W is a cylindrical Wiener process on L 2 (0, 1) and

v, ζ O T = [0,T ]×[0,1] v dζ.
The equation 1.1 is characterized by the two reflection measures η ± . They act as a force to prevent the solution from leaving the physical domain [-1, 1]. They appears naturally because the logarithmic nonlinearity is not strong enough. It can also be seen as a Lagrange multiplier for the condition "X(t, x) ∈ [-1, 1] for all t > 0". This interpretation is strongly linked to the contact conditions (1 + X), η -O T = (1 -X), η + O T = 0. In the white noise case studied in [START_REF] Debussche | Stochastic Cahn-Hilliard equation with double singular nonlinearities and two reflections[END_REF], the stationary solution has enough regularity to obtain a L 1 (O T ) estimate on f (X). This estimates permits to give a sense to

T 0 1 0 f (X(t, θ))Ah(θ)dtdθ since Ah ∈ L ∞ (O T ).
Uniqueness can be proved under a nice definition of the weak solution as in [START_REF] Debussche | Stochastic Cahn-Hilliard equation with double singular nonlinearities and two reflections[END_REF].

The solution of the linear equation with initial data x ∈ H is given by

Z(t, •, x) = e -tA 2 /2 x + t 0 e -(t-s)A 2 /2 √ B dW s .
As easily seen this process is in C([0, +∞[; H) (see [START_REF] Da Prato | Stochastic equations in infinite dimensions[END_REF]). In particular, the mean of Z is constant and the law of the process Z is the Gaussian measure:

Z(t, •, x) ∼ N e -tA 2 /2 x, Q t , Q t = t 0 √ B * e -sA 2 /2 e -sA 2 /2 √ B ds = √ B * (-A) -1 (I -e -tA 2 ) √ B.
If we let t → +∞, the law of Z(t, •, x) converges to the Gaussian measure on L 2 :

µ c := N (ce 0 , √ B(-A) -1 √ B *
), where c = x.

In order to solve equation (1.1), we use polynomial approximations of this equation. We denote by {f n } n∈N the sequence of polynomial functions which converges to the function f on (-1, 1), defined for n ∈ N by:

f n (u) = -2 n k=0 u 2k+1 (2k + 1)
+ λu, for all u ∈ R.

We also use in a crucial way that u → f n (u) -λu is monotone non-increasing below.

Then for n ∈ N, we study for the following polynomial approximation of (1.1) with an initial condition x ∈ H:

     dX n + 1 2 (A 2 X n + Af n (X n ))dt = √ B dW, X n (0, •) = x. (1.2)
This equation has been studied in [START_REF] Da Prato | Stochastic Cahn-Hilliard equation[END_REF] in the case B = I. The results generalize immediately and it can be proved that for any x ∈ H, there exists a unique solution

X n (•, •) a.s. in C([0, T ]; H) ∩ L 2n+2 ((0, T ) × (0, 1)).
It is a solution in the mild or weak sense. Moreover the average of X n (t, •) does not depend on t.

For each c ∈ R, (1.2) defines a transition semigroup (P n,c t ) t≥0 :

P n,c t φ(x) = E[φ(X n (t, •))], t ≥ 0, x ∈ H c , φ ∈ B b (H c ), n ∈ N.
Existence of an invariant measure can be proved as in [START_REF] Da Prato | Stochastic Cahn-Hilliard equation[END_REF]. In all the article, C denotes a constant which may depend on parameters and its value may change from one line to another.

A priori estimates in Hilbert spaces and tightness

In this section we prove the tightness of the solutions of approximated equations, and obtain a limit transition semi-group. Fix -1 < c < 1 and x an initial data in H c . Now consider the unique solution of (1.2) denoted X n in H c with initial data x. We are going to prove that the laws of (X n ) n∈N are tight in some suitable space. First, we prove a result which only needs the assumption

Tr -1 < +∞. Proposition 2.1. Suppose Tr -1 < +∞. The laws of (X n ) n∈N are tight in L ∞ ([0, T ]; V -1 ) ∩ L 2 ([0, T ]; V 1
), and we have

E T 0 |X n (t)| 2 1 dt ≤ |x| 2 -1 + T Q c (λ), (2.1)
where Q c (λ) is a polynomial.

Proof : Applying Itô formula to |X n (t)| 2 -1 , we obtain |X n (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt + 2 O T n k=0 (X n ) 2k+2 2k + 1 dsdθ + c O T λX n dsdθ = 2 T 0 (X n (t), √ B dW t ) + T Tr -1 + O T λ(X n ) 2 dsdθ + 2c O T n k=0 (X n ) 2k+1 (2k + 1) dsdθ
Using Hölder's inequality, we have

n k=0 c 1 0 (X n (t)) 2k+1 2k + 1 dθ ≤ n k=0 c 2k + 1 1 0 (X n (t)) 2k+2 dθ 2k+1/2k+2 ≤ n k=0 1 2k + 2 1 0 (X n (t)) 2k+2 dθ + c 2k+2 (2k + 1)(2k + 2)
.

And since

n k=0 1 0 (X n (t)) 2k+2 2k + 1 dθ - n k=0 1 0 (X n (t)) 2k+2 2k + 2 dθ = n k=0 1 0 (X n (t)) 2k+2 (2k + 1)(2k + 2) dθ,
we obtain

|X n (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt + 2 O T n k=0 (X n (t)) 2k+2 (2k + 1)(2k + 2) dtdθ + c O T λX n (t) dtdθ ≤ 2 T 0 (X n (t), √ B dW t ) + T Tr -1 + O T λ(X n (t)) 2 dtdθ + 2T n k=0 c 2k+2 (2k + 1)(2k + 2)
.

Using X n (t) = c for all t ≥ 0, we obtain

|X n c (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt + c 2 λT + O T (X n (t)) 4 6 dtdθ + (1 -λ) T 0 |X n (t)| 2 0 dt + O T 2 n k=2 (X n (t)) 2k+2 (2k + 1)(2k + 2) dtdθ (2.2) ≤ 2 T 0 (X n (t), √ B dW t ) + T Tr -1 + 2T n k=0 c 2k+2 (2k + 1)(2k + 2)
.

Remark that

y 4 6 + (1 -λ)y 2 + 3 2 (1 -λ) 2 ≥ 0,
for any real number y. Let y = X n (t) and integrate on O T , it follows that

O T (X n (t)) 4 6 dtdθ + (1 -λ) T 0 |X n (t)| 2 0 dt + 3 2 T (1 -λ) 2 ≥ 0. (2.3)
Combining (2.2) and (2.3), we obtain

|Xc n (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt + O T 2 n k=2 (X n (t)) 2k+2 (2k + 1)(2k + 2) dtdθ ≤ 2 T 0 (X n (t), √ B dW t ) + T Tr -1 + 3 2 T (1 -λ) 2 -c 2 λT + 2T n k=0 c 2k+2 (2k + 1)(2k + 2)
.

Or simply

|X n (T )| 2 -1 -|Xn(0)| 2 -1 + T 0 |X n (t)| 2 1 dt ≤ 2 T 0 (X n (t), √ B dW t ) + T Tr -1 + 3 2 (1 -λ) 2 -c 2 λ + F (c) .
Remark that for all c ∈ (-1, 1) the polynomial function

P c : λ → 3 2 (1 -λ) 2 -c 2 λ + F (c
) is always nonnegative. Indeed, if we compute its classical discriminant, we find

∆ Pc = (c 2 + 3) 2 -6 3 2 + F (c) = c 4 + 6c 2 + 9 -9 -12 +∞ k=0 c 2k+2 (2k + 1)(2k + 2) = -12 +∞ k=2 c 2k+2 (2k + 1)(2k + 2) ≤ 0.
So the minimum of P c is attained in λ * = c 2 3 + 1 such that

P c (λ * ) = 2 +∞ k=2 c 2k+2 (2k + 1)(2k + 2) ≥ 0.
Denote Q c (λ) = Tr -1 + P c (λ). Using Poincaré's inequality and taking the expectation, we obtain

E |X n (T )| 2 -1 -|Xc n (0)| 2 -1 + π 4 T 0 |X n (t)| 2 -1 dt ≤ T Q c (λ).
And the Gronwall lemma implies for all t ∈ [0, T ]

E |X n (t)| 2 -1 ≤ E |X n (0)| 2 -1 - Q c (λ) π 4 exp(-π 4 t) + Q c (λ) π 4 .
Under our assumption on the trace class property of the operator √ B, there there exists a constant C such that

E   T 0 (X n (t), √ B dW t ) 2   = E T 0 | QB * X n (t)| 2 -1 dt ≤ C E T 0 |X n (t)| 2 -1 dt .
We set

ϕ n = |X n (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt -T Q c (λ) - O T f n k (X n (t)) (X n (t) -c) dtdθ such that M 2 P(|ϕ n | ≥ M ) ≤ E φ 2 n ≤ E   2 T 0 (X n (t), √ B dW t ) 2   ≤ C E T 0 |X n c (t)| 2 -1 dt ≤ C E |X n c (0)| 2 -1 - Q c (λ) π 4 1 -exp(-π 4 T ) + T Q c (λ) .
we obtain

|X n (T )| 2 -1 -|X n (0)| 2 -1 + T 0 |X n (t)| 2 1 dt ≤ 2 T 0 (X n (t), √ B dW t ) + T Q c (λ),
giving the boundedness of expectation in

L 2 ([0, T ]; V 1 ) E T 0 |X n (t)| 2 1 dt ≤ E |X n (0)| 2 -1 + T Q c (λ).
Using Poincaré's inequality, and taking the expectation, we obtain

E |X n (T )| 2 -1 + π 4 E T 0 |X n (t)| 2 -1 dt ≤ E |X n (0)| 2 -1 + T Q c (λ).
Using Gronwall lemma implies for all t ∈ [0, T ]

E |X n (t)| 2 -1 ≤ E |X n (0)| 2 -1 - Q c (λ) π 4 exp(-π 4 t) + Q c (λ) π 4 ,
giving the desired boundedness of expectation in L ∞ ([0, T ];

V -1 ) ∩ L 2 ([0, T ]; V 1 ).
Proposition 2.2. Suppose x ∈ V 0 and Tr 0 < +∞. Then the laws of (X n ) n∈N are tight in L 2 ([0, T ]; V 2 ) ∩ L ∞ ([0, T ]; V 0 ), and we have

2 O T (∇X n (t, θ)) 2 n k=0 (X n (t, θ)) 2k dtdθ ≤ 2 T 0 √ B * X n (t), dW t + |x| 2 0 + T Tr 0 .
Proof : Applying Ito formula to |X n (t)| 2 0 , we obtain

|X n (T )| 2 0 -|X n (0)| 2 0 + T 0 |X n (t)| 2 2 dt + 2 O T ∇X n (t) n k=0 ∇((X n (t)) 2k+1 ) 2k + 1 dtdθ = -λ O T (∇X n ) 2 dsdθ + 2 T 0 X n (t), √ B dW t + T Tr 0 = |X n (T )| 2 0 -|X n (0)| 2 0 + T 0 |X n (t)| 2 2 dt + 4 O T (∇X n (t)) 2 n k=0 (X n (t)) 2k dtdθ.
Eliminating the positive terms, we obtain the desired estimation. Moreover taking the expectation, we obtain

E T 0 |X n (t)| 2 2 dt ≤ E |X n (0)| 2 0 + T Tr 0 .
Using Poincaré's inequality, taking the expectation, and using Gronwall lemma implies for all t ∈ [0, T ]

E |X n (t)| 2 0 ≤ E |X n (0)| 2 0 - Tr 0 π 4 exp(-π 4 t) + Tr 0 π 4 .
By Proposition 2.1 and classical diagonalization procedure, we obtain Proposition 2.3. For all c ∈ (-1, 1), there exists a transition semi-group P c t , t ≥ 0 on B c (H) and a subsequence {n k } such that P n k ,c t ϕ(x) → P c t ϕ(x) as n k → ∞, for all ϕ ∈ B c (H), x ∈ H, t ≥ 0.

Ergodicity properties

Existence of an invariant measure follows by a classical argument of compactness and by the estimate

|X n (t, x) -X n (t, y)| -1 ≤ e λt x -y -1 . (3.1)
which holds any x, y ∈ H c , t > 0.

Theorem 3.1. For any c ∈ (-1, 1) there exists an invariant measure for the semigroup P c t , t ≥ 0.

Proof. Fix c ∈ (-1, 1). By (2.1) and by the Krylov-Bogoliubov criterion, for any n ∈ N there exists an invariant measure for the transition semigroup P c,n , t ≥ 0. Let ν be as a weak * limit of the sequence {ν n }. By using (3.1) and the thightness of ν n it is strightforward to verify that ν is invariant for P t .

In order to show uniqueness of such invariant measure, we shall show (under some suitable assumption on the noise, see (3.2)) that its transition semigroup P c t enjoys the asymptotic strong Feller property and it is topologically irreducible. We recall that since the noise in degenerate, we are not able to use the same techniques of [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF]; in particular, the Bismut-Elworthy formula does not apply, and we are not able to show that the semigroup P c t is strong Feller. Asymptotic strong Feller property was introduced in [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF] in order to study ergodicity properties of a 2D Navier-Stokes equation perturbed by a very degenerate noise. The exact definition can be found in [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF]Definition 3.8]. Here we consider the property in the following form, which shall be sufficient for our pourpose: Proposition 3.1 (Proposition 3.12 in [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF]). Let t n and δ n be two positive sequences with {t n } nondecreasing and {δ n } converging to zero. A semigroup P t on a Hilbert space H is asymptotically strong Feller if, for all ϕ : H → R with |ϕ| ∞ and |∇ϕ| ∞ finite,

|∇P t ϕ(x)| ≤ C( x H )(|ϕ| ∞ + δ n |∇ϕ| ∞ )
for all n, where C : R + → R + is a fixed nondecrasing function.

Unfortunately, we are not able to show that the semigroup P c t is differentiable (in the case of a white noise perturbation the semigroup is differentiable, and the strong Feller property holds, see [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF]). Also for the semigroup P c,n t , associated to the approximation (1.2) we are not able to show its differentiability. However, we shall use the following variation of the property Proposition 3.2. A semigroup P t on a Hilbert space H is asymptotically strong Feller if there exist two constant C, δ > 0 such that for all ϕ : H → R with |ϕ| ∞ and |∇ϕ| ∞ finite,

|P t ϕ(x) -P t ϕ(y)| ≤ C(|x| -1 ∨ |y| -1 )(|ϕ| ∞ + e -δt |∇ϕ| ∞ )|x -y| H .
This proposition can be proved with the same argument used to prove Proposition 3.12 in [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF]. The right-hand side is clearly derived by the previous proposition, setting δ n = e -δt . The only modification consists in the left-side part, where no assumptions on differentiability of P t ϕ are needed.

The main assumption of this section is

B = ∞ k=1 b k •, e k e k (3.2)
where b k > 0 for k ∈ {1, . . . , N } and

1 2 (N + 1) 2 -λ > 0. (3.3)
In other words, we assume that for a sufficiently large N , span{e 0 , . . . , e N } ⊂ range(B). This kind of setting is known as essentially elliptic (see [START_REF] Goudenège | Stochastic Cahn-Hilliard equation with singular nonlinearity and reflection[END_REF]). We think that more degenerate noises can be considered in order to have asymptotic strong Feller property, and this shall be the objet of a forthcoming paper. The importance of the asymptotic strong Feller property is that in this case any two distinct ergodic invariant measures have disjoint topological support (see Theorem 3.16 in [START_REF] Hairer | Ergodicity of the 2D Navier-Stokes equations with degenerate stochastic forcing[END_REF]). According to [START_REF] Hairer | A theory of hypoellipticity and unique ergodicity for semilinear stochastic PDEs[END_REF], we introduce the following Definition 3.1. We say that a semigroup P t on a Hilbert space H is weakly topologically irreducible if for all x 1 , x 2 ∈ H there exists y ∈ H so that for any open set A containing y there exist t 1 , t 2 > 0 with P ti (x i , A) > 0.

The main result of this section is the following Theorem 3.2. Under assumptions (3.2) and (3.3), for any c ∈ (-1, 1) the semigroup P c t , t ≥ 0 has an unique invariant measure.

Proof. By Corollary 1.4 from [START_REF] Hairer | A theory of hypoellipticity and unique ergodicity for semilinear stochastic PDEs[END_REF], a Markov semigroup which is Feller, weakly topologically irreducible and asymptotically strong Feller admits at most one invariant probability measure. The proof then follows by Proposition 3.3 and Proposition 3.4.

In order to proceed, we need some apriori estimates on the solution of the approximated problem. Le us denote by X n (t, x, W ) the solution of (1.2) perturbed by the Wiener process W . Lemma 3.1. There exist δ > 0 and a continuous non decreasing function C : R + → R + such that any x, y ∈ H c , n ∈ N there exists a process w n ∈ L 2 (0, ∞; H), adapted to W , satifying

X n t, x, W + • 0 w n (s)ds -X n (t, y, W ) -1 ≤ e -δt |x -y| -1 (3.4
)

and E 1 -e -1 t 0 w 2 n (s)ds+ t 0 wn(s)dW (s) ≤ C(|x| -1 ∨ |y| -1 )|x -y| -1 . (3.5)
Proof. Fix n ∈ N. Let us denote by π l the projection of H c into span{e 0 , . . . , e N } (the low frequences) and by π h = I -π l the projection into its orthogonal complement (the high frequences). Let X be the solution of

d X = -A 2 X + λAπ h X -Ap n ( X) + λAπ l X n (t, y, W ) dt + BdW (t) X(0) = x.
Here p n is the increasing polynomial f n -λ. Arguing as in the previous section, it is strightforward to show that this equation admits a unique solution in

C([0, T ]; H c ) ∩ L 2 ([0, T ]; V 1 ), T > 0, adapted to W (t), t ≥ 0. Now set w n (t) = B -1 Aπ l ( X -X n (t, y, W )).
It is clear that the operator B -1 Aπ l : R N → R N is well defined (thanks to (3.2), (3.3)) and that w n (t) is square integrable and adapted to W (t), t ≥ 0. Moreover, we find that X n t, x, W +

• 0 w n (s)ds satisfies the same equation of X, so that it has to coincide with X.

Consequently, Y (t) := X t, x, W

+ • 0 w n (s)ds -X(t, y, W ) solves    dY (t) = -A 2 Y (t) + λAπ h Y (t) -Ap n X(t, x, W + • 0 w n (s)ds) + Ap n (X(t, y, W ) dt Y (0) = x -y.
By taking the scalar product of both members with A -1 Y (t) and using the dissipativity of p n we find

1 2 d|Y (t)| 2 -1 = -|Y (t)| 2 1 + λ π h Y (t) 2 -p n X n (t, x, W + • 0 w n (s)ds) -p n (X n (t, y, W ), Y (t) ≤ - 1 2 (N + 1) 2 -λ |π h Y (t)| 2 0 -|π l Y (t)| 2 0 .
Here we have used the estimate

|ξ| 2 1 = |π l ξ| 2 1 + |π h ξ| 2 1 = |π l ξ| 2 1 + ∞ k=N +1 k 2 (ξ k ) 2 ≥ |π l ξ| 2 0 + (N + 1) 2 |π h ξ| 2 0
where ξ ∈ H 0 and ξ k is the k-th Fourier mode. Setting δ = 2π min 1 2 (N + 1) 2 -λ, 1 (which is stricly positive by (3.3)) we deduce, by Gronwall lemma,

|Y (t)| 2 -1 + πδ t 0 Y (s) 2 ds ≤ |x -y| 2 -1 .
Moreover, since V 0 ⊂ V -1 , with |x| -1 ≤ π -1 x we deduce

|Y (t)| -1 ≤ e -δt |x -y| -1 .
This proves (3.4). Let us show (3.5). By the definition of w n and by (3.4) we have

|w n (s)| ≤ B -1 Aπ l L(R N ;R N ) | X -X n (s, y, W )| -1 ≤ B -1 Aπ l L(R N ;R N ) e -δs |x -y| -1 . (3.6)
Notice that this estimate holds in L ∞ (Ω). Then the process e -

≤ t 0 E e -s 0 w 2 n (τ )dτ +2 s 0 wn(τ )dW (τ ) |w n (s)| 2 L ∞ (Ω) ds 1 2 ≤ t 0 E e -2 s 0 w 2 n (τ )dτ +2 s 0 wn(τ )dW (τ ) e s 0 |wn(τ )| 2 L ∞ (Ω) dτ |w n (s)| 2 L ∞ (Ω) ds 1 2 = t 0 e s 0 |wn(τ )| 2 L ∞ (Ω) dτ |w n (s)| 2 L ∞ (Ω) ds 1 2 = e t 0 |wn(τ )| 2 L ∞ (Ω) dτ -1 1 2 ≤ e 1 2 t 0 |wn(τ )| 2 L ∞ (Ω) dτ t 0 |w n (τ )| 2 L ∞ (Ω) dτ 1 2
.

By (3.6) we have

t 0 |w n (τ )| 2 L ∞ (Ω) dτ ≤ B -1 Aπ l 2 L(R N ;R N ) |x -y| 2 -1 t 0 e -2δτ dτ ≤ B -1 Aπ l 2 L(R N ;R N ) 2δ |x -y| 2 -1 .
Then (3.5) is satisfied with

C(t) = B -1 Aπ l L(R N ;R N ) √ 2δ exp B -1 Aπ l 2 L(R N ;R N ) 2δ t 2 , t ≥ 0.
The previous lemma means that we can find a Wiener process W such that the solution of equation (1.2) starting by x driven by the Wiener process W approches the solution of (1.2) starting by y as t → ∞. Moreover, this perturbation is uniformly controlled, in the sense of (3.5), by a constant independent by n. Proof : Fix c ∈ (-1, 1). Taking into account Proposition 3.2, it is sufficient to show that there exist a nondecreasing function C : R + → R + and a a constant δ > 0 such that for any ψ : H c → R continuous and bounded with bounded Fréchet derivative it holds

|P c t ψ(x) -P c t ψ(y)| ≤ C(|x| -1 ∨ |y| -1 )(|ψ| ∞ + e -δt |∇ψ| ∞ )|x -y| -1 . (3.7)
Taking into account that P c,n t n→∞ -→ P c t (see Proposition 2.3), for any ε > 0 there exists n ∈ N (depending on ε, ψ, x and y) such that

|P c t ψ(x) -P c t ψ(y)| ≤ ε + |P c,n t ψ(x) -P c,n t ψ(y)|.
By the previous Lemma, we take w n (•) such that (3.4), (3.5) hold. Then,

P c,n t ψ(x) -P c,n t ψ(y) = Eψ(X n (t, x, W )) -Eψ(X n (t, y, W )) = Eψ(X n (t, x, W )) -Eψ(X n (t, x, W + • 0 w n (s)ds)) + Eψ(X n (t, y, W + • 0 w n (s)ds)) -Eψ(X n (t, y, W )).
We stress that the expectation is taken with respect to the Wiener process W (t), t ≥ 0. Then, by Girsanov theorem, we obtain

Eψ(X n (t, x, W )) -Eψ(X n (t, x, W + • 0 w n (s)ds)) = E[ψ(X n (t, x, W ))(1 -e -1 2 t 0 w 2 n (s)ds+ t 0 wn(s)dW (s) )].
Then by (3.5) we deduce

|Eψ(X n (t, x, W )) -Eψ(X n (t, x, W + • 0 w n (s)ds))| ≤ |ψ| L ∞ E|1 -e -1 2 t 0 w 2 n (s)ds+ t 0 wn(s)dW (s) | ≤ C(|x| -1 ∨ |y| -1 )|ψ| L ∞ |x -y| -1 .
On the other side, by (3.4) we obtain |Eψ(X n (t, y, W +

• 0 w n (s)ds)) -Eψ(X n (t, y, W ))| ≤ |∇ψ|E|X n (t, y, W + • 0 w n (s)ds) -X n (t, y, W )| ≤ |∇ψ|e -δt |x -y| -1 .
Therefore it holds

|P c,n t ψ(x) -P c,n t ψ(y)| ≤ C(|x| -1 ∨ |y| -1 )|ψ| L ∞ |x -y| -1 + |∇ψ|e -δt |x -y| -1
where the continuous nondecreasing function C : R + → R + and the positive constant δ are independent by n and by ε. Consequently, (3.7) follows.

Proposition 3.4. For any c ∈ (-1, 1), the semigroup P c t , t ≥ 0 on H c is weakly topologically irreducible.

Proof. We shall show that that for any x ∈ H c , δ > 0 there exists ε > 0 and t > 0 such that P c t (x, B(0, δ)) ≤ 1 -ε, where B(0, δ) = {y ∈ H c : |y -c| -1 > δ}. Since P n,c t → P c t , it is sufficient to show that for such t > 0, P c,n t (x, B(0, δ)) c ) ≤ 1 -ε with ε > 0 independent by n. Let W A (t, x) be the solution of DZ = A 2 Zdt + BdW (t), Z(0) = x.

Setting Y n = X n -W A (t), we have that Y n ∈ H 0 and it sastisfies the equation

dY n (t) = A(-AY n + λY n + f n (Y n + W A ))dt, Y n (0) = 0.
By multiplying both sides by (-A) -1 Y n and integrating on [-1, 1] we find for any z ∈ H 1 . Then we deduce

1 2 d|Y n | 2 -1 = -∇Y n 2 2 + λ Y n 2 2 + f n (Y n + W A ), Y n ≤ -∇Y n 2 2 + λ Y n 2 2 + f n (W A ), Y n ≤ -∇Y n 2 2 + λ Y n 2 2 + f n (W A ) 2 2 + 4 Y n 2
1 2 d|Y n | 2 -1 ≤ C|Y n | 2 -1 + f n (W A ) -f n (c) 2 2 .
So by Grownwall inequality we find In order to conclude the proof, it is sufficient to observe that by the gaussianity of the stochastic convolution this probability is < 1.

|Y n (t)|

Conclusion

We obtain the ergodicity of the limit semi-group by assuming an essentially elliptic structure of the noise (that is the noise acts on the first modes). We expect that these properties (expecially the ASF property) hold also with more general noises but this need a better understanding of how the nonlinearity spreads the noise. Unfortunately the structure of the limit equation is unknown. In previous papers, for the same equation perturbed by white noise, it is proved that the nonlinearity has lead to reflection measures. On the other side, in the deterministic case, there is a L ∞ bound proving that the solution never approach the singularities. In both cases they prove regularity in space that we have been unable to obtain in our degenerate noise case. With enough regularity, we expect a good characterization of the solution (with or without reflection measure) leading to uniqueness.

Proposition 3 . 3 .

 33 Assume that (3.2), (3.3) hold. Then for any c ∈ (-1, 1) the semigroup P c t on H c has the asymptotic strong Feller property.

2

  where we have used Young's inequality and the fact (f n (a + b) -f n (a))b ≤ 0 for any a, b ∈ R and n ≥ 0. It is clear that there exists C > 0 sucht that

  2C(t-s) f n (W A (s)) 2 2 ds + |W A (t)| 2 -1 > δ 2 /2 . (3.8)By the properties of the approximating functionsf n we have |f n (W A (s))| ≤ |f (W A (s))| where the right-hand side is allowed to be +∞ if |W A (t, x)| ≥ 1. This implies that (3.8) is bounded by 2C(t-s) f (W A (s)) 2 2 ds + |W A (t)| 2 -1 > δ 2 /2 .

			t
			2 -1 ≤	e 2C(t-s) f n (W A (s)) 2 2 ds.
			0
	Consequently,
	P(|X P	t	e
	0

n (t)| -1 > δ) ≤ P(|Y n (t)| -1 + |W A (t)| -1 > δ) ≤ P(|Y n (t)| 2 -1 + |W A (t)| 2 -1 > δ 2 /2) ≤ P t 0 e