Maurizio Gabbrielli

Catuscia Palamidessi

Frank D Valencia

Concurrent and Reactive Constraint Programming

The Italian Logic Programming community has given several contributions to the theory of Concurrent Constraint Programming. In particular, in the topics of semantics, verification, and timed extensions. In this paper we review the main lines of research and contributions of the community in this field.

1 The origins: from concurrect logic programming to concurrent constraint programming

 and their so-called flat versions. Towards the end of the decade, Concurrent constraint programming ([52, 56, 57]) emerged as one of the most successful proposals in this area. Concurrent constraint programming (ccp) presented two new perspectives on the underlying philosophy of logic programming. One is the replacement of the concept of unification over the Herbrand universe by the more general notion of constraint over an arbitrary domain. This is in a sense a 'natural' development, and the idea was already introduced in 'sequential' logic programming by Jaffar and Lassez ([45]). The other is the introduction of extra-logical operators typical of the imperative concurrent paradigms, like CCS ([47]), TCSP ([8]) and ACP ([1]); in particular, the choice (+), the action prefixing (→), and the hiding operator (∃). Additionally, concurrent constraint programming embodies an explicit characterization of the control mechanisms for communication and synchronization by means of the introduction of two kinds of actions (ask and tell). Also in concurrent logic languages these control features were present, but they were hidden in various ways: the choice was represented by alternative clauses, hiding by local (existentially quantified) variables, prefixing by commitment, communication by sharing of variables, and synchronization by restrictions on the unification algorithm.

There are many advantages in an explicit representation of these concurrency control mechanisms by means of operators. First of all, they are 'isolated' and therefore the laws of their behaviour can be understood better. For instance, one of the problems in studying the semantics of concurrent logic programming is that the choice mechanism is 'mixed up' with recursion, since a clause is in general a recursive definition. Second, the standard tools developed in the theory of concurrency can be applied more easily. Third, a 'reconciliation' with the declarative principles of logic programming is more feasible, once the basic limitations are well understood. For instance, the conditions which rule the behaviour of ask and tell can be described in a logical way, thus providing the synchronization mechanism with a 'declarative flavour' ( [START_REF] Maher | Logic semantics for a class of committed-choice programs[END_REF][START_REF] Saraswat | A somewhat logical formulation of CLP synchronization primitives[END_REF]) that was missing in the 'restricted-unification' approach.

The ccp paradigm

Ccp is based on the concept of store-as-constraint, in contrast to von Neumann's concept of store-as-valuation. The computation proceeds through the concurrent execution of different processes, which interact and communicate through the common store. They refine the partial information about the values of the variables by adding (telling) constraints to the store, and they test (ask ) whether the store entails a constraint before proceeding in the computation.

One of the most characteristic features of the ccp paradigm is a formalization of these basic operations which allow to update and to query the common store, in terms of the logical notions of consistency, conjunction and entailment supported by a given underlying constraint system.

Here we recall briefly the syntax and semantics of ccp. Among the several variants which have been proposed in literature, we choose the simplest and most basic one, called eventual tell ccp. Most of the other ccp dialects can be obtained by enriching this one.

The ccp languages are defined parametrically w.r.t. to a given cylindric constraint system. Definition 1.

-A constraint system is a complete algebraic lattice C, ⊢, ⊔, true, false where ⊔ is the lub operation, and true, false are the least and the greatest elements of C, respectively. The entaiment relation ⊢ is the inverse ordering. -Consider a (denumerable) set of variables x, y, z, . . .. Assume that for each

x ∈ Var a function ∃ x : C → C is defined such that for any c, d ∈ C:

(i) c ⊢ ∃ x (c), (ii) if c ⊢ d then ∃ x (c) ⊢ ∃ x (d), (iii) ∃ x (c ⊔ ∃ x (d)) = ∃ x (c) ⊔ ∃ x (d), (iv) ∃ x (∃ y (c)) = ∃ y (∃ x (c)).
Then C = C, ≤, ⊔, true, false, Var , ∃ is a cylindric constraint system.

In order to model parameter passing, diagonal elements ( [START_REF] Henkin | Cylindric Algebras (Part I)[END_REF]) are added to the primitive constraints: We assume that, for x, y ranging in Var , D contains the constraints d xy which satisfy the following axioms. Note that if C models the equality theory, then the elements d xy can be thought of as the formulas x = y. In the following ∃ x (c) is denoted by ∃ x c with the convention that, in case of ambiguity, the scope of ∃ x is limited to the first constraint subexpression. (So, for instance, ∃ x c ⊔ d stands for ∃ x (c) ⊔ d.)

Definition 2. Assuming a given cylindric constraint system C the syntax of agents is given by the following grammar:

A ::= stop | tell(c) | n i=1 ask (c i ) → A i | A A | ∃xA | p(x)
where the c, c i are supposed to be finite constraints (i.e. algebraic elements) in C. A ccp process P is then an object of the form D.A, where D is a set of procedure declarations of the form p(x) :: A and A is an agent.

The deterministic agents are obtained by imposing the restriction n = 1 in the previous grammar. The standard operational model of ccp can be described by a transition system T = (Conf , -→). The configurations (in) Conf are pairs consisting of a process, and a constraint in C representing the common store. The transition relation -→⊆ Conf × Conf is described by the (least relation satisfying the) rules R1-R6 of table 1.

The agent stop represents successful termination. The basic actions are given by tell(c) and ask (c) constructs which act on the common store. Given a store d, as shown by rule R1, the execution of tell(c) updates the store to c⊔d. The action ask (c) represents a guard, i.e. a test on the current store d, whose execution does not modify d. We say that ask (c) is enabled in d iff d ⊢ c. According to rule R2 the guarded choice operator gives rise to global non-determinism: the agent n i=1 ask(c i ) → A i nondeterministically selects one ask(c i ) which is enabled in the current store, and then behaves like A i . The external environment can then affect the choice since ask(c) is enabled iff the current store d entails c, and d can be modified by other agents (rule R1). If no guard is enabled, then the guarded choice agent suspends, waiting for other (parallel) agents to add information to the store. The situation in which all the components of a system of parallel agents suspend is called global suspension or deadlock. The operator represents parallel composition which is described by rule R3 as interleaving. The agent ∃xA behaves like A, with x considered local to A. To describe locality in rule R4 the syntax has been extended by an agent ∃ d xA where d is a local store of A containing information on x which is hidden in the external store. Initially the local store is empty, i.e. ∃xA = ∃ true xA.

Rule R5 treats the case of a procedure call when the actual parameter equals the formal parameter: in this case a simple body replacement suffices. We do not need more rules since, for the sake of simplicity, we assume that the set D of procedure declarations is closed w.r.t. parameter names.

R1 D.tell(c), d -→ D.Stop, c ⊔ d R2 D. n i=1 ask(ci) → Ai, d -→ D.Aj, d j ∈ [1, n] and d ⊢ ci R3 D.A, c -→ D.A ′ , c ′ D.A B, c -→ D.A ′ B, c ′ D.B A, c -→ D.B A ′ , c ′ R4 D.A, d ⊔ ∃xc -→ D.B, d ′ D.∃ d xA, c -→ D.∃ d ′ xB, c ⊔ ∃xd ′ R5 D.p(x), c -→ D.A, c p(x) : -A ∈ D Table 1.
The transition system of ccp.

Semantic aspects of ccp

In the first few years after its design, ccp had been understood just as a particular case of process algebra. Therefore, the definition of its compositional semantics had been approached by the standard methods, like failure sets and bisimulation. For instance, De Boer et al. [START_REF] De Boer | Control flow versus logic: a denotational and a declarative model for Guarded Horn Clauses[END_REF][START_REF] De Boer | Semantic models for a version of PARLOG[END_REF] used tree-like structures labeled with functions on substitutions. More simple tree-like structures, labeled by constraints, were used by Gabbrielli and Levi [START_REF] Gabbrielli | Unfolding and fixpoint semantics for concurrent constraint logic programs[END_REF]. Saraswat and Rinard [START_REF] Saraswat | Concurrent constraint programming[END_REF] used similar structures modulo equivalence relations based on bisimulation. De Boer and Palamidessi [START_REF] De Boer | A Fully Abstract Model for Concurrent Constraint Programming[END_REF] realized that, due to the fact that the communication mechanism of ccp is asynchronous, the branching structures used for process algebra are not needed. In fact, which actions are enabled does not depend upon the current state of the environment, but only upon the store. In a transition system this can be made explicit by adding a passive rule that does not exist in the classical concurrent paradigms: an arbitrary assumption of a step made by the environment. This amounts to considering all the possible interactions between the given process and arbitrary environments, and it leads to a simple compositional semantics, consisting of sequences of constraints labeled by assume/tell modes. In this framework the parallel composition corresponds to zip sequences, so that the assumptions of a process match with the actions of the other, and vice-versa.

Independently, a different approach was developed in [START_REF] Saraswat | Semantics foundations of Concurrent Constraint Programming[END_REF]. The basic idea consists in denoting processes as Scott's closure operators, which have the nice property of being representable by the set of their fixpoints. The operators of the language can then be described as operations on those sets. In particular, parallelism can be modeled simply by intersection.

The semantics developed in [START_REF] De Boer | A Fully Abstract Model for Concurrent Constraint Programming[END_REF] and in [START_REF] Saraswat | Semantics foundations of Concurrent Constraint Programming[END_REF] are based on very different points of view. The one in [START_REF] De Boer | A Fully Abstract Model for Concurrent Constraint Programming[END_REF] is more general, in the sense that it applies, without essential modifications, to many variants of ccp, including the atomic and nondeterministic versions. The one in [START_REF] Saraswat | Semantics foundations of Concurrent Constraint Programming[END_REF] is very ingenious and elegant, and can be considered one of the principal reasons of the success of ccp. However, it works well only in the basic fragment, the deterministic eventual tell ccp, which is obtained from Definition 6 by imposing n = 1 in the summation. Both semantics are fully abstract, and therefore in the basic fragment they are equivalent. The precise correspondence was delineated in [START_REF] De Boer | On the semantics of concurrent constraint programming[END_REF].

