Andriy

260 Reputation

13 Badges

10 years, 139 days

MaplePrimes Activity


These are replies submitted by Andriy

@Carl Love 

it is a list of thread-safe functions while Physics is a package. Besides that `.` is thread-safe ( http://www.maplesoft.com/support/help/Maple/view.aspx?path=dot ) so I supposed that Physics:-`.` can be thread safe too. Very likely I was wrong.

The problem is solved in Maple 17.02

restart; d := conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x); z := conjugate(f)/d+G*w*conjugate(w)*conjugate(y)/d; z2 := simplify(z)

conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x)

 

conjugate(f)/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))+G*w*conjugate(w)*conjugate(y)/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))

 

(G*abs(w)^2*conjugate(y)+conjugate(f))/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))

(1)

restart; d := conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x); z := conjugate(f)/d+conjugate(G)*w*conjugate(w)*conjugate(y)/d; z2 := simplify(z)

conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x)

 

conjugate(f)/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))+conjugate(G)*w*conjugate(w)*conjugate(y)/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))

 

(conjugate(G)*abs(w)^2*conjugate(y)+conjugate(f))/(conjugate(u)*conjugate(y)+conjugate(v)*conjugate(x))

(2)

``


solved.mw

Hi ecterrab

Thank you for solutions.

Regarding the second problem only the end user knows what form of presentation of complex number is preferable in his case. Moreover, there are few situations when splitting of a complex number into Re + I Im is preferable to not splitting. Therefore, the decision to split or not to split indeed have to be strongly dependent on a particular task. For objective reasons Maple is unable to handle what form of complex number is simplifying for the end user. So, the correct behaviour of Simplify/conjugate is not to split a complex number at all. The compromise might be not splitting for conjugate command and splitting (in some sittuations) for Simplify command. Of couse it is only my oppinion.

Hi ecterrab

Thank you for solutions.

Regarding the second problem only the end user knows what form of presentation of complex number is preferable in his case. Moreover, there are few situations when splitting of a complex number into Re + I Im is preferable to not splitting. Therefore, the decision to split or not to split indeed have to be strongly dependent on a particular task. For objective reasons Maple is unable to handle what form of complex number is simplifying for the end user. So, the correct behaviour of Simplify/conjugate is not to split a complex number at all. The compromise might be not splitting for conjugate command and splitting (in some sittuations) for Simplify command. Of couse it is only my oppinion.

@ecterrab

Thank you for explaining the difference between `*` and `.` and for explaining presented in PhysicsUpdate.mw. They are really helpful.

One more observation. Physics:-Simplify cannot always simplify the elementary expressions with fermionic operators:

restart; 
with(Physics); Setup(mathematicalnotation = true); Setup(anticommutativeprefix = psi);

for i to 4 do
ap[i] := Creation(psi, i, notation = explicit);
am[i] := Annihilation(psi, i, notation = explicit)
end do;

z := ap[1].am[2].am[2];
Simplify(z);


0

z := am[1].am[2].am[2]; 
Simplify(z);


Simplify_problem.mw

I suppose that some kind of defect appeared in Physics package.

The first run of the code below gives the result in improper notations.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true, anticommutativeprefix = psi); for i to 2 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; H := Physics:-`*`(a, ap[1]).am[1]; phi := Physics:-`*`(a, Ket(psi, 1, 0))

 

a*(`a+`[psi[1]].`a-`[psi[1]])

 

a*Physics:-Ket(psi, 1, 0)

(1)

And only the second run gives the result in proper notations.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true, anticommutativeprefix = psi); for i to 2 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; H := Physics:-`*`(a, ap[1]).am[1]; phi := Physics:-`*`(a, Ket(psi, 1, 0))

 

a*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])

 

a*Physics:-Ket(psi, 1, 0)

(2)

NULL

notations.mw

@ecterrab

Thank you for explaining the difference between `*` and `.` and for explaining presented in PhysicsUpdate.mw. They are really helpful.

One more observation. Physics:-Simplify cannot always simplify the elementary expressions with fermionic operators:

restart; 
with(Physics); Setup(mathematicalnotation = true); Setup(anticommutativeprefix = psi);

