## Wirtinger derivatives in Maple 2021

by: Maple

Wirtinger Derivatives in Maple 2021

Generally speaking, there are two contexts for differentiating complex functions with respect to complex variables. In the first context, called the classical complex analysis, the derivatives of the complex components ( abs , argument , conjugate , Im , Re , signum ) with respect to complex variables do not exist (do not satisfy the Cauchy-Riemann conditions), with the exception of when they are holomorphic functions. All computer algebra systems implement the complex components in this context, and computationally represent all of  as functions of z . Then, viewed as functions of z, none of them are analytic, so differentiability becomes an issue.

In the second context, first introduced by Poincare (also called Wirtinger calculus), in brief z and its conjugate  are taken as independent variables, and all the six derivatives of the complex components become computable, also with respect to . Technically speaking, Wirtinger calculus permits extending complex differentiation to non-holomorphic functions provided that they are ℝ-differentiable (i.e. differentiable functions of real and imaginary parts, taking  as a mapping ).

In simpler terms, this subject is relevant because, in mathematical-physics formulations using paper and pencil, we frequently use Wirtinger calculus automatically. We take z and its conjugate  as independent variables, with that , , and we compute with the operators ,  as partial differential operators that behave as ordinary derivatives. With that, all of , become differentiable, since they are all expressible as functions of z and .

Wirtinger derivatives were implemented in Maple 18 , years ago, in the context of the Physics package. There is a setting, , that when set to true - an that is the default value when Physics is loaded - redefines the differentiation rules turning on Wirtinger calculus. The implementation, however, was incomplete, and the subject escaped through the cracks till recently mentioned in this Mapleprimes post.

Long intro. This post is to present the completion of Wirtinger calculus in Maple, distributed for everybody using Maple 2021 within the Maplesoft Physics Updates v.929 or newer. Load Physics and set the imaginary unit to be represented by

The complex components are represented by the computer algebra functions

 (1)

They can all be expressed in terms of  and

 (2)

The main differentiation rules in the context of Wirtinger derivatives, that is, taking  and  as independent variables, are

 (3)

Since in this context  is taken as - say - a mathematically-atomic variable (the computational representation is still the function ) we can differentiate all the complex components also with respect to

 (4)

For example, consider the following algebraic expression, starting with conjugate

 (5)

Differentiating this expression with respect to z and  taking them as independent variables, is new, and in this example trivial

 (6)

 (7)

Switch to something less trivial, replace  by the real part

 (8)

To verify results further below, also express  in terms of

 (9)

New: differentiate  with respect to  and

 (10)

 (11)

Note these results (10) and (11) are expressed in terms of , not . Let's compare with the derivative of  where everything is expressed in terms of z and . Take for instance the derivative with respect to z

 (12)

To verify this result is mathematically equal to (10) expressed in terms of  take the difference of the right-hand sides

 (13)

One quick way to verify the value of expressions like this one is to replace  and simplify   and are real

 (14)

 (15)

The equivalent differentiation, this time replacing in   by ; construct also the equivalent expression in terms of  and   for verifying results

 (16)

 (17)

Since these two expressions are mathematically equal, their derivatives should be too, and the derivatives of  can be verified by eye since  and   are taken as independent variables

 (18)

 (19)

Eq (18) is expressed in terms of  while (19) is in terms of . Comparing as done in (14)

 (20)

 (21)

 (22)

To mention but one not so famliar case, consider the derivative of the sign of a complex number, represented in Maple by . So our testing expression is

 (23)

This expression can also be rewritten in terms of  and

 (24)

This time differentiate with respect to ,

 (25)

Here again, the differentiation of , that is expressed entirely in terms of  and  , can be computed by eye

 (26)

Eq (25) is expressed in terms of  while (26) is in terms of . Comparing as done in (14),

 (27)

 (28)

 (29)

Download Wirtinger_Derivatives.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

## Showing quadratic forms are nonnegative

by: Maple
 > restart;
 > with(LinearAlgebra):