One question that had remained open in [START_REF] De Boer | A Fully Abstract Model for Concurrent Constraint Programming[END_REF] was how to model infinite computations in an abstract way, i.e. by considering only the limit of the answer substitution. When nondeterminism is present, the denotational characterization of infinite computation is actually a non trivial problem: The semantics based on Smith, Hoare and Plotkin's powerdomains constitute only a partial solution to this problem (in the sense that they identify too much), and the semantics based on metric domains are far from being abstract. This problem was solved in [START_REF] De Boer | Nondeterminism and infinite computations in constraint programming[END_REF] by considering a categorical construction called Lehmann's powerdomain, which can be regarded as an extension of Smith's powerdomain. This structure contains more information than the powerdomains, enough to achieve compositionality.

Analysis and verification

De Boer et al. developed in [START_REF] De Boer | Proving concurrent constraint programs correct[END_REF] a system based on the closure operators semantics to prove correctness assertions about concurrent constraint programs. Thanks to the strong properties of ccp, this system is much simpler than the ones developed for other parallel languages. In particular, only the strongest post-condition w.r.t. True needs to be considered, and parallel composition is modeled simply by logical conjunction.

Falaschi et al. investigated in [START_REF] Falaschi | Confluence in concurrent constraint programming[END_REF] various fragments of ccp. Some of them have a very simple semantics based on closure operators. Such semantics can be considered as approximated semantics of ccp, and they were used as a basis for static analysis [START_REF] Falaschi | Compositional analysis for concurrent constraint programming[END_REF][START_REF] Falaschi | Confluence in concurrent constraint programming[END_REF], by means of abstract interpretation techniques. These techniques allow to statically optimize programs and to approximate several important semantic properties, such as deadlock detection, groundness propagation etc.

One interesting fragment is ccp with local choice: This corresponds in fact to CLP with delay, an extension of Constraint Logic Programming which allows efficient implementations. Falaschi et al. [START_REF] Falaschi | Constraint Logic Programming with Dynamic Scheduling: A Semantics Based on Closure Operators[END_REF] and De Boer et al. [START_REF] De Boer | Proving correctness of constraint logic programs with dynamic scheduling[END_REF] used this observation for developing the semantics foundations and a verification system of CLP with delay, by means of techniques based on closure operators.

Another approach to the analysis of ccp was pursed in [START_REF] Zaffanella | Domain Independent Ask Approximation in CCP[END_REF][START_REF] Zaffanella | Abstracting synchronization in concurrent constraint programming[END_REF] where it was extended to ccp languages the generalized semantics approach to static analysis, initially proposed in [START_REF] Giacobazzi | Generalized semantics and abstract interpretation for constraint logic programs[END_REF] for sequential CLP languages. [START_REF] Zaffanella | Domain Independent Ask Approximation in CCP[END_REF] shows that such an extension can be easily achieved for approximations that are closed under antientailment: applications include analyses that can identify definite suspensions, e.g., to compute upper bounds to the degree of concurrency in a ccp program. For the more common case of entailment closed properties (that are of interest for, e.g., proving suspension freeness), it is shown in [START_REF] Zaffanella | Abstracting synchronization in concurrent constraint programming[END_REF] that correctness can only be achieved by modifying the generalized semantics approach so as to introduce a domain-dependent approximation of the synchronization primitive, which cannot be modeled as an entailment test on the abstract domain.

Fold/unfold transformations of ccp

Unfold/fold are source-to source transformation techniques which were first introduced in functional programming by Burstall and Darlington [START_REF] Burstall | A transformation system for developing recursive programs[END_REF], and then adapted to logic programming both for program synthesis and for program specialization and optimization. As shown by a number of applications, these techniques provide a powerful methodology for the development and optimization of large programs, and can be regarded as the basis to be used for partial evaluation.

Despite a large amount of literature in the field of declarative sequential languages, the applications of unfold/fold transformations to concurrent languages are relatively rare. This is partially due to the fact that the nondeterminism and the synchronization mechanisms present in concurrent languages substantially complicate their semantics, thus complicating also the definition of correct transformation systems. Nevertheless, these transformation techniques can be very useful also for concurrent languages, since they allow further optimizations related to the simplification of synchronization and communication mechanisms.

One of the few papers addressing this issue is [START_REF] Etalle | Transformations of ccp programs[END_REF], where a transformation system for concurrent constraint programming (ccp) was introduced. This systems was inspired by that one of Tamaki and Sato [START_REF] Tamaki | Unfold/fold transformation of logic programs[END_REF], a general framework for the unfold/fold transformation of logic programs, which has remained over the years the main historical reference of the field.

Compared to its predecessors, the system in [START_REF] Etalle | Transformations of ccp programs[END_REF] improves by eliminating the limitation that in a folding operation the folding rule has to be non-recursive. Moreover, following de Francesco and Santone [START_REF] Francesco | Unfold/fold transformations of concurrent processes[END_REF], the applicability conditions for this operation are based on the notion of "guardedness" and can be checked locally on the program to be folded (rather than on the transformation history). This makes the operation much easier to understand and to implement. Besides folding and unfolding, the transformation system for ccp includes several other new operations, namely backward instantiation, ask and tell simplification, branch elimination, conservative ask elimination and distribution. The declarative nature of ccp allows one to define reasonably simple applicability conditions for these operations which ensure the total correctness of the system: the original and the transformed program have the same semantics when considering both input/output pairs and (under different applicability conditions) traces, and distinguishing successful, deadlocked, and failed derivations.

From the correctness result follows that the original program is deadlockfree iff the transformed one is, and this allows us to employ the transformation system as an effective tool for proving deadlock-freeness of ccp programs. Moreover, the systems allows to optimize programs by eliminating communication channels and synchronization points, by transforming nondeterministic computations into deterministic ones, and by saving of computational space. Some of these improvements were possible already in the context of GHC programs by using the system defined in Ueda and Furukawa [START_REF] Ueda | Transformation rules for ghc programs[END_REF].

Following the above line of research, [START_REF] Bertolino | The replacement operation for CCP programs[END_REF] investigated transformation techniques based on the replacement. This is a powerful operation which can mimic the most common transformation operations such as unfold, fold, switching, distribution. Because of this flexibility, it can be incorrect if used without specific applicability conditions. The above paper presented applicability conditions for ccp and it showed that, under these conditions, the replacement generalizes both the unfolding operation as well as a restricted form of folding operation.

Timed Reactive CCP

The tcc model is a timed reactive ccp framework introduced by Saraswat et al [START_REF] Saraswat | Foundations of timed concurrent constraint programming[END_REF] as an extension of deterministic ccp. This model is aimed at programming and modeling timed reactive systems and it elegantly combines deterministic ccp with ideas from the paradigms of Synchronous Languages [START_REF] Berry | The esterel synchronous programming language: Design, semantics, implementation[END_REF].

In order to increase the specification expressiveness of tcc, Nielsen et al [START_REF] Nielsen | Temporal concurrent constraint programming: Denotation, logic and applications[END_REF] introduced a non-deterministic extension of tcc, called the ntcc calculus. As its predecessor, the ntcc calculus takes the view of reactive computation as proceeding in discrete time units (or time intervals). Time is conceptually divided into discrete intervals. In each time interval a ccp process receives a stimulus, represented as a constraint, from the environment, it executes with this stimulus as the initial store, and when it reaches its resting point, it responds to the environment with the final store. Furthermore, the resting point determines a residual process, which is then executed in the next time interval.

As illustrated in [START_REF] Nielsen | Temporal concurrent constraint programming: Denotation, logic and applications[END_REF], this view of reactive computation is particularly appropriate for modeling and programming reactive systems such as robotic devices and micro-controllers. These systems typically operate in a cyclic fashion; in each cycle they receive and input from the environment, compute on this input, and then return the corresponding output to the environment.

Syntax and Operational Semantics of ntcc

The ntcc calculus introduces operators to specify temporal executions. The unitdelay operation next A, also present in tcc, specifies that A should be executed in the next time interval, and the unbounded delay operation ⋆A specifies that A will be eventually executed. The time-out operation unless c next A, also present in tcc, specifies that unless c can be inferred from the final store in the current time unit, A should be executed in the next time unit.

Furthermore, to ensure that only terminating processes can be executed within time intervals, procedures are replaced with the simpler replicated form !A. The replication operation !A specifies that A will be executed now and in each future time interval. Thus, !A can be viewed as

A next A next (next A) . . .
All in all, the agents of ntcc include those of ccp in Definition 2 except for procedures, plus the above-mentioned temporal operators. More precisely, Definition 3. Assuming a given cylindric constraint system C the syntax of ntcc agents is given by the following grammar:

A ::= stop | tell(c) | n i=1 ask (c i ) → A i | A A | ∃xA | next A | ⋆ A | unless c next A | !A
where the c, c i are supposed to be finite constraints (i.e. algebraic elements) in C. For the sake of consistency with Definition 2, an ntcc process P can be interpreted as an object of the form D.A by decreeing that D = ∅; i.e., the empty set of procedure declarations.

Reduction Relations

The operational semantics of ntcc is given in terms of an internal reduction relation -→ given by the rules in Table 1 plus the rules in Table 2 and the observable reduction relation =⇒ given in Table 2.

The internal transition γ -→ γ ′ specifies the internal steps much like the ccp transitions -→ in the previous section. The additional rules R6-R8 in Table 2 realize the above intuitions about the temporal operators.

The observable transition P (c,d) =⇒ R should be read as "P on input c from the environment, reduces in one time unit to R and outputs d to the environment". The rule ROBS realizes the above intuition by stating that an observable transition from P = D.A labeled by (c, d) is obtained by performing a sequence of internal transitions from the initial configuration P, c to a final configuration Q, d with Q = D.A ′ in which no further internal evolution is possible. The residual process R to be executed in the next time interval is equivalent to D.F (A ′ ), where F (A ′ ) represents the "future" of A ′ . The process F (A ′ ), given in Definition 4, is obtained by removing from A ′ summations that did not trigger activity within the current time interval and any local information which has been stored in A ′ , and by "unfolding" the sub-terms within "next" and "unless" expressions. This "unfolding" specifies the evolution across time intervals of processes of the form next B and unless c next B. Definition 4 (Future Function). Let F be the partial function defined by