for i to 4 do
ap[i] := Creation(psi, i, notation = explicit);
am[i] := Annihilation(psi, i, notation = explicit)
end do;

z := ap[1].am[2].am[2];
Simplify(z);


0

z := am[1].am[2].am[2]; 
Simplify(z);


Simplify_problem.mw

I suppose that some kind of defect appeared in Physics package.

The first run of the code below gives the result in improper notations.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true, anticommutativeprefix = psi); for i to 2 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; H := Physics:-`*`(a, ap[1]).am[1]; phi := Physics:-`*`(a, Ket(psi, 1, 0))

 

a*(`a+`[psi[1]].`a-`[psi[1]])

 

a*Physics:-Ket(psi, 1, 0)

(1)

And only the second run gives the result in proper notations.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true, anticommutativeprefix = psi); for i to 2 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; H := Physics:-`*`(a, ap[1]).am[1]; phi := Physics:-`*`(a, Ket(psi, 1, 0))

 

a*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])

 

a*Physics:-Ket(psi, 1, 0)

(2)

NULL

notations.mw

@ecterrab 

Some issues emerged with SortProducts and expand.

In the following example I demonstrate that Physics:-SortProducts command doesn't sort operators in expression when this expression contains the same operator twice.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true); Setup(anticommutativeprefix = psi); for i to 4 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; ApAm1 := [seq(ap[j], j = 1 .. 4), seq(am[j], j = 1 .. 4)]; z := ap[1].ap[2].ap[1]; z := SortProducts(z, ApAm1, useanticommutator)

 

[`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[3]], `a+`[psi[4]], `a-`[psi[1]], `a-`[psi[2]], `a-`[psi[3]], `a-`[psi[4]]]

 

Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[1]])

 

Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[1]])

(1)

Besides that SortProduct doesn't sort operators in expression at one time. Of course, one can call collect(z,`.`) and then repeat sorting, However, it is possible (my case) when you don't really know how many times you should repeat sorting. It would be useful to have a possibility to sort them at one time.

z := A*am[2].ap[2].am[1].ap[1]; z := SortProducts(z, ApAm1, useanticommutator); z := collect(z, `.`); z := SortProducts(z, ApAm1, useanticommutator)

A*Physics:-`.`(`a-`[psi[2]], `a+`[psi[2]], `a-`[psi[1]], `a+`[psi[1]])

 

A*(-Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], -Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+1)-Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+1)

 

-A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])-A*Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])+A

 

-A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])-A*Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])-A*Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])+A

(2)

expand command doesn't work in some special situations (demonstrated below). Besides the result of AntiCommutator(HH(1,1), HH(1,2)) contains both Physics[`*`] and Physics[`.`]. Is it possible to convert all Physics[`*`] operations into Physics[`.`]?

PS   I don't understand the sense of the following sentence from the Help page: "Physics[`.`] - scalar product between Bras, Kets, and quantum operators." Namely, I don't know what does it means "scalar product of quantum operators". I don't understand the need in additional Product (Physics[`.`]) for operators different from Physics[`*`].

restart; with(Physics); with(Library); Setup(mathematicalnotation = true); Physics:-Setup(anticommutativeprefix = psi); am := proc (i, sigma) local k::posint; if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; k := 2*i-2+sigma; Annihilation(psi, k, notation = explicit) end proc; ap := proc (i, sigma) local k::posint; if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; k := 2*i-2+sigma; Creation(psi, k, notation = explicit) end proc; nn := proc (i, sigma) if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; ap(i, sigma).am(i, sigma) end proc; HH := proc (i, sigma) if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; h1*am(i, sigma)+h5*am(i, sigma).nn(i, 3-sigma) end proc; f := 2; ApAm1 := [seq(seq(ap(i, sigma), sigma = 1 .. 2), i = 1 .. f), seq(seq(am(i, sigma), sigma = 1 .. 2), i = 1 .. f)]; z := AntiCommutator(HH(1, 1), HH(1, 2)); z := SortProducts(z, ApAm1, useanticommutator); z2 := expand(z)

2

 

[`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[3]], `a+`[psi[4]], `a-`[psi[1]], `a-`[psi[2]], `a-`[psi[3]], `a-`[psi[4]]]

 

