digerdiga

390 Reputation

8 Badges

11 years, 309 days

MaplePrimes Activity


These are replies submitted by digerdiga

@acer Hm, what is it good for then? So you can not output non-executable math code? It sounded like in the answer by Oliver.

@Oliver K Is it only the student version that is 50% off, or also the individual version? Do you have a link? I can't find the 50% discount.

@Oliver K Does this work with 2019? I'm only toggling the symbol "Text" and "Math" next to each other, but the output is unaffected.

What seems to work is using the Format Option "Atomic Variable". Not sure if that is intended however.

edit: So it is Shift+F5, but toggling to non-executable math doesn't output anything. The output is just blank...

That really helped. While it is good to know about the short-macro a=b=c for the relational boolean operation, it is just a display convenience I was looking for (no interpretation).

On the other hand, I'm going to try Oliver's nonexecutable math too, as it may be less cluttered with formal code.

Anyway, Thanks all.

@acer P(X <= 5) = P(-5 <= -X) = P(E(X) - 5 <= E(X) - X) <= P(E(X) - 5 <= abs(E(X) - X) );

for instance

@acer Is it also possible to use a different symbol (=,<=,>=,...) at each step?

I'm a bit confused about the nprintf format specification.

@Preben Alsholm ok, thanks :-)

@acer Thanks. Though shouldn't D convert D(f^k) to (D(k)*ln(f)+k*D(f)/f)*f^k even if k is not assumed to be constant?

@acer One may add that the problem seems to arise in the subroutine "contour" (infolevel[int]:=5) which makes sense, since the i*Pi/2 term arises precisely because of the residue at t=1.

The sign in the first term seems to arise depending on the branch chosen on the segment (-infinity,0) for the contour integral int(...,t=-infinity..infinity). The integral over the arc vanishes for 0<a<1.

Btw: While it doesn't seem to matter in the assumptions a=1 and a=0 is not allowed.

@Kitonum This is good :-), but it would be cool if these trig identities are covered by convert(*,radical)

@acer I really appreciate your effort, but I must say that the following little loop is probably simpler

restart;
with(ArrayTools);
N := 5;
cosx := Array([0]);
for i to N do
    cosx := Append(cosx, sqrt((1 + cosx[i])/2));
end do;
simplify(cosx);
evalf(`-`~(%, [seq(cos(Pi/2^i), i = 1 .. N + 1)]));

 

The point is, why is such a seemingly simple thing not covered by convert(*,radical)? I looks as if this is the perfect thing for which convert(*,radical) could be called for.

@ecterrab That's what I precisely tried too.

It does not work.


 

restart; with(Physics); Setup(dimension = 3, metric = Euclidean, spacetimeindices = lowercaselatin, mathematicalnotation = true, hermitianoperators = {P, X}, automaticsimplification = true); g_[]; Define(X, P); Setup(quantumop = {P, X}, algebrarules = {%Commutator(P[i], P[j]) = 0, %Commutator(X[i], P[j]) = Physics:-`*`(I, g_[i, j]), %Commutator(X[i], X[j]) = 0}); L2 := Simplify(Physics:-`^`(Physics:-`*`(Physics:-`*`(LeviCivita[i, j, k], X[j]), P[k]), 2)); L2X := Simplify(Commutator(L2, X[k])); L2L2X__1 := Library:-SortProducts(Expand(Simplify(Commutator(L2, L2X))), [Physics:-`^`(X[b], 2), X[a]]); Library:-SortProducts(%, [Physics:-`^`(X[b], 2), X[a]], totheright); Simplify(%, indices); L2L2X__2 := Simplify(Expand(AntiCommutator(Physics:-`*`(2, L2), X[k]))); Simplify(L2L2X__1-L2L2X__2)

`The dimension and signature of the tensor space are set to `[3, `- - +`]

 

`The Euclidean metric in cartesian coordinates`

 

`Changing the signature of the tensor spacetime to: `*`+ + +`

 