F (A) =        stop if A = i∈I c i → A i F (A 1 ) F (A 2 ) if A = A 1 A 2 ∃xF (B) if A = ∃ d xB B if A = next B or A = unless c next B

A simple example of weak pre-emption

In spite of its simplicity, the tcc and ntcc extensions to ccp are far-reaching. Many interesting temporal constructs can be expressed (see e.g. [START_REF] Saraswat | Foundations of timed concurrent constraint programming[END_REF]). For example, tcc allows processes to be "clocked" by other processes. This provides meaningful

R6 D. ⋆A, d -→ D.A n , d n ≥ 0 R7 D.unless c next A, d -→ D.stop, d , d ⊢ c R8 D.!A, d -→ D.A next !A, c ⊔ d ROBS D.A, c -→ * D.A ′ , c ′ -→ D.A, c (c,c ′ ) =⇒ D.F (A ′ )
Table 2. Additional rules for the transitions of ntcc processes. The internal reduction -→ is given by the rules in pre-emption constructs and the ability to define multiple forms of time instead of only having a unique global clock.

A rather simple example is the specification of a power-saver:

A = ! unless (LightsOff ) next ⋆ tell (LightsOff )
The power-saver agent A runs forever, hence it is replicated. Furthermore, unless A can infer that the lights are already off in the current time interval, A should turn them off either in the next time unit or sometime later.

Notice that because of the weak pre-emption nature of the time-out operation in ntcc, it is not possible to specify that the lights should be turned off within the current time interval unless they are already off.

The work in [START_REF] Saraswat | Timed default concurrent constraint programming[END_REF] introduces Default tcc as an extension of tcc with the ability to define strong pre-emption. In this model, the time-out operation can trigger activity in the current time interval. Strong pre-emption is useful when an action must be triggered immediately on the absence of a constraint c rather than delayed to the next interaction.

Observables and their Characterizations

Let us consider an infinite sequence of observable transitions:

P = P 1 (c1,c ′ 1 ) ====⇒ P 2 (c2,c ′ 2 ) ====⇒ P 3 (c3,c ′ 3 )
====⇒ . . . Intuitively, at time interval i, with i ≥ 0, the process P i gets a stimulus c i and then it provides a response c ′ i and evolves into P i+1 . We shall also represent this run as P As shown in [START_REF] Nielsen | Temporal concurrent constraint programming: Denotation, logic and applications[END_REF] the observable input-output behaviour of deterministic ntcc processes (i.e., tcc processes) can be compositionally specified as closure operators over sequences of constraints much like for the deterministic ccp case. Also, by building on the strongest-postcondition semantics for ccp in [START_REF] De Boer | Proving concurrent constraint programs correct[END_REF], the work in [START_REF] Nielsen | Temporal concurrent constraint programming: Denotation, logic and applications[END_REF] includes a compositional characterization of the quiescent behaviour of ntcc processes as well as a proof system for their temporal properties. The ntcc proof system is similar to Dijkstra's proof system for the strongest postcondition of imperative programs.

In [START_REF] Nielsen | On the expressive power of concurrent constraint programming languages[END_REF] the authors provided a hierarchy of ntcc variants based on the inputoutput behaviour. A variant C is said to be as expressive as a variant C ′ if for every process P in C ′ , one can compute a process E(P ) in C such that O io (P ) = O io (E(P )). The variants were obtained by replacing replication with alternative mechanisms to specify infinite behaviour: Namely, procedure definitions, static-scoping parameterless recursion, and dynamic-scoping parameterless recursion. It was shown that ntcc is equally expressive to the variant with staticscoping parameterless recursion. These variants were also shown to be strictly less expressive than the variant with parametric procedures which in turn was shown to be equally expressive to the variant with dynamic-scoping parameterless recursion. The authors also showed that the input-output behavior of every ntcc processes is omega-regular ; i.e. it can be specified by a finite-state Büchi automaton [START_REF] Buchi | On a decision method in restricted second order arithmetic[END_REF].

In [START_REF] Falaschi | Declarative diagnosis of temporal concurrent constraint programs[END_REF] it is defined a framework for the declarative debugging of ntcc programs, which is based on a fixpoint semantics for this language. A general framework, parametric w.r.t an abstract domain, for the static analysis of tcc programs is provided in [START_REF] Falaschi | A framework for abstract interpretation of timed concurrent constraint programs[END_REF].

Another timed ccp language

A different timed extension of ccp, called tccp, was proposed in [START_REF] De Boer | A timed concurrent constraint language[END_REF]. Similarly to the previously mentioned timed languages (tcc) [START_REF] Saraswat | Foundations of timed concurrent constraint programming[END_REF] and default tcc [START_REF] Saraswat | Timed default concurrent constraint programming[END_REF], tccp is a language for reactive programming where computation takes a bounded period of time rather than being instantaneous (as it is in ESTEREL [START_REF] Berry | The esterel synchronous programming language: Design, semantics, implementation[END_REF]). However, differently from tcc and default tcc, which are inspired by the deterministic synchronous languages, tccp follows the guidelines of the timed process algebras approach and allows for non-determinism. This corresponds to a different view and use of a timed language: deterministic languages can be used for programming "kernels" of real-time systems, since deterministic systems are simpler to specify, debug and analyze. However, non-determinism arises when considering larger reactive systems involving several processes running on different processors and communicating via asynchronous links. These (timed) systems can be naturally specified and programmed by using a non-deterministic language. Indeed all the existing timed process algebras and almost all the variants of Statecharts admit non-determinism.

Notice that the ntcc calculus discussed in the previous section, is also a nondeterministic timed ccp language. However, ntcc is an orthogonal non-deterministic extension of tcc, while tccp is an orthogonal timed nondeterministic extension of ccp. That means that, unlike in tccp, in ntcc computation proceeds as in the synchronous languages.

Below we first describe the tccp language and its operational semantics. Then we define a fix-point semantics for it which is based on reactive sequences and which is fully abstract w.r.t. the input/output notion of observables. All the technical definitions and results in this section are from [START_REF] De Boer | A timed concurrent constraint language[END_REF].

Syntax and operational semantics of tccp

When querying the store for some information which is not present (yet) a ccp agent will simply suspend until the required information has arrived. In many applications involving time, however, often one cannot wait indefinitely for an event. Consider for example the case of a bank teller machine: if there is a problem with the authorization of the bank, after a reasonable amount of time the card should be given back to the customer. In order to model such a situation then the language should allow us to specify that, in case a given time bound is exceeded (i.e. a time-out occurs), the wait is interrupted and an alternative action is taken. Moreover, in some cases it is also necessary to abort an active process A and to start a process B when a specific event occurs (this is usually called preemption of A). For example, according to a typical pattern, A is the process controlling the normal activity of some physical device, the event indicates some abnormal situation and B is the exception handler.

In order to enrich ccp agents with such timing mechanisms, we introduce a discrete global clock and assume that ask and tell actions take one time-unit. Computation evolves in steps of one time-unit, so called clock-cycles, and action prefixing is the syntactic marker which distinguishes a time instant from the next one.

Furthermore, we make the assumption that parallel processes are executed on different processors, which implies that at each moment every enabled agent of the system is activated. This assumption, which is common to many timed process algebras, gives rise to what is called maximal parallelism.

Since the store is monotonically increasing and one can have dynamic process creation, clearly the previous assumptions in principle imply that the constraint solver takes a constant time (no matter how big the store is) and that there is an unbound number of processors. In practice, however, one can impose suitable restrictions on programs, thus ensuring that the (significant part of the) store the number of processes do not exceed a fixed bound.

In order to express time-out and preemption which, as previously mentioned, are essential to many applications, the language is enriched by introducing a more basic timing construct of the form now c then A else B . This construct is similar to the analogous one used in [START_REF] Saraswat | Foundations of timed concurrent constraint programming[END_REF], even though here it has a different interpretation: If c is entailed by the store then the above agent behaves as A at the current time instant, otherwise it behaves as B (at the current time instant). Note that the ability to detect the absence of an event is essential here.

Thus, we end up with the following syntax.

Definition 6 (tccp Language). Assuming a given cylindric constraint system C the syntax of agents is given by the following grammar:

A ::= stop | tell(c) | n i=1 ask(c i )→ A i | now c then A else B | A B | ∃x A | p(x )
where the c, c i are supposed to be finite constraints (i.e. algebraic elements) in C.

A tccp process P is then an object of the form D.A, where D is a set of procedure declarations of the form p(x ) : -A and A is an agent.

In order to simplify the notation, in the following we will omit the n i=1 whenever n = 1 and we will use tell(c) → A as a shorthand for tell (c) (ask (true) → A).

The operational model of tccp can be formally described by a transition system T = (Conf , -→) where we assume that each transition step takes exactly one time-unit. Configurations (in) Conf are pairs consisting of an agent and a constraint in C representing the common store. The transition relation -→⊆ Conf × Conf is the least relation satisfying the rules R1, R2, R4 and R5 in Table 1 plus the rules in Table 3.

Notice that the rules now characterizes also the temporal evolution of the system, so A, c -→ B , d means that if at time t we have the agent A and the store c then at time t + 1 we have the agent B and the store d.

In particular, Rule R1 (in Table 1) shows that the evaluation of a tell action takes one time-unit, thus the updated store c ⊔ d will be visible only starting from the next time instant. Analogously, also the evaluation of an ask action takes one time-unit (rule R2).

Let us now briefly discuss the new rules in Table 3. Rules R3bis and R3ter, which replace rule R3 of Table 1, model the parallel composition operator in terms of maximal parallelism: The agent A B executes in one time-unit all the initial enabled actions of A and B .