h1*h5*(2*Physics:-`*`(`a-`[psi[1]], `a-`[psi[2]], `a+`[psi[1]], `a-`[psi[1]])+Physics:-`.`(`a-`[psi[2]], `a-`[psi[1]]))+h5*(h1*(2*Physics:-`*`(`a-`[psi[2]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(-Physics:-`.`(`a-`[psi[1]], `a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])+2*Physics:-`.`(Physics:-`*`(`a-`[psi[1]], `a-`[psi[2]], `a+`[psi[1]], `a-`[psi[1]]), `a+`[psi[2]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[2]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])))

 

h1*h5*(2*Physics:-`*`(Physics:-`*`(`a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[2]], `a-`[psi[1]])-Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(h1*(2*Physics:-`*`(-Physics:-`*`(`a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[1]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(-Physics:-`.`(-Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])+1, `a-`[psi[1]], `a-`[psi[2]])-2*Physics:-`.`(Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[2]], `a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])+Physics:-`.`(-Physics:-`.`(`a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[1]], `a-`[psi[2]])))

 

Error, (in type/satisfies) too many levels of recursion

 

NULL

 

SortProduct_expand_problem.mw

@ecterrab 

Some issues emerged with SortProducts and expand.

In the following example I demonstrate that Physics:-SortProducts command doesn't sort operators in expression when this expression contains the same operator twice.

restart; Physics:-Version(); with(Physics); with(Library); Setup(mathematicalnotation = true); Setup(anticommutativeprefix = psi); for i to 4 do ap[i] := Creation(psi, i, notation = explicit); am[i] := Annihilation(psi, i, notation = explicit) end do; ApAm1 := [seq(ap[j], j = 1 .. 4), seq(am[j], j = 1 .. 4)]; z := ap[1].ap[2].ap[1]; z := SortProducts(z, ApAm1, useanticommutator)

 

[`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[3]], `a+`[psi[4]], `a-`[psi[1]], `a-`[psi[2]], `a-`[psi[3]], `a-`[psi[4]]]

 

Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[1]])

 

Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[1]])

(1)

Besides that SortProduct doesn't sort operators in expression at one time. Of course, one can call collect(z,`.`) and then repeat sorting, However, it is possible (my case) when you don't really know how many times you should repeat sorting. It would be useful to have a possibility to sort them at one time.

z := A*am[2].ap[2].am[1].ap[1]; z := SortProducts(z, ApAm1, useanticommutator); z := collect(z, `.`); z := SortProducts(z, ApAm1, useanticommutator)

A*Physics:-`.`(`a-`[psi[2]], `a+`[psi[2]], `a-`[psi[1]], `a+`[psi[1]])

 

A*(-Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], -Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+1)-Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+1)

 

-A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])-A*Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])+A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])+A

 

