+1 vote

Hi!
Dealing with graded manifolds, I would like to define a graded coordinate of degree 1, denoted

$\xi_{a}$

and the associated partial derivative

$D_{a}$

of degree -1 (position of indices is unimportant for my purpose).

In particular, both

$\xi_{a}$

and

$D_{a}$
are self-anticommuting and anti-commuting with each other (being both of odd degree).

However, when I implement the situation in the following way:

{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::Indices(T, position=free, parent=double);

D{#}::PartialDerivative;

{\xi{#}}::Depends(D{#});

{D{#},\xi{#}}::AntiCommuting;

{D{#},\xi{#}}::SelfAntiCommuting;

Exp:=D_{a}{D_{b}{\xi_{c}}*\xi_{d}};

product_rule(_);


$D_{a b}{\xi_{c}} \xi_{d}-D_{b}{\xi_{c}} D_{a}{\xi_{d}}$

where the second sign is wrong, since

$D_{b}{\xi_{c}}$

should be of degree 0, and then commute with

$D_{a}$.

Is there a way to fix this?

Thank you for any information!

+1 vote

Assign the AntiCommuting property to the indices, not to the derivatives. So

{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::Indices(T, position=free, parent=double);
D{#}::PartialDerivative;
\xi{#}::Depends(D{#});
{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::AntiCommuting;


and then

Exp:=D_{a}{D_{b}{\xi_{c}}*\xi_{d}};
product_rule(_);


produces

$$D_{a b}{\xi_{c}} \xi_{d} + D_{b}{\xi_{c}} D_{a}{\xi_{d}}$$

Please let me know if you run into any other issues. I am reworking the code for this, so that it works properly if you have a combination of explicit and implicit indices, so now is the time to fix other issues (if any).

However, I'm not sure to quite get how Anticommuting works on coordinates yet.

For example,

{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::Indices(T, position=free, parent=double);
{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::AntiCommuting;

Exp:=\xi_{a}*\xi_{b}+\xi_{b}*\xi_{a};
sort_product(_);


renders $2\xi{a} \xi{b}$ where I was expecting zero.

For that you do need the

\xi_{a}::SelfAntiCommuting;


property. The problem at the moment is that not all algorithms make use of the same property information (sort_product needs the SelfAntiCommuting, while product_rule looks at the property directly on the indices). This is being cleaned up, but still a bit confusing at the moment.

Ok, now it works fine, thank you!

By the way, do you know if there is a way to make D_{a b} skewsymmetric in a and b, i.e. such that:

{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::Indices(T, position=free, parent=double);
{a, b, c, d, e, f, g, h, i, j, k, l, m, n ,o, r,s,t,u,v,w,x,y,z#}::AntiCommuting;
D{#}::PartialDerivative;
Exp:=D_{a b}{f}-D_{b a}{f};
canonicalise(_);


doesn't yield zero?

Partial derivatives are always assumed to be commuting (which should not be, in case they are in anticommuting directions, but that's not handled right now). So you'll need to declare D{#}::Derivative. That does lead to slightly messier output unfortunately.

Dear Kasper,

I'm still slightly confused about how the sort_product algorithm deals with Anticommuting indices. In the following example, it doesn't consider the indices a and b as anticommuting in the first example but seems to do so when one adds a partial derivative.

{\mu,\nu}::Indices; {a, b}::Indices; {a, b}::AntiCommuting;

\partial{#}::PartialDerivative;

Exp1:=\zeta_{b}*\xi_{a}; sort_product(_);

Exp2:=\zeta_{b}*\partial_{\mu}{\xi_{a}}; sort_product(_);

Is there a way to harmonise this so that to obtain a plus sign in the second output?

Thank you!