differentiating and taking limit of complex vector valued function with maple

Question

I would like to do the following with maple let

omega := z -> 2*<Re(z), Im(z), 1>/(1+abs(z)^2):

and

phi := -> z (l*z+a)/(1-l*conjugate(a)*z):

where a is complex and l is real. I consider Omega=omega( phi(z) ) and i would like to evaluate diff(Omega,x) diff(Omega,y) but also compute some limit like

> expr := omega(phi(1/e));
> Omega := simplify(map(limit, expr, e = 0));
> expr2 := (omega(phi(1/(e^2*conjugate(z))))-Omega)/e^2; 
> H := limit(expr2, e = 0);

Unfortunately i have tried every thing (Vector Calculus , Complex...) and i have always a probleme either because i work with vector or because the variable is complex.

Does someone have any idea of the good way to code such a problem? Thx

Answer 1

[edited:] I cannot tell whaht your original definition of operator phi is, as there is a syntax error in the original post (invalid syntax). In particular I cannot tell whether you meant,

phi := z -> (l*z+a)/(1-l*conjugate(a)*z):

or,

phi := z -> z (l*z+a)/(1-l*conjugate(a)*z):

I used the former below. The results will depend upon the choice, of course.

In a previous question by you an answer involved using evalc, under which all unknowns would be treated as real.

But now you seem to have a mix, where l is to be taken as real while a may be complex.

As shown in your earlier question another approach is to use assumptions on the unknowns, which in this case can give finer control over your mix.

Note that a will get treated as being possibly complex, by default. So we can use an assumption on just l.

restart:                                       

omega := z -> 2*<Re(z), Im(z), 1>/(1+abs(z)^2):

phi := z -> (l*z+a)/(1-l*conjugate(a)*z):      

expr := omega(phi(1/e)):                       

map(limit,expr,e=0) assuming l::real:

map(simplify,%);
                            [   2 Re(a)  ]
                            [- ----------]
                            [       2    ]
                            [  | a |  + 1]
                            [            ]
                            [   2 Im(a)  ]
                            [- ----------]
                            [       2    ]
                            [  | a |  + 1]
                            [            ]
                            [         2  ]
                            [  2 | a |   ]
                            [ ---------- ]
                            [      2     ]
                            [ | a |  + 1 ]

Here is another way to get a result. We could let a=S+T*I and use evalc to handle altogether the assumptions that S and T (and l) are purely real.

map(limit,subs(a=S+T*I,expr),e=0) assuming l::real:

simplify(map(evalc,%));                            

                            [      2 S    ]
                            [- -----------]
                            [   2    2    ]
                            [  S  + T  + 1]
                            [             ]
                            [      2 T    ]
                            [- -----------]
                            [   2    2    ]
                            [  S  + T  + 1]
                            [             ]
                            [     2    2  ]
                            [ 2 (S  + T ) ]
                            [ ----------- ]
                            [  2    2     ]
                            [ S  + T  + 1 ]