The rules R9-R12 show that the agent now c then A else B behaves as A or B depending on the fact that c is or is not entailed by the store. Note that here, differently from the case of the ask, the evaluation of the guard is instantaneous. Since A and B could contain nested now then else agents, a limit for the number of these nested agents should be fixed. However, for recursive programs such a limit is ensured by the presence of the procedure call, since we assume that the evaluation of such a call takes one time unit. Using the transition system described by (the rules in) Table 1 we can define the following notion of observables which considers the input/output of terminating computations, including the deadlocked ones. Here and in the sequel -→ * denotes the reflexive and transitive closure of the relation -→.

R3bis A, c -→ A ′ , c ′ B , c -→ B ′ , d ′ A B , c -→ A ′ B ′ , c ′ ⊔ d ′ R3ter A, c -→ A ′ , c ′ B , c -→ A B , c -→ A ′ B , c ′ B A, c -→ B A ′ , c ′ R9 A, d -→ A ′ , d ′ now c then A else B , d -→ A ′ , d ′ d ⊢ c R10 A, d -→ now c then A else B , d -→ A, d d ⊢ c R11 B , d -→ B ′ , d ′ now c then A else B , d -→ B ′ , d ′ d ⊢ c R12 B , d -→ now c then A else B , d -→ B , d d ⊢ c
Table 3. The additional rules for tccp.

Definition 7 (Observables). Let A be an agent. We define

O io (A) = { c, d | A, c -→ * B , d →}.

Programming example

We show now how some typical reactive programming idioms can be derived from the basic combinators of tccp. Then we use these in a programming example.

Time-out

The timed guarded choice agent

n i=1 ask (c i ) → A i time-out(m) B
waits at most m time-units (m ≥ 0) for the satisfaction of one of the guards. Before this time-out the process behaves just like the guarded choice: As soon as there exist enabled guards, one of them and the corresponding branch is nondeterministically selected. After waiting for m time-units, if no guard is enabled, the timed choice agent behaves as B . This agent can be defined inductively as follows. Let us denote by A the agent n i=1 ask (c i ) → A i . In the base case, m = 0, we define For the inductive step we define

n i=1 ask (c i ) → A i time-out(m) B as n i=1 ask (c i ) → A i time-out(0) n i=1 ask (c i ) → A i time-out(m-1) B .
Watchdogs These are typical preemption primitives of such languages as ESTEREL and are used to interrupt the activity of a process on signal from a specific event.

Since events are expressed by constraints, a watchdog can be defined as the process do A watching celseB which behaves as A, as long as c is not entailed by the store; when c is entailed, the process A is immediately aborted and process B is started. We have here a form of weak preemption in which the abortion of A is performed in the next time interval. In fact, even though A is aborted at the same time instant of the detection of the entailment of c, if c is detected at time t then c has to be produced at time t ′ with t ′ < t.

Previous watchdog agent can be defined (by induction on the structure of process A) in terms of the other constructs of the language (see [START_REF] De Boer | A timed concurrent constraint language[END_REF]). For example in case of the tell process one has the following translation do tell (d ) watching c else B ⇒ now c then B else tell (d ),

As a simple example of a tccp program let us now consider a system s(Ex) consisting of two processes p1 and p2 which perform some time critical activities, reacting to external inputs transmitted on the channel Ex. The system is continuously checked by a controller which receives a stream of ok messages by each process pi. Each ok message is sent at unpredictable time instants, however it is assumed that each pi is working correctly iff it sends the next ok within n time-units from the previous one. When this limit is exceeded by a process pi the controller aborts the whole system, starts a recovery routine rr for the activity of pi and then restart the system. The system s(Ex) is implemented by the following program where the specific tasks of the pi's and of the recovery routines are not specificed:

The denotational model

It is easy to see that the operational semantics which associates to an agent A its observables O io (A) is not compositional. A compositional characterization of the operational semantics can be obtained by using sequences of pairs of finite constraints, so called timed reactive sequences, analogous to those that we have seen in the semantics of ccp. However, a reactive sequence is now provided with a different interpretation which accounts for the timing aspects. In fact such a sequence has the form

c 1 , d 1 • • • c n , d n d, d
and each pair of constraints c i , d i now represents a computation step performed by the agent A which, at time i, assuming c i as input constraint produces the constraint d i . The last pair denotes a "stuttering step" in which no further information can be produced by the agent, thus indicating that a "resting point" has been reached.

Since in tccp computations the store evolves monotonically and the constraints arising from computation steps are finite, it is natural to assume that reactive sequences are monotonically increasing and contains only finite constraints. The set of all reactive sequences is denoted by S and its typical elements by s, s 1 . . ., while sets of reactive sequences are denoted by S, S 1 . . . and ε indicates the empty reactive sequence. The semantics R which associates to an agent the reactive sequences that it generates can be defined by a fixpoint construction as follows.

Definition 8. The semantics R ∈ Agent → P(S) is defined as the least fixedpoint of the operator Φ ∈ (Agent → P(S)) → Agent → P(S) defined by

Φ(I)(A) = { c, d • w ∈ S | c ∈ C, A, c → B , d and w ∈ I(B )} ∪ { c, c • w ∈ S | A, c → and w ∈ I(A) ∪ {ε}}.
The ordering on Agent → P(S) is that of (point-wise extended) set-inclusion and it is straightforward to check that Φ is continuous, so standard results allows us to construct the least fixpoint in ω steps.

It is possible to show that the above semantics is correct (w.r.t. the input/ouput observables) and compositional, however is not fully abstract, since it distinguishes tccp agents whose observables are the same under any possible context. In order to obtain a fully abstract model one needs to introduce a suitable abstraction on traces, however, due to the presence of the now then else construct and of maximal parallelism, one cannot use here the abstraction which has been used in [START_REF] De Boer | On the asynchronous nature of communication in concurrent logic languages: A fully abstract model based on sequences[END_REF] for ccp since this would be incorrect (it would identify agents which can be distinguished by a context). This semantic difference has also an expresiveness counterpart, indeed one can show [START_REF] De Boer | A timed concurrent constraint language[END_REF] that tccp is strictly more expressive than. ccp.

So, the full abstraction problem for tccp cannot be reduced to that one for ccp. Indeed, differently from the case of ccp, the definition of a fully abstract semantics for tccp requires the ability to specify the "difference" c i \ d i-1 between an assumption c i (at time i) and the previous contribution d i-1 (at time i -1). Such a difference is formalized by using the algebraic notion of weak relative pseudo-complement [START_REF] Giacobazzi | Weak relative pseudo-complements of closure operators[END_REF][START_REF] Birkhoff | Lattice theory[END_REF]. Using this difference the abstraction α on set of sequences can be defined as follows.

Definition 9 (Abstraction). Let s, s ′ be reactive sequences. Then the relation is defined as follows:

s s ′ iff for some sequences s 1 and s 2 one has that

s = s 1 • a, b c, d • s 2 , s ′ = s 1 • a, b ′ c, d • s 2 and (c \ b ′ ) ≤ (c \ b).
Moreover the (equivalence) relation ≃ is defined as follows s ≃ s ′ iff the sequences s and s ′ differ only in the number of repetitions of the last element.

Given a set of reactive sequences S, α(S) denotes the least set S ′ such that the following holds:

(i) S ⊆ S ′ , (ii) if s ′ ∈ S ′ and either s s ′ or s ≃ s ′ , then s ∈ S ′ .
The fully abstract semantics R α is obtained by simply applying the function α to R(A). One can show that the semantics obtained in this way is compositional (w.r.t. all the operators of the language) and correct (since it allows to reconstruct the observables O io (A)). Moreover it is also fully abstract, as shown by the following theorem.

Theorem 1 (Full abstraction). Assume that the constraint system is weakly relative pseudo-complemented. Then, for any pair of tccp agents A and B , α(R(A)

) = α(R(B )) iff O io (C [A]) = O io (C [B ]) for each context C [•].
FInally it is worth noting that a temporal logic for reasoning on tccp programs, inpired by this semantics, has been defined in [START_REF] De Boer | A temporal logic for reasoning about timed concurrent constraint programs[END_REF].

Other extensions of ccp

In this section we survey some more recent extensions of ccp which mainly deal with probabilistic and uncertainty aspects.

Probabilistic ccp

In [START_REF] Di Pierro | An Operational Semantics for Probabilistic Concurrent Constraint Programming[END_REF] the concurrent constraint programming paradigm is extended with a probabilistic choice construct which replaces the nondeterministic choice of the original paradigm; this allows a program to make stochastic moves during its execution, so that it may be seen as a stochastic process. This embedding of randomness within the semantics of a well structured programming paradigm, like ccp, also aims at providing a sound framework for formalising and reasoning about randomised algorithms and programs. For the resulting language called probabilistic ccp, a fixpoint semantics is given in [START_REF] Di Pierro | A Banach Space Based Semantics for Probabilistic Concurrent Constraint Programming[END_REF][START_REF] Di Pierro | Probabilistic Concurrent Constraint Programming: Towards a Fully Abstract Model[END_REF], which is based on vector spaces and the Brouwer's fixpoint theorem. The addition of probabilities allows for a natural formulation of the average behaviour of a program, whose specification and analysis is particularly important in the study of system performance and reliability. It also allows for an average-case analysis of programs as opposite to the worst case analysis common to the classical static analysis approaches [START_REF] Di Pierro | Quantitative observables and averages in Probabilistic Concurrent Constraint Programming[END_REF].

Concurrent Constraint Programming has been used as a reference programming paradigm for the introduction of a general theory of probabilistic abstract interpretation, which re-formulates the classical theory of abstract interpretation in a setting suitable for a quantitative reasoning about programs. In this setlinear spaces replace the classical order-theoretic domains, and the notion of the so-called Moore-Penrose pseudo-inverse of a linear operator replaces the classical notion of a Galois connection. The resulting abstractions turn out to be close approximations of the concrete semantics, so that closeness becomes a quantitative replacement for classical safety [START_REF] Di Pierro | Concurrent Constraint Programming: Towards Probabilistic Abstract Interpretation[END_REF].