Recently @Nour asked (in part) if Maple can simplify 2*(x^2 - x*y - x*z + y^2) to (x - y)^2 + (y - z)^2 + (z - x)^2. User @vv pointed out that a sum of squares form is not unique. I'm not sure if @Nour's intent was to show that this was always non-negative, but even if the sum of squares form is not unique, it does help to demonstrate that the expression will be nonnegative for all real x,y,z. This reminded me that I have over the years had cases where I wanted to know if a quadratic form (multivariate polynomial with all terms of degree 2) would always be non-negative (a quadratic form will be zero if all variables are zero, so we know it won't always be positive). I have typically done this by hand in the following way, which I demonstrate for the simpler case

 > p1:=2*x^2-3*x*y+4*y^2;

We make a (column) vector of the variables, v = [x,y] and then construct the symmetric Matrix A for which Transpose(v).A.v is the required expression. For the squared term 2*x^2, the coefficient 2 is put in the diagonal entry A[1,1] and likewise 4*y^2 leads to A[2,2] = 4. The term -3*x*y comes from the sum A[1,2]+A[2,1] and so half of the coefficient -3 goes to each of A[2,1] and A[1,2]. The Matrix is therefore

 > A:=Matrix(2,2,[2,-3/2,-3/2,4]);v:=Vector([x,y]):simplify(v^+.A.v);

The Matrix is found to be positive definite (positive eigenvalues), which means that the quadratic form is positive for all non-zero real vectors v.

 > IsDefinite(A,query='positive_definite');evalf(Eigenvalues(A));

One way to get the sum of squares form is to use the Cholesky decomposition (for positive definite or semidefinite matrices), which yields A = L.Transpose(L) = L.I.Transpose(L), and then note that Transpose(L).v is a change of variables to a diagonal quadratic form

 > L:=LUDecomposition(A,method='Cholesky'); L.L^+;

so we have

 > v2:=L^+.v; v2^+.v2; map(simplify,%);

and we have rewritten the quadratic form in an explicitly nonnegative form.

Another way to the sum of squares would be via the othogonal similarity A = U.Lambda.Transpose(U), where U is an orthogonal matrix of eigenvectors and Lambda is diagonal with eigenvalues on the diagonal. This form works even if the matrix is not positive (semi)definite.

In this simple case, Maple has some other ways of showing that the quadratic form is non-negative for real x,y

 > Student[Precalculus]:-CompleteSquare(p1,x);

Without assumptions, is correctly decides p1 is not always nonnegative, and an example of this for complex x and y is easily found. With assumptions, is fails.

 > is(p1,nonnegative); eval(p1,{x=I,y=I}); is(p1,nonnegative) assuming real;

At least in Maple 2017, solve suggests any x and y will do, which is not quite right

 > solve(p1>=0);

In the next worksheet, I implement this method in a general procedure IsQformNonNeg, which works as well as IsDefinite does. For most cases of interest (integer or rational coefficients) there are no problems. For floating point coefficients, as always, numerical roundoff issues arise, and I dealt with this by giving warnings. (Rank is more robust in these cases than IsDefinite, but since this case can be better dealt with by converting floats to rationals, I haven't worked too hard on this - perhaps IsDefinite will be improved.)

The original example 2*(x^2 - x*y - x*z + y^2)  is dealt with as an example in the next worksheet

 >

Download QformPost.mw

## Multibyte characters

by:

Maple strings contain extended ASCII characters (codes 1..255).
The international characters such as  î, ș, Å, Ø ,Ă, Æ, Ç are multi-byte encoded. They are ignored by the Maple engine but are known to the user interface which uses the UTF-8 encoding.
The package StringTools does not support this encoding. However it is not difficult to manage these characters using Python commands (included in the Maple distribution now).
Here are the UTF-8 versions of the Maple procedures length and substring.
You may want to improve these procedures, or to add new ones (my knowledge of Python is very limited).

```LEN:=proc(s::string) Python:-EvalFunction("len",s) end proc:

SS:=proc(s::string, mn::{integer, range(({integer,identical()}))})
local m,n;
if type(mn,integer) then m,n := mn\$2 else m:=lhs(mn); n:=rhs(mn) fi;
if m=NULL then m:=1 fi; if n=NULL then n:=-1 fi;
if n=-1 then n:=LEN(s) elif n<0 then n:=n+1 fi;
if m=-1 then m:=LEN(s) elif m<0 then m:=m+1 fi;
Python:-EvalString(cat("\"",  s, "\"", "[", m-1, ":", n, "]"  ));
end proc:
```

LEN("Canada"), length("Canada");
6, 6

s:="România":
LEN(s), length(s);
7, 8

SS(s, 1..), SS(s, 1..-3), SS(s, 1..1), SS(s, -7..2), SS(s,1), SS(s,-1);
"România", "Român", "R", "Ro", "R", "a"

## Feynman Integrals

by: Maple

Download FeynmanIntegrals.mw

Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft

## Old bug in `diff/abs`

by: Maple

diff(abs(z), z)  returns abs(1, z)  and the latter, for a numeric z, is defined only for a nonzero real z.
However,  functions such as abs(I+sin(t)) are (real) differentiable for a real t and diff should work. It usually does, but not always.

```restart
f:= t -> abs(GAMMA(2*t+I)):  # We want D(f)(1)
D(f)(1):
evalf(%);  # Error, (in simpl/abs) abs is not differentiable at non-real arguments
D(f)(1); simplify(%);
evalf(%);   # 0.3808979508 + 1.161104935*I,  wrong
```

The same wrong results are obtained with diff instead of D

```diff(f(t),t):   # or  diff(f(t),t) assuming t::real;
eval(%,t=1);
simplify(%); evalf(%);   # wrong, should be real
```

To obtain the correct result, we could use the definition of the derivative:

```limit((f(t)-f(1))/(t-1), t=1); evalf(%); # OK
fdiff(f(t), t=1);    # numeric, OK
```

0.8772316598
0.8772316599

Note that abs(1, GAMMA(2 + I)); returns 1; this is also wrong, it should produce an error because  GAMMA(2+I) is not real;

Let's redefine now `diff/abs`  and redo the computations.

```restart
`diff/abs` := proc(u, z)   # implements d/dx |f(x+i*y|) when f is analytic and f(...)<>0
local u1:=diff(u,z);
1/abs(u)*( Re(u)*Re(u1) + Im(u)*Im(u1) )
end:
f:= t -> abs(GAMMA(2*t+I));
D(f)(1); evalf(%);   # OK now
```

0.8772316597

Now diff works too.

```diff(f(t),t);
eval(%,t=1);
simplify(%); evalf(%);   # it works
```

This is a probably a very old bug which may make diff(u,x)  fail for expressions having subespressions abs(...) depending on x.

However it works  using assuming x::real, but only if evalc simplifies u.
The problem is actually more serious because diff/ for Re, Im, conjugate should be revized too. Plus some other related things.

## Putnam Mathematical Competition 2020

by: Maple

The Putnam 2020 Competition (the 81st) was postponed to February 20, 2021 due to the COVID-19 pandemic, and held in an unofficial mode with no prizes or official results.

Four of the problems have surprisingly short Maple solutions.
Here they are.

A1.  How many positive integers N satisfy all of the following three conditions?
(i) N is divisible by 2020.
(ii) N has at most 2020 decimal digits.
(iii) The decimal digits of N are a string of consecutive ones followed by a string of consecutive zeros.

```add(add(`if`( (10&^m-1)*10&^(n-m) mod 2020 = 0, 1, 0),
n=m+1..2020), m=1..2020);
```

508536

A2.  Let k be a nonnegative integer.  Evaluate

```sum(2^(k-j)*binomial(k+j,j), j=0..k);
```

4^k

A3.  Let a(0) = π/2, and let a(n) = sin(a(n-1)) for n ≥ 1.
Determine whether the series   converges.

```asympt('rsolve'({a(n) = sin(a(n-1)),a(0)=Pi/2}, a(n)), n, 4);
```

a(n) ^2 being equivalent to 3/n,  the series diverges.

B1.  For a positive integer n, define d(n) to be the sum of the digits of n when written in binary
(for example, d(13) = 1+1+0+1 = 3).

Let   S =
Determine S modulo 2020.

```d := n -> add(convert(n, base,2)):
add( (-1)^d(k) * k^3, k=1..2020 ) mod 2020;
```

1990

## Vibrational Mechanics - Practical Applications

by: Maple

Presenters:

Affiliated Research Professor Mohammad Khoshnevisan

Physics Department, Northeastern University

United States of America

&

Behzad Mohasel Afshari, Admitted Ph.D. student

School of Advanced Manufacturing & Mechanical Engineering

University of South Australia

Australia

Note: This webinar is free. For registration, please send an e-mail to m.khoshnevisan@ieee.org. The registration link will be sent to all the participants on April 26, 2021. Maximum number of participants =60

Vibrational Mechanics - Practical Applications- Animation 1

Vibrational Mechanics - Practical Applications- Animation 2

Vibrational Mechanics - Practical Applications- Animation 3

by: Maple

## Pythagorean Triples Ternary Tree

Maple 18

I make a maple worksheet for generating Pythagorean Triples Ternary Tree :

Around 10,000 records in the matrix currently !

You can set your desire size or export the Matrix as text ...

But yet ! I wish to understand from you better techniques If you have some suggestion ?

the mapleprimes Don't load my worksheet for preview so i put a screenshot !

Pythagoras_ternary.mw

Pythagoras_ternary_data.mw

Pythagoras_ternary_maple.mw

## New book Fourier Transforms for Chemistry

by: Maple 2020

We announce the release of a new book, of title Fourier Transforms for Chemistry, which is in the form of a Maple worksheet.  This book is freely available through Maple Application Centre, either as a Maple worksheet with no output from commands or as a .pdf file with all output and plots.

This interactive electronic book in the form of a Maple worksheet comprises six chapters containing Maple commands, plus an overview 0 as an introduction.  The chapters have content as follows.

-   1    continuous Fourier transformation

-   2    electron diffraction of a gaseous sample

-   3    xray diffraction of a crystal and a powder

-   4    microwave spectrum of a gaseous sample

-   5    infrared and Raman spectra of a liquid sample

-   6    nuclear magnetic resonance of various samples

This book will be useful in courses of physical chemistry or devoted to the determination of molecular structure by physical methods.  Some content, duly acknowledged, has been derived and adapted from other authors, with permission.

## pillow curve

Maple 13

Hi all,

Look at my pretty plot.  It is defined by

x=sin(m*t);
y=sin(n*t);

where n and m are one digit positive integers.

You can modify my worksheet with different values of n and m.

pillow_curve.mw

pillow_curve.pdf

The name of the curve may be something like Curve of Lesotho.  I saw this first in one of my father's books.

Regards,
Matt

## Maple Evaluation Order Example

by: Maple 2020

The order in which expressions evaluate in Maple is something that occasionally causes even advanced users to make syntax errors.

I recently saw a single line of Maple code that provided a good example of a command not evaluating in the order the user desired.

The command in question (after calling with(plots):) was

`animate(display, [arrow(<cos(t), sin(t)>)], t = 0 .. 2*Pi)`

This resulted in the error:

Error, (in plots/arrow) invalid input: plottools:-arrow expects its 3rd argument, pv, to be of type {Vector, list, vector, complexcons, realcons}, but received 0.5000000000e-1*(cos(t)^2+sin(t)^2)^(1/2)

This error indicates that the issue in the animation is the arrow command

`arrow(<cos(t), sin(t)>)`

on its own, the above command would give the same error. However, the animate command takes values of t from 0 to 2*Pi and substitutes them in, so at first glance, you wouldn't expect the same error to occur.

What is happening is that the command

`arrow(<cos(t), sin(t)>)`

in the animate expression is evaluating fully, BEFORE the call to animate is happening. This is due to Maple's automatic simplification (since if this expression contained large expressions, or the values were calculated from other function calls, that could be simplified down, you'd want that to happen first to prevent unneeded calculation time at each step).

So the question is how do we stop it evaluating ahead of time since that isn't what we want to happen in this case?

In order to do this we can use uneval quotes (the single quotes on the keyboard - not to be confused with the backticks).

`animate(display, ['arrow'(<cos(t), sin(t)>)], t = 0 .. 2*Pi)`

By surrounding the arrow function call in the uneval quotes, the evaluation is delayed by a level, allowing the animate call to happen first so that each value of t is then substituted before the arrow command is called.

Maple_Evaluation_Order_Example.mw

## pendulum animation: decomposing a vector into...

by: Maple

Download pendulumprojection.mw

Most of the time in multivariable calculus the vectors we are decomposing with respect to a given direction are attached to a specific point and this "orthogonal decomposition" should be visualized as a triplet of vectors with initial point at that given point such that the two projections sum to the original vector. Keep in mind our high school physics pendulum example where we need to evaluate both the component of the downward gravitational force along the tangential direction of motion of the pendulum for the equations of motion as well as along the perpendicular direction to the motion to evaluate the tension in the string or wire holding the pendulum mass.

We create an Explorable graphic to visualize this idea and then create an animation which requires a bit of Maple expert user knowledge to accomplish (thanks Maplesoft!). A delayed evaluation of the arrow command from the plot package is required in order to animate that arrow so that it waits for the animation command to feed it actual numerical values for the vector to be plotted.

My worksheet URL:
http://www34.homepage.villanova.edu/robert.jantzen/courses/mat2500/handouts/pendulumprojection.mw

## One more way of inverse kinematics

by:

As a continuation of the posts:
https://www.mapleprimes.com/posts/208958-Determination-Of-The-Angles-Of-The-Manipulator
https://www.mapleprimes.com/posts/209255-The-Use-Of-Manipulators-As-Multiaxis
https://www.mapleprimes.com/posts/210003-Manipulator-With-Variable-Length-Of
But this time without Draghilev's method.
Motion along straight lines can replace motion along any spatial path (with any practical precision), which means that solving the inverse problem of the manipulator's kinematics can be reduced to solving the movement along a sequential set of segments. Thus, another general method for solving the manipulator inverse problem is proposed.
An example of a three-link manipulator with 5 degrees of freedom. Its last link, like the first link, geometrically corresponds to the radius of the sphere. We calculate the coordinates of the ends of its links when passing a straight line segment. We do this in a loop for interior points of the segment using the procedure for finding real roots of polynomial systems of equations RootFinding [Isolate]. First, we “remove” two “extra” degrees of freedom by adding two equations to the system. There can be an infinite set of options for additional equations - if only they correspond to the technical capabilities of the device. In this case, two maximally easy conditions were taken: one equation corresponds to the perpendicularity of the last (third) link directly to the segment of the trajectory itself, and the second equation corresponds to the perpendicularity to the vector with coordinates <1,1,1>. As a result, we got four ways to move the manipulator for the same segment. All of these ways are selected as one of the RootFinding [Isolate] solutions (in text  jj=1,2,3,4).
In this text jj=4
without_Draghilev_method.mw

As you can see, everything is very simple, there is practically no programming and is performed exclusively by Maple procedures.

## An elementary problem

by: Maple

Here is a very nice (but not easy) elementary problem.
The equality
ceil(2/(2^(1/n)-1)) = floor(2*n/ln(2));

is not an identity, it does not hold for each positive integer n.
How to find such a number?

[This is a re-post, because the original vanished when trying a conversion Question-->Post]

The problem appears in the recent book:
Richard P. Stanley - Conversational Problem Solving. AMS, 2020.

The problem is related to a n-dimensional tic-tac-toe game. The first counterexample (2000) was wrong due to a multiprecision arithmetic error.
The  author of the book writes
"To my knowledge, only eight values of n are known for which the equation fails,
and it is not known whether there are infinitely many such values",

but using Maple it will be easy to find more.

A brute-force solution is problematic because the smallest counterexample is > 7*10^14.

```restart;
a := 2/(2^(1/n)-1): b := 2*n/ln(2):
asympt(b-a, n);
```

It results:  b - a → 1 (for n →oo);
So, to have a counterexample, b must be close to an integer
m ≈ 2*n/ln(2)  ==> n/m ≈ ln(2)/2

The candidates for n/m will be obviously the convergents of the continued fraction of the irrational number ln(2)/2.

```convert(ln(2)/2, confrac, 200, 'L'):
Digits:=500:
for n in numer~(L[3..]) do
if not evalf(ceil(a)=floor(b)) then printf("n=%d\n", n) fi;
od:
```

n=777451915729368
n=140894092055857794
n=1526223088619171207
n=54545811706258836911039145
n=624965662836733496131286135873807507
n=1667672249427111806462471627630318921648499
n=36465374036664559522628534720215805439659141
n=2424113537313479652351566323080535902276508627
n=123447463532804139472316739803506251988903644272
n=97841697218028095572510076719589816668243339678931971
n=5630139432241886550932967438485653485900841911029964871
n=678285039039320287244063811222441860326049085269592368999
n=312248823968901304612135523777926467950572570270886324722782642817828920779530446911
n=5126378297284476009502432193466392279080801593096986305822277185206388903158084832387
n=1868266384496708840693682923003493054768730136715216748598418855972395912786276854715767
n=726011811269636138610858097839553470902342131901683076550627061487326331082639308139922553824778693815

So, we have obtained 16 counterexamples. The question whether there are an infinity of such n's remains open.

 4 5 6 7 8 9 10 Last Page 6 of 66
﻿