SSYMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY
DIEGO CONTI
Abstract.
We introduce the C ++ library Wedge, based on GiNaC, for sym-bolic computations in differential geometry. We show how Wedge makes itpossible to use the language C ++ to perform such computations, and illus-trate some advantages of this approach with explicit examples. In particular,we describe a short program to determine whether a given linear exterior dif-ferential system is involutive. Keywords : Curvature, differential forms, computer algebra, exterior differential systems.
Introduction
There are many computationally intensive problems in differential and Riemann-ian geometry that are best solved by the use of a computer. Due to the nature ofthese problems, any system meant to perform this type of calculations must beable to manipulate algebraic and differential expressions. For this reason, such sys-tems are generally implemented as extensions, or packages, for a general purposecomputer algebra system: the latter takes care of handling expressions, and the ex-tension introduces the differential-geometry specific features — differential forms,tensors, connections and so on. Examples are given by the packages difforms andGRTensor (see [9]) for Maple, or the Ricci package for Mathematica.A remarkable consequence of this approach is that one is essentially limited, whenimplementing one’s own algorithms, to using the programming language built in thecomputer algebra system. Some drawbacks and limitations of these programminglanguages are described in [1], where an alternative is also introduced, namely theC ++ library GiNaC. As suggested by the name (an acronym for GiNaC Is Not ACAS), GiNaC differs from the above mentioned computer algebra systems in thatit is based on a general purpose, well-established programming language such asC ++ , rather than introducing a new one. In particular, development, debuggingand documentation of a program based on GiNaC can take advantage of the manytools commonly available to a C ++ programmer. This makes GiNaC a naturalchoice when implementing new, complex algorithms, like the one introduced in [5],which provided the original motivation for the present work.In this paper we introduce Wedge, an extension to GiNaC that can be used towrite a C ++ program that performs computations in differential and Riemanniangeometry. Wedge is able to perform algebraic or differential computations withdifferential forms and spinors, as well as curvature computations in an adaptedframe, and contains some support for vector spaces, represented in terms of a basis.Bases of vector fields, or frames, play a central rˆole in Wedge: in particular, thetangent space of a manifold is represented by a frame, and a Riemannian metric Mathematics Subject Classification.
Primary 53-04; Secondary 53C05, 68W30, 58A15. a r X i v : . [ m a t h . DG ] A p r DIEGO CONTI is represented by a (possibly different) orthonormal frame. Notice that the above-mentioned package GRTensor also supports working with adapted frames, but ourapproach differs in that the frame need not be defined in terms of coordinates; thiscan be useful when working on a Lie group, where the geometry is defined natu-rally by the structure constants, or on the generic manifold with a fixed geometricstructure (see Section 2).Another unique feature of Wedge among packages for differential and Riemann-ian geometry, beside the choice of C ++ , is the fact that it is completely based onfree, open-source software. Like GiNaC, Wedge is licensed under the GNU generalpublic license; its source code is available at http://libwedge.sourceforge.net .This paper is written without assuming the reader is familiar with C ++ , and itspurpose is twofold: to introduce the main functionality of Wedge, and to illustratewith examples certain features of C ++ which can prove very helpful in the practiceof writing a program to perform some specific computation.In the first section we introduce some basic functionality, concerning differentialforms and connections; at the same time, we illustrate classes and inheritance.In the second section we introduce spinors and “generic” manifolds; at the sametime, we illustrate object-oriented programming.In the third section we explain briefly how GiNaC handles expressions, thenintroduce bases and frames, namely the linear algebra features of Wedge.In the final section we give an application from Cartan-K¨ahler theory, with ashort program that reproduces the computations of [3] that prove the local existenceof metrics with holonomy G .1. Working with differential forms and connections
A fundamental feature of C ++ is the possibility of introducing user-defined types,i.e. classes (or structs). The definition of a class specifies not only the type of datacontained in a variable which has that class as its type, but also some operationsthat can be performed on this data. This is generally better than having globalfunctions which either take a long list of arguments or use global variables, and thiscan be seen, for instance, in situations where more sets of data appear in the sameprogram. In this section we shall illustrate this point with an example, consideringa problem concerning multiple connections on a fixed manifold. In the course ofthe section, we shall introduce some of the essential functionality of Wedge.The basic geometric entity in Wedge is the class Manifold . A variable of type
Manifold represents a manifold in the mathematical sense, which is assumed to beparallelizable, and represented by a global basis of one-forms e , . . . , e n , with dualbasis of vector fields e , . . . , e n . This assumption is tailored on Lie groups, but onecan also think of a Manifold object as representing a coordinate patch; also, everymanifold can be written as a quotient
M/G of a parallelizable manifold, so onecan always reduce to the parallelizable case. For instance, one can compute thecurvature of a Riemannian metric on
M/G applying the O’Neill formula (see [10]).As an example, we shall consider the nilpotent Lie group X , characterized bythe existence of a global basis of one-forms e , . . . , e such that(1) de = 0 , de = 0 , de = e , de = e . YMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY 3
Figure 1.
Inheritance graph for classes inheriting from
Manifold
In the above equation, e stands for the wedge product e ∧ e , and so on; thisshorthand notation is also used by Wedge, and so it will appear throughout the pa-per in both formulae and program output. Equations (1) translate to the followingcode: struct X : public ConcreteManifold , public Has_dTable {X() : ConcreteManifold(4) {Declare_d(e(1),0);Declare_d(e(2),0);Declare_d(e(3),e(1)*e(2));Declare_d(e(4),e(1)*e(3));}}; The first line means that X inherits from the two classes ConcreteManifold and
Has dTable . Roughly speaking, this means that it inherits the functionalityimplemented by these two classes; inheritance defines a partial ordering relation,and is best represented by a graph (see Figure 1). Specifically, inheriting from
ConcreteManifold ensures that the forms e , . . . , e are defined (where the dimen-sion 4 appears as a parameter on the second line). The fact that X inherits from Has dTable means that the operator d on the manifold X is known in terms of itsaction on the basis e , . . . , e ; the relations (1) are given with calls to the memberfunction Declare d . These calls appear in the body of the constructor of X , whichis invoked automatically when a variable of type X is constructed. We can nowinstantiate a variable of type X and perform computations with it, e.g. X M;cout< The class Manifold also implements the Lie bracket and Lie derivative as mem-ber functions, whilst the exterior and interior product of forms are implementedby global functions. Covariant differentiation and curvature computations are ac-counted for by the class Connection , which we now introduce with an example.Every almost-complex manifold ( M, J ) admits an almost complex connection ˜ ∇ such that its torsion form Θ and the Nihenjuis tensor are related by16Θ( X, Y ) = N ( X, Y ) ;by [8] ˜ ∇ can be obtained from an arbitrary torsion-free connection ∇ by(2)˜ ∇ X Y = ∇ X Y − Q ( X, Y ) , Q ( X, Y ) = ( ∇ JY J ) X + J (( ∇ Y J ) X ) + 2 J (( ∇ X J ) Y ) . Suppose one wants to compute such a connection in the case of our nilpotent Liegroup X , with the almost-complex structure determined by J ( e ) = e , J ( e ) = e . We can do so with the following code: struct AlmostComplex : public X {TorsionFreeConnection This code defines and instantiates a struct named AlmostComplex inheriting from X ; AlmostComplex has a data member h of type TorsionFreeConnection DeclareNabla need not be elements of the frame(they can even be forms of degree higher than one, or, for Riemannian connectionsonly, spinors), and part of the connection forms may be left unspecified. However,said procedure only works because the Γ ijk are stored in the Connection object,which is how DeclareNabla knows it should leave the Γ ijk as parameters, and solvewith respect to the ˜Γ ijk .Summing up, we have illustrated how the fact that a connection is representedas an instance of a class makes working with two different connections on a fixedmanifold as natural as defining two variables of the same type.2. Torsion free connections and generic manifolds Class X from Section 1 represents a fixed manifold, where the action of the d operator can be recovered from its action on a basis of one-forms; we have seen thatWedge enables one to perform torsion computations, or impose torsion conditions.One can also go the other way, and compute the action of d in terms of the covariantderivative, with respect to a torsion-free connection. To illustrate this, suppose onehas a four-dimensional Riemannian manifold X , with a global orthonormal frame e , . . . , e . The parallelism induces a spin structure; in general, on a parallelizable n -dimensional manifold a spinor can be viewed as a map X → Σ, where Σ is the n -dimensional spinor representation. Let m = [ n/ 2] be the integer part of n/ 2; Σis a complex vector space of dimension 2 m , represented in Wedge in terms of thebasis u , . . . , u m − , where u k corresponds to u (( − (cid:15) m − , . . . , ( − (cid:15) ) , k = m − (cid:88) r =0 (1 − (cid:15) r )2 r in the notation of [2] (see also [6] for more explicit formulae). In our case, we candeclare that the constant spinor ψ : X → Σ, ψ ≡ u is parallel, i.e. ∇ e i ψ = 0 i = 1 , . . . , DIEGO CONTI with the following code: struct X : public ManifoldWith Hence, X is a generic parallelizable Riemannian 4-manifold with holonomycontained in SU(2); this condition does not determine the connection formuniquely, but it does impose certain conditions on them. Internally, the tem-plate class ManifoldWith LeviCivitaConnection TorsionFreeConnection All further code fragments appearing in this section will be as-sumed to appear in the body of the constructor of a class such as SomeCalculations of Section 1.In fact, whilst the new X does not derive from has dTable , the definition of SomeCalculations of Section 1 is still legitimate. Of course, the output will dependon the Γ ijk which in part are left unspecified. In particular, it is not possible toguarantee that d = 0, as this leads to an underdetermined system of differentialequations, quadratic in the Γ ijk and linear in their derivatives. However, thereare many interesting relations not involving the derivatives of the Γ ijk that can beproved using ManifoldWith . As a first example, we can verify that the existence ofa parallel spinor is equivalent to the existence of a local frame e , . . . , e such thatthe forms(4) e + e , e + e , e + e , are closed (see [7]). In our case, since we have chosen u as the parallel spinor, thestandard frame e , . . . , e satisfies this condition, and the code cout< Has dTable and ManifoldWith , and so the meaning of a call to d in the bodyof a member of X depends on whether X inherits from Has dTable , as was the casein Section 1, or ManifoldWith , as in the example above. In fact, C ++ allows evengreater flexibility, as we now illustrate with a second example. YMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY 7 In order to give a slightly more complicated application, we observe that ourmanifold X is in particular an almost-K¨ahler manifold with respect to any one ofthe closed two-forms (4); we shall fix the first one. Thus, it makes sense to considerthe bilagrangian splitting T X = F ⊕ G , where F = (cid:104) e , e (cid:105) and G = (cid:104) e , e (cid:105) ; thissplitting determines a canonical connection ω . By [11], the torsion of ω is zero ifand only if the distributions F and G are integrable. We can actually prove thisequivalence with Wedge; we shall illustrate the “only if” implication here. Connection omega(this,e(),"Gamma’");for (int k=1;k<=4;++k) {omega.DeclareNabla This code defines a generic connection ω , whose connection parameters are de-noted by Γ (cid:48) ijk to distinguish them from the parameters Γ ijk of the Levi-Civitaconnection, and imposes the two sets of conditions that determine the symplecticconnection. First, the holonomy is reduced to GL(2 , R ) by requiring that the sym-plectic form be parallel and the two Lagrangian distributions F and G preservedby the covariant derivative. Then one imposes ∇ X F Y G = [ X F , Y G ] G , ∇ X G [ Y F ] = [ X G , Y F ] F , X, Y ∈ Γ( T X ) , where the subscripts denote projection (reflected in the code by the use of the in-terior product function Hook ). Notice that LieBracket is a member function of Manifold , which ManifoldWith reimplements in terms of the Levi-Civita connec-tion; thus, its result depends on the Γ ijk . By the general theory, the conditionsdetermine ω completely, i.e. ω does not depend on the Γ (cid:48) ijk but only on the Γ ijk .Since this dependence is linear, the condition that the torsion is zero gives equa-tions in the Γ ijk that can be solved by the function DeclareZero , a member of ManifoldWith . Having imposed this torsion conditions, the program concludesthat [ e , e ] and [ e , e ] equal e Γ + e Γ , Γ e + Γ e respectively, proving that the distributions F and G are involutive.The code at work here uses a typical object-oriented programming technique.Specifically, Connection needs to compute the action of d in order to compute thetorsion; to this end, every Connection object contains a pointer to the Manifold object it refers to. In this case, the manifold to which ω refers is representedby a ManifoldWith object, which implements d using the Levi-Civita connection; DIEGO CONTI since d is a virtual function , the calls to d performed by Torsion execute theimplementation of ManifoldWith . In the examples of Section 1, those same callsexecute the implementation of Has dTable . This ensures that the torsion of ω is computed correctly in terms of the Γ ijk here, whereas the code of Section 1computes the torsion using the action of d on the forms e , . . . , e , although thefunction Torsion is exactly the same. Remark. There is nothing essential about the assumption that X has holonomySU(2). In fact, one can easily modify the code to obtain the same result for ageneric symplectic 4-manifold X .3. Forms and frames In this section we introduce the main linear algebra functionality of Wedge;before doing that, we need to explain how GiNaC handles expressions.We have seen in Section 1 that manifolds are represented in Wedge by a globalbasis of one-forms e , . . . , e n , which can be accessed via a member function of theclass Manifold . The C ++ type of a form, say X.e(1) , is the class ex defined in thelibrary GiNaC, which handles expressions such as , the result of whichis still an ex . The class ex acts as a proxy to the GiNaC class basic . In practice,this means that an ex contains the address of an object whose type is a classthat inherits from basic (e.g. add , representing a sum, or numeric representing anumber), and it is this object that performs the actual computations. The use ofvirtual functions ensures that the correct code is used, depending on the C ++ typeof the object the ex points to (for details, see [1]).Thus, while X.e(1) has type ex , under the hood it “refers” to an object of type DifferentialOneForm , and it is this type that implements skew-commutativity,making use of a canonical ordering that exists among basic objects. More signifi-cantly, objects of type DifferentialOneForm and linear combinations of them canbe used interchangeably; nonetheless, they can be distinguished by their internalrepresentation, since the former have type DifferentialOneForm and the latterhave type add (e.g. e(1)+e(2) ) or mul (e.g. ). We refer to objects in theformer category as simple elements. Mathematically, we are working with sparserepresentations of elements in the vector space generated by all the variables oftype DifferentialOneForm appearing in a program. All this works equally wellwith other types than DifferentialOneForm .In general, given a small set of vectors, it is possible to switch from sparse to denserepresentation by extracting a basis, and writing the other terms in components.This is accomplished by the class template Basis . As a simple example, suppose X defines the Iwasawa manifold, characterized by the existence of an invariant basis e , . . . , e satisfying de = 0 = de = de = de , de = e + e , de = e + e . We can compute a basis of the space of invariant exact three-forms with the fol-lowing code (with the usual convention of p. 6): Basis YMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY 9 resulting in the output e , − e , − e , e , e − e − e + e . One can then recover the components of, say, de by cout< Basis is based on the standard container vector , part of the Standard TemplateLibrary. So, a Basis object can be thought of as a sequence x , . . . , x n of ex , wherethe x k are linear combinations of simple elements of a given type T , which is atemplate parameter of Basis . However, Basis differs from vector in the followingrespects: • When elements are added to a Basis object, resulting in a sequence ofpossibly dependent generators x , . . . , x n , an elimination scheme is used toremove redunant (dependent) elements. This is done in such a way thatthe flag V ⊆ . . . ⊆ V n , V k = Span { x , . . . , x k } is preserved. • The first time the member functions Components or dual are called, Basis sets up some internal data according to the following procedure. First, theset S = S ( x , . . . , x m ) = { α simple | (cid:104) α, x k (cid:105) (cid:54) = 0 for some 1 ≤ k ≤ m } is computed; then, the sequence { x , . . . , x m } that represents the basisinternally is enlarged with elements x k ∈ S , m < k ≤ n so that { x , . . . , x n } is a basis of Span S. Then, for each α ∈ S the components b αj satisfying α = n (cid:88) j =1 b αj x j are computed; as a matrix, ( b αj ) is the inverse of the matrix with entries a jα = (cid:104) x j , α (cid:105) . The dual basis x , . . . , x n is then given by x k = (cid:88) α ∈ S b αk α. The actual code also take advantage of the fact that with a suitable orderingof the columns, one obtains the block form( a jα ) = (cid:18) ∗ ∗ I n − k (cid:19) . The dual basis and the b αj are cached internally, until the basis is modified. • The member function Components uses the pairing (cid:104) , (cid:105) to determine thecomponents with respect to S , then multiplies by the matrix ( b αj ) to obtainthe components with respect to the basis x , . . . x m .From the point of view of performance, the operations of Basis have the followingcomplexity, measured in term of the number of multiplications: • Given a list x , . . . , x n of elements which are known to be linearly indepen-dent, one can construct a Basis object with no overhead over vector andno algebraic operation involved. • Inserting elements y , . . . , y k in a Basis object consisting of elements x , . . . , x n has a complexity of O ( m ( n + k ) ), where m = | S ( x , . . . , x n , y , . . . , y k ) | . • Setting up a Basis object consisting of elements x , . . . , x n in order thatthe dual basis or components of a vector may be computed has a complexityof O (( n + m ) n ), where m = | S ( x , . . . , x n ) | . • Once the Basis object is so set up, computing the components of a vectorhas complexity O ( nm ).Since we work in the symbolic setting, the number of multiplications only givesa rough estimate of execution time. In any case, the above figures show the im-portance of being able to define a class that only performs certain operations whenit is needed. Again, this is something which can be achieved naturally in C ++ , bystoring a flag in each object Basis . Since a Basis object is only modified by in-voking certain member functions, the flag is cleared automatically when the objectis modified, effectively invalidating the cached values of b αj . Remark. The frames associated to a Manifold , RiemannianStructure or Connection object are represented by Basis objects; thanks to the mechanismsdescribed in this section, these frames need not consist of simple elements. In fact,this was the main motivation for introducing Basis .4. An application: Cartan-K¨ahler theory In this section we consider, as an application, the problem of determining whethera linear exterior differential system (EDS) is involutive. This problem eventuallyboils down to computing the rank of certain matrices, but actually writing down YMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY 11 these matrices requires a system that supports differential forms and interior prod-ucts, as well as linear algebra; this makes Wedge particularly appropriate to thetask.Suppose we have a real analytic EDS with independence condition ( I , θ , . . . , θ k )on a manifold X . As a special case, we shall take X to be the bundle of frames overa 7-manifold M , the θ i the components of the tautological form and I generatedby the exterior derivative of the G -forms φ and ∗ φ . We wish to determine whetherthe system is involutive, i.e. every point of X is contained in some submanifold S ⊂ X such that all the forms of I vanish on S and the forms θ | S , . . . , θ k | S are abasis of the cotangent bundle T ∗ S ; we then say that S is an integral manifold for I . In the special case, the EDS turns out to be involutive, proving the existence oflocal metrics with holonomy G (see [3]).The general procedure is the following. Complete θ , . . . , θ k to a basis θ , . . . , θ k , ω , . . . , ω n of 1-forms on X . Suppose that E ⊂ T x X is a k -dimensionalsubspace such that the forms θ | , . . . , θ k are independent on E ; then one can write ω i | E = p ij θ j | E . We say that E is an integral element if the forms of I restrict to 0 on E . The( x, p ij ) are coordinates on the Grassmannian of k -planes over I , and by definitionthe tangent space of an integral manifold at each point will be an integral element E of the form above. The integral elements of dimension n form a subset V n of theGrassmannian.Suppose that there exists an integral element E ⊂ T x X , and V n is smooth about E . By the Cartan-K¨ahler theory, the (local) existence of an integral manifold S with T x S = E is guaranteed if one can find a flag E ⊂ . . . ⊂ E k = E, dim E k = k, such that dim V n = c + . . . + c k , where c j is the dimension of the space of polar equations H ( E j ) = { α ( e , . . . , e j , · ) | α ∈ I , e l ∈ E j } ⊂ T ∗ x X. Since we are assuming that E j is contained in an integral element E , H ( E j ) hasthe same dimension as its image H ∗ ( E j ) under the quotient map(5) T ∗ x X → T ∗ x X (cid:104) θ , . . . , θ k (cid:105) . We shall say that a system is linear if I ⊂ Λ ∗ Span { e , . . . , e k } ∧ Span { ω , . . . , ω n } , where the span is over C ∞ ( X ). This condition implies that the equations defining V n are affine in the p ij . In addition, one has H ∗ ( E j ) = H ∗ ( E (cid:48) j ), where E (cid:48) j is thehorizontal projection of E j determined by the splitting (cid:104) θ , . . . , θ k , (cid:105) ⊕ (cid:104) ω , . . . , ω n (cid:105) . One can compute the dimension of V n and the c i with the surprisingly shortprogram of Fig. 2. This program represents the frame bundle P as a parallelizablemanifold with a frame ( θ i , ω jk ), where the θ i are the components of the tautological form, and the ω jk are the components of a torsion-free connection form, related bythe structure equation de i = e j ∧ ω ij . The member function GetEquationsForVn simply replaces every occurrence of ω jk with p jk in terms of the coordinates p ij of the Grassmannian, and im-poses that the coefficients of the resulting forms are zero. The member function GetReducedPolarEquations , on the other hand, calls itself recursively to obtain allthe forms e i (cid:121) . . . (cid:121) e i l (cid:121) α , where α ranges in a basis of I and 1 ≤ i < . . . < i l ≤ j .When the resulting degree is one, the function stops the recursion and stores thedifferential one-form, applying a substitution corresponding to the projection (5).The code of Fig. 2 is for a general linear EDS on the bundle of frames. In orderto obtain a result for the special case of G , we can use the following: struct G2 : EDS {G2() : EDS (7) {lst I;I=d(ParseDifferentialForm(e(),"567-512-534-613-642-714-723")),d(ParseDifferentialForm(e(),"1234-6712-6734-7513-7542-5614-5623"));Basis Remark. Concerning the non-linear case, Wedge also provides a class template PolyBasis , analogous to Basis , where polynomial equations can be stored, relyingon CoCoA for the necessary Gr¨obner basis computations (see [4]). Notice however YMBOLIC COMPUTATIONS IN DIFFERENTIAL GEOMETRY 13 struct EDS : public ConcreteManifold, public Has_dTable {lst moduloIC;int dim;EDS(int dimension) : ConcreteManifold(dimension*(dimension+1)) {dim=dimension;for (int i=1;i<=dim;++i) {ex x;for (int j=1; j<=dim;++j)x+=e(j)*e(i*dim+j);Declare_d(e(i),x);moduloIC.append(e(i)==0);}}template Figure 2. Using Wedge to determine if a linear EDS on the framebundle is involutivethat the simple program of Fig. 2 assumes linearity when computing the polarequations. References [1] C. Bauer, A. Frink, and R. Kreckel. Introduction to the GiNaC framework for symboliccomputation within the C ++ programming language. J. Symbolic Comput. , 33(1):1–12, 2002. [2] H. Baum, T. Friedrich, R. Grunewald, and I. Kath. Twistor and Killing spinors on Riemann-ian manifolds . Teubner-Verlag Leipzig/Stuttgart, 1991.[3] R. Bryant. Metrics with exceptional holonomy. Annals of Mathematics , 126:525–576, 1987.[4] CoCoATeam. CoCoA: a system for doing Computations in Commutative Algebra. Availableat http://cocoa.dima.unige.it .[5] D. Conti. Invariant forms, associated bundles and Calabi-Yau metrics. J. Geom. Phys. ,57:2483–2508, 2007.[6] D. Conti and A. Fino. Calabi-Yau cones from contact reduction, 2007. arXiv:0710.4441v1.[7] N. J. Hitchin. The self-duality equations on a Riemann surface. Proc. London Math. Soc. (3) ,55(1):59–126, 1987.[8] S. Kobayashi and K. Nomizu. Foundations of differential geometry . Interscience Publishers,1963.[9] K. Lake and P. Musgrave. GRTensor, a system for making the classical functions of generalrelativity elementary. In Proceedings of the 5th Canadian Conference on General Relativityand Relativistic Astrophysics (Waterloo, ON, 1993) , pages 317–320. World Sci. Publ., RiverEdge, NJ, 1994.[10] Barrett O’Neill. The fundamental equations of a submersion. Michigan Math. J. , 13:459–469,1966.[11] Izu Vaisman. Symplectic curvature tensors. Monatsh. Math. , 100(4):299–327, 1985. Dipartimento di Matematica e Applicazioni, Universit`a di Milano Bicocca, via Cozzi53, 20125 Milano, Italy. E-mail address ::