ccp for Service Level Agreement

Service Oriented Computing is an emerging paradigm that builds upon the notion of services as interoperable elements that can be described, published, searched and composed. Services may expose both functional properties (i.e. what they do) and non-functional properties (i.e. the way they are supplied). A Service Level Agreement (SLA) is a contract between two parties, usually a service provider and a customer, that records non-functional properties about a service like performance, availability, and cost.

Recently several extensions of the pure ccp language have been proposed for dealing with Service Level Agreement aspects. Here we briefly describe the main proposals in this area.

The concurrent constraint pi-calculus (cc-pi calculus) [START_REF] Buscemi | Cc-pi: A constraint-based language for specifying service level agreements[END_REF] is a model of Service Level Agreement negotiations that is inspired by both ccp and name-passing calculi. Specifically, the cc-pi calculus combines basic operations of concurrent constraint programming, such as ask and atomic tell, with a symmetric, synchronous mechanism of interaction between senders and receivers, where the sent name is 'fused' (i.e. identified) to the received name and such an explicit fusion enables using interchangeably the two names. The cc-pi calculus is parametric with respect to the choice of an underlying constraint system that is defined using a suitable semiring structure, equipped with a notion of names. Moreover, cc-pi includes a restriction operation that allows for local stores of constraints. Synchronisations of interacting processes may have the effect of combining local into global stores. Some semantic aspects of the cc-pi calculus are studied in [START_REF] Buscemi | Open bisimulation for the concurrent constraint pi-calculus[END_REF], where its is defined a notion of open bisimilarity à la pi-calculus for cc-pi. Essentially, two processes are open bisimilar if they have the same stores of constraints -which can be statically checked -and if their moves can be mutually simulated. In [START_REF] Buscemi | Open bisimulation for the concurrent constraint pi-calculus[END_REF] it is also shown that the polyadic Explicit Fusion calculus introduced by Gardner and Wischik can be translated into monadic cc-pi and such a transition preserves open bisimilarity.

In [START_REF] Buscemi | Transactional service level agreements[END_REF] a further extension of the cc-pi calculus is defined by including primitives for distributed nested commits, inspired by the cjoin calculus (introduced by Bruni, Melgratti, and Montanari). The two key operations of cjoin are: the 'abort with compensation', to stop a negotiation and activate a compensating process, and the 'commit', to store a partial agreement among the parties before moving to the next negotiation phase. This extended cc-pi calculus comes equipped with both a small-and a big-step operational semantics which are proved to coincide.

A different line of research is focused on the use of, so called soft constraint, to model qualitative aspects of Service Level Agreement in the context of the ccp paradigm. As described in more detail in another chapter of this book [START_REF] Gavanelli | Constraint Logic Programming[END_REF], soft constraints extend classical constraints to represent multiple consistency levels, and thus provide a way to express preferences, fuzziness, and uncertainty. An extension of the ccp framework which allows soft constraints in the calculus has been proposed in [START_REF] Bistarelli | Soft concurrent constraint programming[END_REF]. In this extension it is permitted to add (tell) or check (ask) for soft constraints and the language is enriched with tell/ask thresholds which can express the level of consistency of the store, thus allowing to prune and direct the search for a solution (when some consistency levels are not satisfied). The resulting language, called soft cc (scc), can be also very useful in many web-related scenarios, since allows web agents to express their interaction and negotiation protocols, and also to post their requests in terms of preferences. Differently from the case of "hard" (or "crisp") constraints, the underlying soft constraint solver here can find an agreement among the agents even if their requests are incompatible.

A timed extension of scc has been proposed in [START_REF] Bistarelli | Timed soft concurrent constraint programs[END_REF] in order to be able to express also Quality of Service aspects which involve time. As in the case of scc, tell and ask agents are equipped with a preference (or consistency) threshold which is used to determine their success or suspension. The time and the semantic model of this extension follows the lines of the tccp language presented in Section 5.

Another extension of scc, which allows the nonmonotonic evolution of the constraint store, is defined in [START_REF] Bistarelli | A nonmonotonic soft concurrent constraint language for sla negotiation[END_REF]. To accomplish this, some new operations are introduced: the retract(c) reduces the current store by c; the updateX(c) transactionally relaxes all the constraints of the store that deal with the variables in X set, and then adds a constraint c; the nask(c) tests if c is not entailed by the store. This language allows the management of resources that need a given Quality of Service: the requirements of all the parties should converge, through a negotiation process (which involves retract of information), on a formal agreement defined as the Service Level Agreement, which specifies the contract that must be enforced.

In this section we shall briefly survey some existing working ccp systems.

The programming language jcc [START_REF] Saraswat | jcc: Integrating timed default concurrent constraint programming into java[END_REF] was designed as an integration of default tcc into Java and is intended for embedded reactive systems. In jcc users can define their own constraint system and thus specialize the language to particular domains. The main purpose of jcc is to provide a model of loosely-coupled concurrent programming in Java. The language introduces the notion of a vat. A vat can be thought of as encapsulating a single synchronous, reactive tcc computation. A computation consists of a dynamically changing collection of interacting vats, communicating with each other through shared, mutable objects called ports. Asking and telling objects can read from and write into the port, respectively and the temporal constructs from the underlying tcc model allow an object to specify code whose execution should be delayed.

In the hybrid concurrent constraint programming language, hcc [START_REF] Gupta | Computing with continuous change[END_REF], it is possible to express discrete and continuous evolution of time. More precisely, there are points at which discontinuous change may occur (i.e. the execution proceeds as burst of activity) and open intervals in which the state of the system changes continuously (i.e. the system evolves continuously and autonomously). The notion of continuous constraint system (a real-time extension of constraint systems) is introduced to describe the continuous evolution. The syntax of hcc extends that of tcc with the construct hence P , asserting that P holds continuously beyond the current instant. An interpreter of hcc can be found at http://www-cs-students.stanford.edu/∼vgupta/hcc/hcc.html.

NtccSim is a simulation tool developed in Oz for ntcc, one of the temporal models previously described . Constraints over finite domains and real intervals have been used to implement models of biological systems. NtccSim can be found at http://cic.javerianacali.edu.co/wiki/doku.php?id=grupos:avispa:ntccsim. An implementation of the other temporal model previously described, tccp, can be found at http://users.dsic.upv.es/∼villanue/tccpInterpreter.

The LMNTAL model [START_REF] Ueda | LMNtal as a unifying declarative language: Live demonstration[END_REF] provides a scalable, uniform view of concurrent programming concepts such as processes, messages, synchronous and asynchronous computation. It inherits ideas from the concurrent constraint language GHC and from Janus. Communication is based on constraints over logical variables. Processes sharing variables are thought of as been connected. Multisets of nested nodes and links are a first-class notion in LMNtal. Transformations are rules, much like in Janus. LMNtal provides both channel mobility and process mobility: it allows dynamic reconfiguration of process structures as well as the migration of nested computations. An implementation of LMNtal can be found at http://www.ueda.info.waseda.ac.jp/lmntal/.

CORDIAL [START_REF] Rueda | Integrating constraints and concurrent objects in musical applications: A calculus and its visual language[END_REF] is a visual language intended as a user transparent integration of constraints and objects. The language is based on a ccp calculus extended with the notion of objects and classes. Methods are represented as windows. Objects within methods are represented by closed contours. Object methods launch ccp processes that, in addition to the usual ask and tell operations, can send messages to other objects. Messages are objects connected by links to object mailboxes. Objects are identified by an associated constraint parametrized on a local variable (so-called self ). Senders willing to invoke some object method post a constraint involving some variable, say X, and then send the message to X. Any object such that its associated constraint can be entailed by the store conjoined with the constraint self = X, is eligible to accept the message. Some eligible object is then non-deterministically chosen to handle the message. This scheme allows very complex patterns of communication and mobility.

  (i) true ⊢ d xx , (ii) if z = x, y then d xy = ∃ z (d xz ⊔ d zy ), (iii) if x = y then d xy ⊔ ∃ x (c ⊔ d xy ) ⊢ c.

  (α,α ′ ) = = = =⇒ where α = c 1 .c 2 .c 3 . . . . and α ′ = c ′ 1 .c ′ 2 .c ′ 3 . . .. The observable input-output behaviour of an ntcc process is its set of stimulusresponse sequences. The strongest-postcondition, or quiescent behaviour, of a process P is the set of sequences on input of which P can run without adding any information whatsoever. More precisely, Definition 5 (Observables of ntcc). Let P be a process. The input-output behaviour of P is given by O io (P ) = {(α, α ′ ) | P (α,α ′ ) ====⇒}. The strongest postcondition of P is given by O sp (P ) = {α | P (α,α) ====⇒}.

n

  i=1 ask (c i ) → A i time-out(0 ) B as the agent now c 1 then A else ( now c 2 then A else . . .( now c n then A else ask (true) → B ) . . .)

  s(Ex):-∃ Alarm,O1,R1,O2,R2 ((do p1(Ex,O1,R1) p2(Ex,O2,R2) watching Alarm = on) controller(O1,O2,R1,R2)) controller(O1,O2,R1,R2):-∃ A1,A2 (do c(O1,A1) c(O2,A2) watching Alarm = on else (now (A1 = on ⊔ A2 = on) then rr(R1) rr(R2) else now A1 = on then rr(R1) else now A2 = on then rr(R2)) restart(Ex)) c(O,A):-ask (∃ Y.O=[ok|Y]) → (∃ Y tell(O=[ok|Y]) →c(Y,A)) timeout(n) tell(Alarm = on ⊔ A = on)

  Table 1 and Rules R6-R8. The observable reduction =⇒ is given by Rule ROBS. The relation -→ * denotes transitive and reflexive closure of -→. γ -→ holds iff that is no γ ′ such that γ -→ γ ′ . The function F is given in Definitions 4