[automaticsimplification = true, dimension = 3, hermitianoperators = {P, X}, mathematicalnotation = true, metric = {(1, 1) = 1, (2, 2) = 1, (3, 3) = 1}, spacetimeindices = lowercaselatin]

 

Physics:-g_[a, b] = Matrix(%id = 18446746066398517478)

 

`Defined objects with tensor properties`

 

{P, X, Physics:-Dgamma[a], Physics:-Psigma[a], Physics:-d_[a], Physics:-g_[a, b], Physics:-LeviCivita[a, b, c]}

 

`* Partial match of  '`*quantumop*`' against keyword '`*quantumoperators*`' `

 

_______________________________________________________

 

[algebrarules = {%Commutator(P[i], P[j]) = 0, %Commutator(X[i], P[j]) = I*Physics:-g_[i, j], %Commutator(X[i], X[j]) = 0}, quantumoperators = {P, X}]

 

(2*I)*Physics:-`*`(X[j], P[j])+Physics:-`*`(Physics:-`^`(X[j], 2), Physics:-`^`(P[k], 2))-Physics:-`*`(X[j], X[k], P[j], P[k])

 

2*X[k]-(2*I)*Physics:-`*`(Physics:-`^`(X[b], 2), P[k])+(2*I)*Physics:-`*`(X[c], X[k], P[c])

 

(12*I)*Physics:-`*`(X[c], X[k], P[c])-(4*I)*Physics:-`*`(Physics:-`^`(X[b], 2), P[k])-4*Physics:-`*`(X[f], X[i], X[k], P[f], P[i])-4*Physics:-`*`(X[a], Physics:-`^`(X[b], 2), P[a], P[k])+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[k], Physics:-`^`(P[h], 2))+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[f], P[f], P[k])+4*X[k]

 

(12*I)*Physics:-`*`(X[c], X[k], P[c])-(4*I)*Physics:-`*`(Physics:-`^`(X[b], 2), P[k])-4*Physics:-`*`(X[f], X[i], X[k], P[f], P[i])-4*Physics:-`*`(X[a], Physics:-`^`(X[b], 2), P[a], P[k])+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[k], Physics:-`^`(P[h], 2))+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[f], P[f], P[k])+4*X[k]

 

(12*I)*Physics:-`*`(X[c], X[k], P[c])-(4*I)*Physics:-`*`(Physics:-`^`(X[b], 2), P[k])-4*Physics:-`*`(X[f], X[i], X[k], P[f], P[i])-4*Physics:-`*`(X[a], Physics:-`^`(X[b], 2), P[a], P[k])+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[k], Physics:-`^`(P[h], 2))+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[f], P[f], P[k])+4*X[k]

 

4*X[k]+(12*I)*Physics:-`*`(X[c], X[k], P[c])+4*Physics:-`*`(Physics:-`^`(X[b], 2), X[k], Physics:-`^`(P[d], 2))-(4*I)*Physics:-`*`(Physics:-`^`(X[b], 2), P[k])-4*Physics:-`*`(X[e], X[f], X[k], P[e], P[f])

 

0

(1)

NULL


 

Download Commutator_Algebra_with_L2.mw

@ecterrab I know I'm getting on your nerves, but not satisfying answers were given as to why it can not commute X^2[b] with X[a] if a commutation rule %Commutator(X[i],X[j])=0 has been set. Afterall it can commute P^2[i] with X[j] given the commutation rule %Commutator(X[i],P[j])=i g_[i,j] ??

The only thing you said is that there are issues when X is both a tensor and an operator at the same time.

So that is the answer?

 

I'm already reading your tut regarding the Sort-thing, but I just would like to understand.

If not here, where should be place for discussion!?

@ecterrab  What noncommutative objects subject to commutator rules? Not sure what you mean; the only thing that needs to be commuted is X[b]^2 with X[a] which commute by the algebrarule %Commutator(X[a],X[b])=0 !?

 

Is it possible to do this without using tensor then, but still benefitting from some automatic summation procedure?

1 2 3 4 5 6 7 Last Page 1 of 19