-A*Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])-A*Physics:-`.`(`a+`[psi[2]], `a-`[psi[2]])-A*Physics:-`.`(`a+`[psi[1]], `a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])+A

(2)

expand command doesn't work in some special situations (demonstrated below). Besides the result of AntiCommutator(HH(1,1), HH(1,2)) contains both Physics[`*`] and Physics[`.`]. Is it possible to convert all Physics[`*`] operations into Physics[`.`]?

PS   I don't understand the sense of the following sentence from the Help page: "Physics[`.`] - scalar product between Bras, Kets, and quantum operators." Namely, I don't know what does it means "scalar product of quantum operators". I don't understand the need in additional Product (Physics[`.`]) for operators different from Physics[`*`].

restart; with(Physics); with(Library); Setup(mathematicalnotation = true); Physics:-Setup(anticommutativeprefix = psi); am := proc (i, sigma) local k::posint; if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; k := 2*i-2+sigma; Annihilation(psi, k, notation = explicit) end proc; ap := proc (i, sigma) local k::posint; if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; k := 2*i-2+sigma; Creation(psi, k, notation = explicit) end proc; nn := proc (i, sigma) if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; ap(i, sigma).am(i, sigma) end proc; HH := proc (i, sigma) if [i, sigma]::(Not(list(posint))) then return 'procname(args)' end if; h1*am(i, sigma)+h5*am(i, sigma).nn(i, 3-sigma) end proc; f := 2; ApAm1 := [seq(seq(ap(i, sigma), sigma = 1 .. 2), i = 1 .. f), seq(seq(am(i, sigma), sigma = 1 .. 2), i = 1 .. f)]; z := AntiCommutator(HH(1, 1), HH(1, 2)); z := SortProducts(z, ApAm1, useanticommutator); z2 := expand(z)

2

 

[`a+`[psi[1]], `a+`[psi[2]], `a+`[psi[3]], `a+`[psi[4]], `a-`[psi[1]], `a-`[psi[2]], `a-`[psi[3]], `a-`[psi[4]]]

 

h1*h5*(2*Physics:-`*`(`a-`[psi[1]], `a-`[psi[2]], `a+`[psi[1]], `a-`[psi[1]])+Physics:-`.`(`a-`[psi[2]], `a-`[psi[1]]))+h5*(h1*(2*Physics:-`*`(`a-`[psi[2]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(-Physics:-`.`(`a-`[psi[1]], `a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])+2*Physics:-`.`(Physics:-`*`(`a-`[psi[1]], `a-`[psi[2]], `a+`[psi[1]], `a-`[psi[1]]), `a+`[psi[2]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[2]], `a-`[psi[1]], `a+`[psi[2]], `a-`[psi[2]])))

 

h1*h5*(2*Physics:-`*`(Physics:-`*`(`a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[2]], `a-`[psi[1]])-Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(h1*(2*Physics:-`*`(-Physics:-`*`(`a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[1]], `a-`[psi[2]])+Physics:-`.`(`a-`[psi[1]], `a-`[psi[2]]))+h5*(-Physics:-`.`(-Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]])+1, `a-`[psi[1]], `a-`[psi[2]])-2*Physics:-`.`(Physics:-`.`(`a+`[psi[1]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[2]], `a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])+Physics:-`.`(-Physics:-`.`(`a+`[psi[2]], `a-`[psi[1]], `a-`[psi[2]])-`a-`[psi[1]], `a-`[psi[2]])))

 

Error, (in type/satisfies) too many levels of recursion

 

NULL

 

SortProduct_expand_problem.mw

@ecterrab 

I will test the new version of Coefficients with great pleasure.

@ecterrab 

I will test the new version of Coefficients with great pleasure.

macro command solved the problem.

The procedure below

coeffuniversal := proc (z) 
local W, h;
W := [seq(h*op(i, z), i = 1 .. nops(z))];
#W := [seq(select(type, W[i], commutative), i = 1 .. numelems(W))];
W := map(u->select(type, u, commutative), W);
map(u->u/h, W)
end proc

gets the coefficients both operator expression and wave function expression. Internal variable 'h' is dynamically created at the procedure call so it doesn't interfere with the variable 'h' that may exist in the argument 'z'.

I'd prefer to multiply by 1 rather than 'h', namely to replace the first command of the procedure with the following one

W := [seq(`%*`(1, op(i, z)), i = 1 .. nops(z))]

but it doesn't give the desired result.

There is a short summary of this thread in the attached file.
coefficients.mw

The procedure below

coeffuniversal := proc (z) 
local W, h;
W := [seq(h*op(i, z), i = 1 .. nops(z))];
#W := [seq(select(type, W[i], commutative), i = 1 .. numelems(W))];
W := map(u->select(type, u, commutative), W);
map(u->u/h, W)
end proc

gets the coefficients both operator expression and wave function expression. Internal variable 'h' is dynamically created at the procedure call so it doesn't interfere with the variable 'h' that may exist in the argument 'z'.

I'd prefer to multiply by 1 rather than 'h', namely to replace the first command of the procedure with the following one

W := [seq(`%*`(1, op(i, z)), i = 1 .. nops(z))]

but it doesn't give the desired result.

There is a short summary of this thread in the attached file.
coefficients.mw

3 4 5 6 7 8 9 Page 5 of 10