Achille Schiavone
email: achille.schiavone@unito.it

Riccardo Chiarini

Margherita Marzoni

Annelisse Castillo

Sonia Tassone

Isabella Romboli

Muscovy ducks fed on a microalga (Crypthecodinium cohnii) meal supplemented diet

Keywords: Ducks, Meat, Fats and fatty acids

teaching and research institutions in France or abroad, or from public or private research centers.

Breast meat traits of Muscovy ducks fed on a microalga (Crypthecodinium cohnii) meal supplemented diet

INTRODUCTION 12

In human nutrition, the biological effect of n-3 long chain polyunsaturated fatty 13 acids (LC-PUFAs) has received great interest as they play an active role in the 14 prevention and management of several pathologies such as coronary heart disease, 15 hypertension, type 2 diabetes, renal disease, ulcerative colitis, chronic obstructive 16 pulmonary disease and Crohn's disease (Simopoulos, 2000). The main molecules 17 of the n-3 LC-PUFAs family involved in the beneficial biological effects are 18 eicosapentaenoic acid (EPA, C20:5 n-3), docosapentaenoic acid (DPA, C22:5 n-3) 19 and docosahexaenoic acid (DHA, 22:6 n-3). The current Western diet is 20 characterised by low fish consumption, representing the main source of n-3 LC-21

PUFAs, and a high consumption of products from terrestrial animal origin, 22 characterised by a large content of PUFAs of the n-6 series (Simopoulos, 2000). 23 On the other hand, the nutritional value of these products rich in n-6 PUFAs, such as poultry meat, could be enhanced by increasing the n-3 LC-PUFAs content. In 1 fact, several studies aimed to enrich poultry products with n-3 LC-PUFAs 2 indicated fish oil as the most effective source for this purpose (Hargis and Van 3 Elswyk, 1993; [START_REF] Leskanich | Manipulation of n-3 16 polyunsaturated fatty acid composition of avian eggs and meat[END_REF]. Our previous experience showed an 4 increase in the amount of LC-PUFAs in duck meat with dietary fish oil 5 (Schiavone et al., 2004). The recommendation of the European Union (decision 6 00/766/EU), concerning the ban on the use of animal proteins in animal nutrition, 7 and the consumers' preferences, stimulated the interest in making diets for birds 8 using exclusively vegetable ingredients. 9

This investigation aimed to increase the docosahexaenoic acid (DHA) 10 content of the breast muscle of Muscovy ducks. Therefore, ducks were fed on a 11 diet supplemented with marine microalga meal at the end of the finisher period. 12

The microalga Crypthecodinium cohnii, a non-photosynthetic marine 13 dinoflagellate, rich in DHA [START_REF] Jiang | Production potential of 4 docosahexaenoic acid by the heterotrophic marine dinoflagellate Crypthecodinium 5 cohnii[END_REF] was included in the diet and its 14 effect evaluated at the minimum slaughter age for Muscovy ducks. Besides, meat 15 sensory evaluation was performed to exclude the presence of a disagreeable taste. 16 AG DHA ®). The two diets were formulated to be isoenergetic and 9 isonitrogenous (Table 1). Each diet was randomly assigned to three pens for each 10 sex. Olive oil was used as fat source for both diets. During the trial, individual 11 duck body weight and feed consumption per pen were recorded weekly to 12 calculate the feed conversion ratio (FCR). 13

MATERIALS AND METHODS 17

Carcase assessment and meat quality 14

At the minimum slaughter age, seven 71-d old males and seven 64-d old females 15 per dietary treatment were sacrificed by electrical stunning followed by neck-16 cutting, after a 12-h starving period. Eviscerated and plucked carcases were 17 weighted after removal of the feet and abdominal fat to obtain ready to cook 18 carcases (RCC). Breast fillets and liver were excised from refrigerated RCC (6 19 hours at +4°C) and weighed to evaluate slaughter traits. 20

Just before the dissection, pH and colour measurements of Pectoralis 21 major muscles were determined. pH was measured using a Hanna Instruments 22 8417 pH-meter supplied with a Hamilton Biotrode electrode. Meat colour 23 (CIELAB system: L*, a*, b*) was measured on breast muscle surface using a 24 Minolta Chroma-Meter CR-300 colour analyser. 25 Pectoralis major muscle was vacuum-packaged and frozen (-20°C) for 1 analytical and sensory determinations described below. AOAC methods (1990) 2 were used to assess moisture, ash, protein and ether extract and results were 3 expressed as percentage on a fresh matter basis. Fatty acid composition of both 4 breast muscle and diets was ascertained by capillary gas chromatography after 5 lipid extraction (Folch et al., 1957) and esterification (Christie, 1982), using 6 sodium methoxide as catalyst. Fatty acid methyl esters were analysed by a Perkin-7

Elmer AutoSystem gas-chromatograph, equipped with a flame ionisation detector 8 and a Supelco Omegawax 320 capillary column (30 m x 0.32 mm, 0.25 µm film). 9

Each fatty acid peak was identified by pure methyl ester standards (Supelco and 10

Restek Corporation, Bellefonte, PA) and data were conveyed as relative values. 11 Susceptibility to lipid oxidation was estimated from thiobarbituric acid 12 reactive substances (TBARS) according to the iron-induced TBARS procedure, 13 described by [START_REF] Huang | Iron-induced TBARs as an indicator of 1 oxidative stability of fresh chicken meat[END_REF]: 3 g of minced breast were homogenised in 14 57 ml of a chilled 1.15% KCl solution; 30 ml of the homogenate were incubated 15 at 37°C in a shaking water bath with 8.34 mg FeSO 4 •7H 2 O (final concentration 1 16 mM Fe +3 ) as oxidative agent. The iron-induced TBARS assay was performed at 0, 17 60 and 120 minutes of incubation and the absorbance was read at 532 nm.

Statistical analysis 9

Measurements of in vivo performances, slaughter traits, chemical composition, 10 fatty acid profile and sensory analysis of meat were split by sex and analysed with 11 a linear model including the fixed effect of diet (SPSS, 1997). Significance of 12 differences was evaluated by t-test. 13 RESULTS 14

Fatty acid composition of microalga meal was characterised by a 30.6% DHA 15 content. The 5 g/kg inclusion of microalga meal in MA diet resulted in a 2.3 g/kg 16 content of DHA of total fatty acids, while DHA in the C diet was not detected 17 (Table 1). Growth performances, slaughter traits and breast muscle traits (colour, 18 pH and chemical composition) were not influenced by dietary treatments (Tables 19 2, 3 and 4). Similarly, susceptibility to lipid oxidation was not affected by the 20 diet (Table 4). Besides, the inclusion of microalga did not influence tenderness, 21 juiciness, fibrousness and acceptability of meat (Table 4). 22

Fatty acid composition of breast meat (Table 5) was affected (P < 0.05) by 23 the diet. In particular DHA content was significantly higher in birds fed on the 24 MA diet (+ 2.9 fold in males and + 2.8 fold in females, for MA and C diet, 25 significantly influenced the total n-3 PUFAs amount (+ 1.9 fold in males and + 2 1.8 fold in females, for MA and C diet, respectively) and the n-6/n-3 ratio (-1. 8 3 fold in males and -1.9 fold in females, for MA and C diet respectively). 4 DISCUSSION 5

Our results of moisture, protein and lipid contents in breast meat, 74. [START_REF] Klasing | Lipids[END_REF] Avian fatty acids are typically monounsaturated, due to an active hepatic 9 delta-9 desaturase, and an oleic and palmitoleic acid predominance. Domestic 10 granivores use dietary carbohydrate for de novo fatty acid synthesis. Birds 11 usually, except for some species, lack the enzymatic capacity to introduce double 12 bonds past the ninth carbon of the fatty acid. Thus, they cannot use stearic acid to 13 synthesise linoleic acid or alpha-linolenic acid, which are essential fatty acids in 14 birds [START_REF] Klasing | Lipids[END_REF]. Dietary provision of lipids was shown to influence the 15 composition of phospholipid membranes and adipose depots. In fact, 16 susceptibility of avian tissues and yolk lipids to fatty acid manipulation has been 17

reviewed by [START_REF] Leskanich | Manipulation of n-3 16 polyunsaturated fatty acid composition of avian eggs and meat[END_REF] and Hargis and Van Elswyk (1993). [START_REF] Liu | Assay of aldehydes 19 from lipid peroxidation: gas chromatography-mass spectrometry compared to 20 thiobarbituric acid[END_REF] Thus, the enrichment of poultry products with n-3 fatty acids, especially those 19 with a number of carbons up to 20, is the main goal of fatty acid manipulation. 20 Maldijan et al. (1996) showed that phospholipid fatty acid composition of eggs 21 from chicken and duck (Anas platyrhynchos L.) markedly differed. The 22 phospholipid fraction of duck eggs has higher proportions of arachidonic acid and 23 lower proportions of DHA than chicken eggs. This shows that duck liver is quiet 24 efficient at converting dietary 18:2 n-6 into 20:4 n-6, whereas in chicken the 25 antioxidant molecules (Surai, 1999). Our data on iron-induced TBARS showed no 22 differences between groups in spite of the increase in DHA amount in animals fed 23 on the diet supplemented with the microalga meal. This might be explained by the 24 fact that the content of naturally occurring carotenoids, such as beta-carotene and 25 (5.5% of diet) were judged "undesirable". 17

In conclusion the 5 g/kg inclusion of microalga Crypthecodinium cohnii in 18 the diet, provided for the last 21 d of life, improved DHA content in the duck meat 19 without negative influences on sensory traits of the breast meat. 20 Also, the dietary microalga did not negatively influence growth 21 performances or slaughter traits. In addition, chemical composition, colour, pH 22 and oxidative stability of breast muscle were not influenced by the microalga 23 supplemented diet. Muscovy duck appeared to react positively to this dietary 24

Animals and diets 18

 18 Muscovy ducklings (Cairina moschata domestica L.) of both sexes of an Italian 19 rural strain, hatched at the Experimental Avian Station of the Department of 20 Animal Production of Pisa (Italy), were used for this trial. The experimental 21 protocol was approved by the Ethics Committee of the Faculty of Veterinary 22 Medicine of Pisa, Italy. All animal housing conformed to European Union 48 males and 48 females were distributed by sex in 6 pens, 1 respectively. Density was 3.5 males/m 2 and 4 females/m 2 . All ducks received the 2 same diet before the beginning of the experimental trial: a starter diet (12.1 MJ 3 ME/kg and 240 g of crude protein/kg), and a finisher diet (12.0 MJ ME/kg and 4 200 g of crude protein/kg). The trial began when male ducks and female ducks 5 were 50 and 43 d old, respectively. During the 21-d experimental period the 6 finisher diet (Control diet, C) was compared with the same diet enriched with 5 7 g/kg dried microalga Crypthecodinium cohnii (Microalga diet, MA) (Algamix -8

6 A

 6 Liquid 18 malonaldehyde bis (diethyl acetal) (MDA) (Aldrich Chemical Co Ltd, Dorset 19 England) was used as the standard to determine the linear standard response and 20 recovery. TBARS values were calculated by multiplying absorbance by a constant 21 coefficient K (23.58), combining standard response, recovery (93.4%), molecular 22 weight of the MDA and sample weight. TBARS values were expressed as mg 23 MDA/kg fresh meat. 24 sensory panel test was performed on Pectoralis major muscle, without 1 skin, roasted in a hot air oven at 165°C until an internal temperature of 70°C, 2 without salt or spices and skin. Cooked samples were immediately sliced into 8 3 pieces and randomly offered to 6 trained panellists. The trial consisted of 4 4 sessions and the traits assessed were: tenderness, juiciness, fibrousnesses and 5 acceptability. A 5-point scale was used: 1 referring to very disagreeable, very 6 tough, very dry, very fibrous and 5 to very agreeable, extremely tender, very 7 juicy, without fibre (Cross et al. 1986). 8

  The improvement of DHA content in breast muscles due to MA diet 1

  :3 n-3 into 22:6 n-3 has priority. Thus, variations in the fatty acid 1 profiles of yolk lipids may be derived from dietary provision of PUFAs as well as 2 genetic differences among avian species regarding liver metabolic activities. 3 However, in broiler chicken the capability to transfer LC-PUFAs from liver to 4 peripheral tissue seems to be less effective than the mechanism involved in the 5 incorporation of these in the yolk lipids. In fact Lopez-Ferrer et al.(2001) showed 6 that dietary linolenic acid (28% of total dietary fatty acid) stimulates hepatic 7 metabolic pathways involved in the elongation and desaturation of C18:3 n-3 into 8 22:6 n-3 (5.67%-7.16% of total fatty acid), resulting in an inefficient build-up in 9 thigh muscles (0.25% of total fatty acid). Similarly, in turkey, the conversion of 10 C18:3 n-3 to EPA and DHA is weak. According to Komprda et al. (2005) the 11 administration of three different diets containing 1.9%, 36.5% and 1.1% alpha-12 linolenic acid resulted in 6.8%, 9.0% and 5.7% EPA+DHA in breast meat. 13 Dietary algae have been successfully used in the nutrition of laying hens 14 (Herber and van Elswyk, 1996; Nitsan et al., 1999; Tallarico et al., 2002), broiler 15 chickens (González-Esquerra and Leeson, 2001; Mooney et al., 1998; Sirri et al., 16 2003a; Sirri et al., 2003b) to obtain enriched poultry products, characterised by a 17 significant amount of DHA or EPA, which could contribute to the novel concept 18 of "functional food" in human nutrition (Garg et al., 2006; Almeida et al., 2006). 19 In biological tissues and fluids, susceptibility to lipid oxidation is related to fatty 20 acid chain length, number of double bonds (Liu et al., 1997) and amount of 21

  Crypthecodinium cohnii (Barclay et al., 1994), may provide 1 LC-PUFAs stabilisation due to their antioxidant properties (Surai, 2002). Other 2 authors studied the effect of other dietary microalgae on lipid stability of avian 3 meat. No differences were found by Mooney et al. (1998) in breast meat TBARS 4 values among chickens fed on 0%, 2.8% and 5.5% of dried Schizochytrium. Sirri 5 et al. (2003a and 2003b) studied the effect of 0.0%, 0.5% and 1.0% dietary 6 Schizochitrium in broiler chicken on lipid stability of both drumstick and breast 7 meat. TBARS values of drumstick meat were not influenced by dietary 8 Schizochytrium, oppositely breast meat TBARS values of the same birds receiving 9 1.0% Schizochytrium appeared to be significantly higher than those from birds fed 10 on 0.0 and 0.5% alga meal. 11 The 5 g/kg inclusion of Crypthecodinium cohnii did not affect the sensory 12 panel test, agreeing with the results shown by Sirri et al. (2003b) when 13 Schizochytrium were administered to chickens. Likewise Mooney et al. (1998) 14 referred no modification of flavour in fresh chicken meat, while cooked meat 15 samples from the experimental group with the highest level of Schizochytrium 16

  , the use of Crypthecodinium cohnii could be used as a 1 dietary strategy to enhance n-3 PUFA in duck meat. 2In conclusion this DHA-enriched meat could contribute to human 3 nutrition, providing an increase of about three-fold in DHA content compared to 4 meat from ducks fed on a diet without microalga meal supplementation. 5 .R., MEAGER K.M., & ABRIL, J.R.(1994). Heterotrophic 1 production of long chain omega-3 fatty acid utilizing algae and algae-like 2 microorganisms. Journal of Applied Phycology, 6: 123-129. 3 CHRISTIE, W.W. (1982). A simple procedure for rapid transmethylation of 4 glycerolipids and cholesteryl esters. Journal of Lipid Research, 23: 1072-1075. 5 CIELAB Colour System (1976). Commission International de l'Eclairage. Paris: 6 CIE Publication. 7 CROSS, H.R., DURLAND, P.R., & SEIDEMAN, S.C. (1986). Sensory qualities 8 of meat, in P.J. BECHTEL (Ed.), Muscle as food, pp. 279-3290 (Orlando, 9 Harcourt Brace Jovanovich). 10 FOLCH, J., LEES, M., & SLOANE-STANLEY, H. (1957). A simple method for 11the isolation and purification of total lipids from animal tissue. Journal of Biology 12 Chemistry, 226: 479-509. 13 GARG, M.L., WOOD, L.G., SINGH, H., & MOUNGHAN, P.J. (2006). Mean of 14 delivering recommended levels of long chain n-3 polyunsaturated fatty acids in 15 human diets. Journal of Food Science, 71 (5): 66-71. 16 GONZÁLEZ-ESQUERRA, R., & LEESON, S. (2001). Alternatives for 17 enrichment of eggs and chicken meat with omega-3 fatty acids. Journal of Animal 18 Science, 81 (3): 295-305. 19 HARGIS, P.S., & VAN ELSWYK, M.E. (1993). Manipulation of fatty acid 20 composition of poultry meat and eggs for the health conscious consumer. World's 21 Poultry Science Journal, 49: 257-264. 22 HERBER, S.M., & VAN ELSWYK, M.E. (1996). Dietary marine algae promotes 23 efficient deposition of n-3 fatty acids for the production of enriched shell eggs. 24 Poultry Science, 75: 1501-1507. 25 ., CRISTOFORI, C., NOBLE, R.C., & SPEAKE, B.K. (1996). 1 The fatty acid composition of brain phospholipids from chicken and duck 2 embryos. Comparative Biochemistry and Physiology B, 115B: 153-158. 3 MOONEY, J.W., HIRSCHLER, E.M., KENNEDY, A.K., SAMS, A.R., & VAN 4 ELSWYK, M.E. (1998). Lipid and flavour quality of stored breast meat from 5 broilers fed marine algae. Journal Science of Food Agriculture, 78: 134-140. 6 NITSAN, Z., MOKADY, S., & SUKENIK, A. (1999). Enrichment of poultry 7 products with n-3 fatty acids by dietary supplementation with the alga 8 Nannochloropsis and mantur oil. Journal of Agriculture Food Chemistry, 47: 9 5127-5132. 10 PAQUIN, J. (1988). Valeur nutritionelle des viandes de volailles, in ROSSET, R. 11 (Ed.) L'aviculture française. Informations Techniques des Services Vétérinaires 12 (Paris). 13 SCHIAVONE, A., ROMBOLI, I., CHIARINI, R., & MARZONI, M. (2004). 14 Influence of dietary lipid source and genotype on fatty acid composition of 15 Muscovy duck meat. Journal of Animal Physiology and Animal Nutrition, 88: 88-16 93. 17 SIMOPOULOS, A.P. (2000). Human requirement for n-3 polyunsaturated fatty 18 acid, Poultry Science, 79: 961-970. 19 SIRRI, F., MINELLI, G., IAFFALDANO, N., TALLARICO, N., & 20 FRANCHINI, A. (2003a). Oxidative stability and quality traits of n-3 PUFA 21 enriched chicken meat. Italian Journal of Animal Science, 2(1): 450-452. 22 SIRRI, F., MINELLI, G., MELUZZI, A., & FRANCHINI, A. (2003b). Quality 23 traits and oxidative stability of n-3 PUFA enriched meat, in: BAEZA, E. & 24 . (Eds.). Proceedings of the XVI European Symposium on the 1 Quality of Poultry Meat, Saint-Brieuc, pp. 258-264. 2 SPSS (1997). Guida dell'utente SPSS, base 7.5 per Windows ®. (Inc. Chicago, 3 Illinois. U.S.A.). 4 SURAI, P.F. (1999) Vitamin E in avian reproduction. Poultry and Avian Biology 5 Reviews, 10 (1), 1-60. 6 SURAI, P.F. (2002) Carotenoids in natural antioxidants in avian nutrition and 7 reproduction. Nottingham University Press (U.K), pp 129-200. 8 TALLARICO, N., SIRRI, F., MELUZZI, A., PITTIA, P., PERPINELLO, G.P., & 9 FRANCHINI, A. (2002). Effect of dietary vegetable lipids on functional and 10 sensory properties of chicken eggs. Italian Journal of Food Science, 14 (2):

3 3

 3 mg; pyridoxine 1.5 mg; cobalamin 0.015 mg; pantothenic acid 8.0 mg; niacin 25 mg; choline chloride 500 mg; Fe (FeSO4 4 . 7H2O), 30 mg; Cu (CuSO4 . 5H2O) 1.5 mg; Mn (MnSO4 . H2O) 80 mg; Zn (ZnSO4 . 7H2O) 30.0 mg; I (KI) 1.4 mg. 5 b saturated fatty acids; c unsaturated fatty acids; d monounsaturated fatty acids;

Table 1

 1

	near here

  [START_REF] Baéza | 18 Effect of selection, over three four generations, on meat yield and fatness in 19 Muscovy ducks[END_REF][START_REF] Baéza | Effect of selection for improved body weight and composition on muscle 22 and meat characteristics in Muscovy duck[END_REF][START_REF] Koci | Carcass 9 and nutritive value of the small white broiler duck and its crosses[END_REF] Paquin, 1988). 8

	6	-76.8 %,
	7	20.2 -21.2 %, 0.99 -1.06 % respectively, are similar to those reported by other
		authors, (

Table 5

 5

	near here

Table 1 .

 1 Ingredients, chemical and fatty acid composition

	1
	2	of the diets
			Experimental period
			(last 21 d of life)
			C diet	MA diet
	Ingredients (g/kg)
	Maize meal		598	602
	Soybean meal		340	333
	Dicalcium phosphate		20	20
	Calcium carbonate		17	17
	Sodium chloride		2	2
	DL-methionine		2	2
	L-lysine		1	1
	Vitamin and mineral premix a	5	5
	Olive oil		15	13
	Crypthecodinium cohnii meal	-	5
	Chemical composition (g/kg)
	Dry matter		878.1	878.6
	Crude protein		200.1	202.6
	Ether extract		34.4	37.3
	Crude fibre		29.2	31.4
	Ash		67.7	63.2
	Metabolisable energy (MJ/kg)	12.09	12.07
	Fatty acid composition
	(g/100 g fatty acid)
	C14:0		0.11	0.31
	C16:0		13.89	13.92
	C16:1n7		0.33	0.34
	C18:0		3.06	2.81
	C18:1n9ct		31.84	31.80
	C18:2n6c		45.19	45.45
	C18:3n3		1.99	1.72
	C22:6n3		-	0.23
	SFAs b		17.96	17.98
	UFAs c		79.81	79.65
	SFAs/UFAs		0.23	0.23
	MUFAs d		32.38	32.45
	PUFAs e		47.43	47.20
	n6		45.48	45.22
	n3		1.95	1.99
	n6/n3		23.00	23.00
	a provided per kg of diet: retinol 3 mg; cholecalciferol, 45 mg; DL-α-tocopheryl acetate 30 mg; thiamine 1.5 mg; riboflavin

Table 2 .

 2 Effects of microalga meal incorporation in diets for 3 weeks on growth

	1
	2		performance of Muscovy ducks (means, n = 24)
	3
			Females			Males
			C	MA SEM	P	C	MA SEM P
		Initial age	d 43	43			50	50
		Final age	d 64	64			71	71
		Initial LW a	g 1343 1369 21.05	ns	2314 2318 32.64	ns
		Final LW	g 1893 1909 22.72	ns	3314 3339 41.55	ns
		Total body
		weight gain	g 550	540 11.44	ns	1000 1021 24.34	ns
		ADG b	g 26.20 25.71 0.54	ns	47.64 48.62 1.16	ns
		FCR c	5.31	5.03	0.11	ns	4.36	4.00	0.11	ns
	4
	5	a Live body weight.
	6	b Average daily weight gain.
	7	c Feed conversion ratio (n = 3 for females; n = 4 for males).

Table 3 .

 3 Effects of microalga meal incorporation in diets for 3 weeks on slaughter

	1
	2		traits of Muscovy ducks (means, n = 7)
	3
				Females	Males
				(64 d old)	(71 d old)
				C	MA SEM P	C	MA	SEM P
		LW a	g	1895	1918 24.89 ns	3443	3454 23.12 ns
		RCC b	g	1171	1193 16.07 ns	2163	2181 20.72 ns
		%LW 61.78	62.23 0.46 ns	62.82	63.14	0.53 ns
		BM c	g 244.40 249.26 4.98 ns	431.20 432.17 14.67 ns
		%RCC 20.88	20.90 0.42 ns	21.27	21.69	0.32 ns
		Liver	g 27.54	28.60 1.31 ns	67.76	70.53	3.93 ns
		%RCC 2.35	2.40 0.11 ns	3.18	3.24	0.19 ns
	4	a Live body weight.
	5	b Ready to cook carcase.
	6	c Breast muscles.

Table 4 .

 4 Effects of microalga meal incorporation in diets for 3 weeks on physico-

	1
	2	chemical characteristics, oxidation susceptibility and sensory traits of the
	3	Pectoralis major muscle from Muscovy ducks (means, n = 7 or 5 for chemical
	4				composition)
	5
				Females			Males
			C	MA	SEM	P	C	MA SEM	P
		pH a	5.64	5.67	0.04	ns	5.75	5.69	0.03	ns
		Chemical composition a
		Moisture -%	74.61 75.20 0.22	ns	76.77	76.57	0.09	ns
		Protein -%	21.15 20.90 0.11	ns	20.59	20.17	0.20	ns
		Fat -%	1.06	1.00	0.09	ns	0.99	1.02	0.06	ns
		Ash -%	1.35	1.36	0.02	ns	1.23	1.26	0.02	ns
		Iron-induced TBARS (mg MDA kg -1 meat) a
		0 minutes	0.54	0.41	0.10	ns	0.88	1.20	0.22	ns
		60 minutes	0.97	0.83	0.11	ns	1.89	2.46	0.37	ns
		120 minutes	1.62	1.41	0.15	ns	1.63	2.18	0.27	ns
		Colour a
		L*	44.95 45.14 0.55	ns	46.28	46.84	0.41	ns
		a*	17.71 17.98 0.54	ns	17.07	16.68	0.30	ns
		b*	5.46	5.54	0.29	ns	4.53	4.70	0.36	ns
		Sensory traits b
		Tenderness	3.48	3.35	0.09	ns	3.35	3.21	0.13	ns
		Juiciness	3.39	3.08	0.14	ns	2.73	2.78	0.17	ns
		Fibrousness	3.32	3.04	0.13	ns	2.62	2.55	0.10	ns
		Acceptability	3.03	2.96	0.15	ns	2.48	2.83	0.103	ns
	6	a results are means of two replicate analyses.
	7	b each value is the mean of the judgement of 4 panellists.

Table 5 .

 5 Effects of microalga meal incorporation in diets for 3 weeks on fatty acid 1 composition (% of total fatty acids) of the Pectoralis major muscle from Muscovy 2 ducks (means, n = 3, results are means of three replicates analyses)

	3
	4
	5
				Female			Male
			C	MA SEM	P	C	MA SEM	P
		C14:0	0.35	0.38 0.02	ns	0.36 0.33	0.04	ns
		C16:0	24.57 24.57 0.71	ns	24.00 22.36 0.55	ns
		C16:1n7	1.27	1.17 0.16	ns	2.09 1.40	0.45	ns
		C18:0	12.82 12.48 0.78	ns	12.29 13.17 0.76	ns
		C18:1n9ct	23.75 23.11 1.48	ns	23.73 23.31 1.73	ns
		C18:1n7	2.81	2.52 0.08	ns	2.64 2.44	0.16	ns
		C18:2n6c	16.85 17.03 0.45	ns	15.08 16.38 1.12	ns
		C18:3n3	0.36	0.36 0.05	ns	0.33 0.34	0.03	ns
		C20:4n6	8.87	9.10 0.96	ns	9.90 9.85	0.42	ns
		C20:5n3	0.06	0.11 0.02	ns	0.08 0.12	0.01	ns
		C22:4n6	1.99	1.80 0.21	ns	2.14 1.77	0.13	ns
		C22:5n6	1.24	1.04 0.15	ns	1.20 0.96	0.11	ns
		C22:5n3	0.40	0.39 0.07	ns	0.47 0.44	0.04	ns
		C22:6n3	0.70	1.97 0.11	< 0.05	0.74 2.12 0.18 < 0.05
		SFAs a	38.08 37.82 0.26	ns	37.01 36.25 0.37	ns
		UFAs b	60.06 61.73 0.40	ns	60.28 61.54 0.75	ns
		SFAs/UFAs 0.63	0.62 0.01	ns	0.61 0.59 0.01	ns
		MUFAs c	28.55 27.80 1.52	ns	29.13 27.80 2.05	ns
		PUFAs d	31.51 32.93 1.40	ns	31.16 33.74 1.80	ns
		n6	29.98 30.10 1.25	ns	29.50 30.65 1.61	ns
		n3	1.53	2.83 0.16	< 0.05	1.66 3.09 0.21 < 0.05
		n6/n3	19.85 10.65 1.05	< 0.05 17.84 9.98 0.67 < 0.001
	6
	7	a saturated fatty acids; b unsaturated fatty acids; c monounsaturated fatty acids;
	8	d polyunsaturated fatty acids.

E-mail: br.poultsci@bbsrc.ac.uk URL: http://mc.manuscriptcentral.com/cbps British Poultry Science

ACKNOWLEDGEMENTS 6

We are grateful to Mrs Manuela Baglini for duck breeding and Mrs Chiara 7

Bianchi for technical support. Acknowledgements are due to Bios Pan Srl 8 (Concordia sulla Secchia -MO, Italy) for providing the Algamix -AG DHA ®. 9