Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

How would I go about getting true or false returned on these propositions?
I have tried just about every eval and various syntax methods, but nothing has worked so far.

I know most can easilly be done by hand/thinking, but I'm sure Maple should have a way to do this as well.

∀n∈Z:2n>n+2   ,   ∃n∈Z:2|(3n+1)    ,   ∃k∈Z:∀n∈Z:n=kn   ,   ∃k∈Z:∀n∈Z:2|(n+k)   ,   ∀n∈Z:∀k∈Z:(n>k∨k≥n)


Coherent States in Quantum Mechanics

 

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

(1) Laboratoire PhLAM, UMR CNRS 8523, Université Lille 1, F-59655, France

(2) Maplesoft

 

  

Coherent states are among the most relevant representations for the state of a quantum system. These states, that form an overcomplete basis, minimize the quantum uncertainty between position x and momentum p (they satisfy the Heisenberg uncertainty principle with equality and their expectation values satisfy the classical equations of motion). Coherent states are widely used in quantum optics and quantum mechanics in general; they also mathematically characterize the concept of Planck cells. Part of this development is present in Maple 2018.2.1. To reproduce what you see below, however, you need a more recent version, as the one distributed within the Maplesoft Physics Updates (version 276 or higher). A worksheet with this contents is linked at the end of this post.

Definition and the basics

 

with(Physics)

 

Set a quantum operator A and corresponding annihilation / creation operators

Setup(quantumoperators = A)

[quantumoperators = {A}]

(1.1)

am := Annihilation(A)

`#msup(mi("a"),mo("&uminus0;"))`

(1.2)

ap := Creation(A)

`#msup(mi("a"),mo("+"))`

(1.3)

In what follows, on the left-hand sides the product operator used is `*`, which properly represents, but does not perform the attachment of Bras Kets and operators. On the right-hand sides the product operator is `.`, that performs the attachments. Since the introduction of Physics in the Maple system, we have that

am*Ket(A, n) = am.Ket(A, n)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, n)) = n^(1/2)*Physics:-Ket(A, n-1)

(1.4)

(%Bracket = Bracket)(Bra(A, n), Ket(A, n))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(A, n)) = 1

(1.5)

(%Bracket = Bracket)(Bra(A, n), Ket(A, m))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(A, m)) = Physics:-KroneckerDelta[m, n]

(1.6)

New development during 2018: coherent states, the eigenstates of the annihilation operator `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`, with all of their properties, are now understood as such by the system

am*Ket(am, alpha) = am.Ket(am, alpha)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

(1.7)

Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) is an eigenket of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` but not of  `#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`

ap.Ket(am, alpha)

Physics:-`.`(`#msup(mi("a"),mo("+"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(1.8)

The norm of these states is equal to 1

(%Bracket = Bracket)(Bra(am, alpha), Ket(am, alpha))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = 1

(1.9)

These states, however, are not orthonormal as the occupation number states Ket(A, n) are, and since `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` is not Hermitian, its eigenvalues are not real but complex numbers. Instead of (1.6) , we now have

(%Bracket = Bracket)(Bra(am, alpha), Ket(am, beta))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, beta)) = exp(-(1/2)*abs(alpha)^2-(1/2)*abs(beta)^2+conjugate(alpha)*beta)

(1.10)

At alpha = beta,

simplify(eval(%Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, beta)) = exp(-(1/2)*abs(alpha)^2-(1/2)*abs(beta)^2+conjugate(alpha)*beta), alpha = beta))

1 = 1

(1.11)

Their scalar product with the occupation number states Ket(A, m), using the inert %Bracket on the left-hand side and the active Bracket on the other side:

(%Bracket = Bracket)(Bra(A, n), Ket(am, alpha))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)

(1.12)

The expansion of coherent states into occupation number states, first representing the product operation using `*`, then performing the attachments replacing `*` by `.`

Projector(Ket(A, n), dimension = infinity)

Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity)

(1.13)

Ket(am, alpha) = (Sum(Physics[`*`](Physics[Ket](A, n), Physics[Bra](A, n)), n = 0 .. infinity))*Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(1.14)

eval(Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Physics[Ket](A, n), Physics[Bra](A, n)), n = 0 .. infinity), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)), `*` = `.`)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(1.15)

Hide now the ket label. When in doubt, input show to see the Kets with their labels explicitly shown

Setup(hide = true)

`* Partial match of  '`*hide*`' against keyword '`*hideketlabel*`' `

 

_______________________________________________________

 

[hideketlabel = true]

(1.16)

Define eigenkets of the annihilation operator, with two different eigenvalues for experimentation

`K__α` := Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

(1.17)

`K__β` := Ket(am, beta)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, beta)

(1.18)

Because the properties of coherent states are now known to the system, the following computations proceed automatically. The left-hand sides use the `*`, while the right-hand sides use the `.`

(`*` = `.`)(Dagger(`K__α`), ap, am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = abs(alpha)^2

(1.19)

(`*` = `.`)(Dagger(`K__α`), ap+am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`+`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)+alpha

(1.20)

(`*` = `.`)(Dagger(`K__α`), ap-am, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), `#msup(mi("a"),mo("+"))`-`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)-alpha

(1.21)

(`*` = `.`)(Dagger(`K__α`), (ap+am)^2, `K__α`)

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`^`(`#msup(mi("a"),mo("+"))`+`#msup(mi("a"),mo("&uminus0;"))`, 2), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = conjugate(alpha)^2+2*abs(alpha)^2+1+alpha^2

(1.22)

Properties of Coherent states

 

The mean value of the occupation number N

 

 

The occupation number operator N is given by

N := ap.am

Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.1)

N*` is Hermitian`

%Dagger(N) = N

%Dagger(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)) = Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.2)

value(%Dagger(Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)) = Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`))

Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`) = Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`)

(2.1.3)

N is diagonal in the Ket(A, n) basis of the Fock (occupation number) space

(`*` = `.`)(Bra(A, n), N, Ket(A, p))

Physics:-`*`(Physics:-Bra(A, n), `#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, p)) = p*Physics:-KroneckerDelta[n, p]

(2.1.4)
• 

The mean value of N in a coherent state `≡`(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Ket(alpha))

Bracket(%N)[alpha] = %Bracket(Bra(am, alpha), N, Ket(am, alpha))

Physics:-Bracket(%N)[alpha] = %Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.1.5)

value(Physics[Bracket](%N)[alpha] = %Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)))

Physics:-Bracket(%N)[alpha] = abs(alpha)^2

(2.1.6)

The mean value of N^2

Bracket(%N^2)[alpha] = %Bracket(Bra(am, alpha), N^2, Ket(am, alpha))

Physics:-Bracket(%N^2)[alpha] = %Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics:-`^`(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.1.7)

value(Physics[Bracket](%N^2)[alpha] = %Bracket(Physics[Bra](`#msup(mi("a"),mo("&uminus0;"))`, alpha), Physics[`^`](Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics[Ket](`#msup(mi("a"),mo("&uminus0;"))`, alpha)))

Physics:-Bracket(%N^2)[alpha] = abs(alpha)^4+abs(alpha)^2

(2.1.8)

The standard deviation `ΔN` = sqrt(-Bracket(%N)[alpha]^2+Bracket(%N^2)[alpha]) for a state Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)

((Physics[Bracket](%N^2)[alpha] = abs(alpha)^4+abs(alpha)^2)-(Physics[Bracket](%N)[alpha] = abs(alpha)^2)^2)^(1/2)

(-Physics:-Bracket(%N)[alpha]^2+Physics:-Bracket(%N^2)[alpha])^(1/2) = abs(alpha)

(2.1.9)

In conclusion, a coherent state "| alpha >" has a finite spreading `ΔN` = abs(alpha).  Coherent states are good approximations for the states of a laser, where the laser intensity I  is proportional to the mean value of the photon number, I f Bracket(%N)[alpha] = abs(alpha)^2, and so the intensity fluctuation, `∝`(sqrt(I), abs(alpha)).

• 

The mean value of the occupation number N in an occupation number state `≡`(Ket(A, n), Ket(n))

Bracket(%N)[n] = %Bracket(Bra(A, n), N, Ket(A, n))

Physics:-Bracket(%N)[n] = %Bracket(Physics:-Bra(A, n), Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Physics:-Ket(A, n))

(2.1.10)

value(Physics[Bracket](%N)[n] = %Bracket(Bra(A, n), Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), Ket(A, n)))

Physics:-Bracket(%N)[n] = n

(2.1.11)

The mean value of the occupation number N in a state Ket(A, n) is thus n itself, as expected since Ket(A, n)represents a (Fock space) state of n (quase-) particles. Accordingly,

Bracket(%N^2)[n] = %Bracket(Bra(A, n), N^2, Ket(A, n))

Physics:-Bracket(%N^2)[n] = %Bracket(Physics:-Bra(A, n), Physics:-`^`(Physics:-`*`(`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Physics:-Ket(A, n))

(2.1.12)

value(Physics[Bracket](%N^2)[n] = %Bracket(Bra(A, n), Physics[`^`](Physics[`*`](`#msup(mi("a"),mo("+"))`, `#msup(mi("a"),mo("&uminus0;"))`), 2), Ket(A, n)))

Physics:-Bracket(%N^2)[n] = n^2

(2.1.13)

The standard deviation `ΔN` = sqrt(-Bracket(%N)[n]^2+Bracket(%N^2)[n]) for a state Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha), is thus

((Physics[Bracket](%N^2)[n] = n^2)-(Physics[Bracket](%N)[n] = n)^2)^(1/2)

(-Physics:-Bracket(%N)[n]^2+Physics:-Bracket(%N^2)[n])^(1/2) = 0

(2.1.14)

That is, in a Fock state, `ΔN` = 0,  there is no intensity fluctuation.

"a^(-)| alpha > = alpha| alpha >"

 

 

The specific properties of coherent states implemented can be derived explicitly departing from the projection of "Ket(a^(-),alpha"into the Ket(A, m)basis of occupation number states and the definition of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))` as the operator that annihilates the vacuum `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`Ket(A, n) = 0

Ket(am, alpha) = (Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity))*Ket(am, alpha)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics:-`*`(Sum(Physics:-`*`(Physics:-Ket(A, n), Physics:-Bra(A, n)), n = 0 .. infinity), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))

(2.2.1)

eval(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)), `*` = `.`)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(2.2.2)

To derive `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = alpha*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) from the formula above, start multiplying by `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`

am*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

(2.2.3)

In view of `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(A, 0) = 0, discard the first term of the sum

subs(0 = 1, Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 1 .. infinity))

(2.2.4)

Change variables n = k+1; in the result rename proc (k) options operator, arrow; n end proc

subs(k = n, PDEtools:-dchange(n = k+1, Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 1 .. infinity)), `@`(combine, simplify)))

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)

(2.2.5)

Activate the product `#msup(mi("a",mathcolor = "olive"),mo("&uminus0;",mathcolor = "olive"))`*Ket(A, n+1) by replacing, in the right-hand side, the product operator `*` by `.`

lhs(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)) = eval(rhs(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(A, n+1))*alpha^(n+1)/(factorial(n)^(1/2)*(n+1)^(1/2)), n = 0 .. infinity)), `*` = `.`)

Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity)

(2.2.6)

By inspection the right-hand side of (2.2.6) is equal to alpha times the right-hand side of (2.2.2)

alpha*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Sum(exp(-(1/2)*abs(alpha)^2)*Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity))

alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*(Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Sum(exp(-(1/2)*abs(alpha)^2)*Physics:-Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity))

(2.2.7)

combine(alpha*Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics[`*`](`#msup(mi("a"),mo("&uminus0;"))`, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = alpha*(Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))-(Sum(exp(-(1/2)*abs(alpha)^2)*Ket(A, n)*alpha^(n+1)/factorial(n)^(1/2), n = 0 .. infinity)))

alpha*Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)-Physics:-`*`(`#msup(mi("a"),mo("&uminus0;"))`, Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = 0

(2.2.8)
• 

Overview of the coherent states distribution

 

Consider the projection of Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) over an occupation number state Ket(A, n)

%Bracket(Bra(A, n), lhs(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)))) = Bracket(Bra(A, n), rhs(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Physics[`*`](Sum(Physics[`*`](Ket(A, n), Bra(A, n)), n = 0 .. infinity), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha))))

%Bracket(Physics:-Bra(A, n), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)

(2.2.9)

An overview of the distribution of coherent states Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) for a sample of values of n and alpha is thus as follows

plot3d(rhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)), n = 0 .. 25, alpha = 0 .. 10, axes = boxed, caption = lhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)))

 

The distribution can be explored for ranges of values of n and alpha using Explore

NA := Typesetting:-Typeset(Bracket(Bra(A, n), Ket(am, alpha)))

Explore(plot(rhs(%Bracket(Bra(A, n), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(alpha)^2)*alpha^n/factorial(n)^(1/2)), n = 0 .. 200, view = 0 .. .6, labels = [n, NA]), parameters = [alpha = 0 .. 10], initialvalues = [alpha = 5])

"a^(+)| alpha >= (∂)/(∂alpha) | alpha >+(alpha)/2 | alpha >"

   

exp(-(1/2)*abs(alpha)^2)*exp(alpha*`#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`)"| 0 >" = "| alpha >"

   

 exp(alpha*`#msup(mi("a",mathcolor = "olive"),mo("+",mathcolor = "olive"))`-conjugate(alpha)*a)" | 0 >" = "| alpha >"

   

`<|>`(beta, alpha) = exp(conjugate(beta)*alpha-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2)

 

NULL

The identity in the title can be derived departing again from the the projection of a coherent stateKet(`#msup(mi("a"),mo("&uminus0;"))`, alpha)into the Ket(A, m)basis of occupation number states

Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)

(2.6.1)

Dagger(subs({alpha = beta, n = k}, Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity)))

Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta) = Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Physics:-Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity)

(2.6.2)

Taking the `*` product of these two expressions

(Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta) = Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity))*(Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha) = Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics:-`*`(Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Physics:-Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Physics:-Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))

(2.6.3)

Perform the attachment of Bras and Kets on the right-hand side by replacing `*` by `.`, evaluating the sum and simplifying the result

lhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))) = simplify(value(eval(rhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = Physics[`*`](Sum(exp(-(1/2)*abs(beta)^2)*conjugate(beta)^k*Bra(A, k)/factorial(k)^(1/2), k = 0 .. infinity), Sum(exp(-(1/2)*abs(alpha)^2)*alpha^n*Ket(A, n)/factorial(n)^(1/2), n = 0 .. infinity))), `*` = `.`)))

Physics:-`*`(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta))

(2.6.4)
• 

Overview of the real and imaginary part of `<|>`(beta, alpha)

 

In most cases, alpha and beta are complex valued numbers. Below, the plots assume that alpha and beta are both real. To take into account the general case, the possibility to tune a phase difference theta between alpha and beta is explicitly added, so that (2.6.4) becomes

 

%Bracket(Bra(am, beta), Ket(am, alpha)) = subs(conjugate(beta) = conjugate(beta)*exp(I*theta), rhs(Physics[`*`](Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(conjugate(beta)*alpha-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2)))

%Bracket(Physics:-Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Physics:-Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta)*exp(I*theta))

(2.6.5)

Explore(plot3d(Re(rhs(%Bracket(Bra(`#msup(mi("a"),mo("&uminus0;"))`, beta), Ket(`#msup(mi("a"),mo("&uminus0;"))`, alpha)) = exp(-(1/2)*abs(beta)^2-(1/2)*abs(alpha)^2+alpha*conjugate(beta)*exp(I*theta)))), alpha = -10 .. 10, beta = -10 .. 10, view = -1 .. 1, orientation = [-12, 74, 3], axes = boxed), parameters = [theta = 0 .. 2*Pi], initialvalues = [theta = (1/10)*Pi])

 

 

Download Coherent_States_in_Quantum_Mechanics.mw

 

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

 

Using Maple 2018.2.1, I'm receiving a lost kernel message when importing the attached data file with ImportMatrix. I traced the issue to a "*" symbol at the end of the file but would have expected this to cause an error message (if any error at all) instead of the connection to the kernel to be lost. Is this a bug or am I misunderstanding the usage of ImportMatrix?

test.mw

test2.txt


i want someone hlep me in this worksheet the diff eq of complex i want to sovle it with any numeric method 
 

restart

with(Physics):

with(IntegrationTools):

v := 1;

1

 

-500

 

.1

 

.5

 

.5

(1)

``

M[1] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)

Int(-(2*I)*exp(-(.5*I)*tt)/((0.1e-1+tt^2)^(1/2)*exp((0.1e-1+tt^2)^(1/2)))+(2*I)*exp((.5*I)*tt)/((0.1e-1+tt^2)^(1/2)*exp((0.1e-1+tt^2)^(1/2))), tt = -500 .. z)

(2)

M[2] := Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M[3] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M[4] := Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

M := Physics:-`*`(z^2, M[1])+Physics:-`*`(z, M[2])+Physics:-`*`(z, M[3])+M[4]:

Mc[1] := Physics:-`*`(z^2, Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[2] := Physics:-`*`(z, Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(4, I), tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[3] := Physics:-`*`(z, Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Mc[4] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), tt^2), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v^2), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(v, exp(sqrt(b^2+tt^2)))), tt = -500 .. z):

Mc := Mc[1]+Mc[2]+Mc[3]+Mc[4]:

N[1] := Int(Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(2, tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2, I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/exp(sqrt(b^2+tt^2))), tt = -500 .. z):

N[2] := Physics:-`*`(z, Int(-Physics:-`*`(Physics:-`*`(2, exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(2, exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

N := N[1]+N[2]:

Nc[1] := Int(-Physics:-`*`(Physics:-`*`(Physics:-`*`(2., tt), exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))+Physics:-`*`(Physics:-`*`(Physics:-`*`(2., tt), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(Physics:-`*`(2., I), exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/exp(sqrt(b^2+tt^2))), tt = -500 .. z):

Nc[2] := Physics:-`*`(z, Int(Physics:-`*`(Physics:-`*`(2., exp(Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2))))-Physics:-`*`(Physics:-`*`(2., exp(-Physics:-`*`(Physics:-`*`(Physics:-`*`(.5, I), v), tt))), 1/Physics:-`*`(Physics:-`*`(sqrt(b^2+tt^2), v), exp(sqrt(b^2+tt^2)))), tt = -500 .. z)):

Nc := Nc[1]+Nc[2]:

V := Physics:-`*`(Physics:-`*`(1/Physics:-`*`(4, Pi^2), 1/sqrt(b^2+z^2)), Physics:-`*`(exp(-Physics:-`*`(2, sqrt(b^2+z^2))), Physics:-`*`(2, sqrt(b^2+z^2))+2)-2):

Vc := Physics:-`*`(Physics:-`*`(Physics:-`*`(-1, 1/Physics:-`*`(4, Pi^2)), 1/sqrt(b^2+z^2)), Physics:-`*`(exp(-Physics:-`*`(2, sqrt(b^2+z^2))), Physics:-`*`(2, sqrt(b^2+z^2))+2)-2):

``

H := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2)+(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)+I*((-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int((-1)*2.*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2.*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*I*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(2.*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

H(500)

-6.287499768+0.1713975e-19*I

(3)

NULL

L := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*((-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(2*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))-2*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(2*I)*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(-2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)+I*(-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2)-(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

``

G := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(I*(-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2)+(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*((-1/2+(1/2)*p^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int((-1)*2.*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2.*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*I*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(2.*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(-1)*2.*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

``

K := proc (z) local t; if not z::numeric then return ('procname')(args) end if; evalf(I*((-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(2*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))-2*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+(2*I)*exp((-1)*.5*I*v*tt)/exp(sqrt(b^2+tt^2)), tt = -500 .. z)+z*(Int(-2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2)))+2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v*exp(sqrt(b^2+tt^2))), tt = -500 .. z)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)-I*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(-1/2+(1/2)*q^2*v^2+1/sqrt(b^2+z^2)-(1/4)*(exp(-2*sqrt(b^2+z^2))*(2*sqrt(b^2+z^2)+2)-2)/(Pi^2*sqrt(b^2+z^2)))/(((z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))*(z^2*(Int(-(2*I)*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int((4*I)*tt*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))-(4*I)*tt*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+z*(Int(-2*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))-2*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))+Int(-(2*I)*tt^2*exp((-1)*.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+(2*I)*tt^2*exp(.5*I*v*tt)/(sqrt(b^2+tt^2)*v^2*exp(sqrt(b^2+tt^2)))+2*tt*exp((-1)*.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2)))+2*tt*exp(.5*I*v*tt)/(v*exp(sqrt(b^2+tt^2))), tt = -500 .. z))-1)*v)) end proc:

NULL

NULL

sys := {diff(X(z), z) = Physics:-`*`(H(z), Y(z))+Physics:-`*`(L(z), X(z)), diff(Y(z), z) = Physics:-`*`(G(z), Y(z))+Physics:-`*`(K(z), X(z))}

{diff(X(z), z) = H(z)*Y(z)+L(z)*X(z), diff(Y(z), z) = G(z)*Y(z)+K(z)*X(z)}

(4)

IC_1 := {X(-500) = 0, Y(-500) = 1}

{X(-500) = 0, Y(-500) = 1}

(5)

dsol3 := dsolve(`union`(sys, IC_1), numeric, method = dverk78, output = procedurelist, known = [H, L, G, K])

proc (x_dverk78) local _res, _dat, _vars, _solnproc, _xout, _ndsol, _pars, _n, _i; option `Copyright (c) 2000 by Waterloo Maple Inc. All rights reserved.`; if 1 < nargs then error "invalid input: too many arguments" end if; _EnvDSNumericSaveDigits := Digits; Digits := 15; if _EnvInFsolve = true then _xout := evalf[_EnvDSNumericSaveDigits](x_dverk78) else _xout := evalf(x_dverk78) end if; _dat := Array(1..4, {(1) = proc (_xin) local _xout, _fcn, _i, _octl, _ctl, _y0, _yini, _ycur, _reinit, _pars, _n, _ysav, _ini, _par; option `Copyright (c) 1993 by the University of Waterloo. All rights reserved.`; Digits := max(15, Digits); _xout := _xin; _octl := array( 1 .. 32, [( 1 ) = (3), ( 2 ) = (1), ( 3 ) = (0), ( 4 ) = (0), ( 5 ) = (0), ( 6 ) = (0), ( 7 ) = (0), ( 9 ) = (1), ( 8 ) = (0), ( 11 ) = (-1), ( 10 ) = (-1), ( 13 ) = (-1), ( 12 ) = (-1), ( 15 ) = (-1), ( 14 ) = (-1), ( 18 ) = (-1), ( 19 ) = (-1), ( 16 ) = (-1), ( 17 ) = (-500.), ( 22 ) = (-1), ( 23 ) = (-1), ( 20 ) = (-500.), ( 21 ) = (-1), ( 27 ) = (-499.), ( 26 ) = (2), ( 25 ) = (-500.), ( 24 ) = (0), ( 31 ) = (-500.), ( 30 ) = (1), ( 29 ) = (2), ( 28 ) = (0.1e-7), ( 32 ) = (0)  ] ); _yini := Array(0..2, {(1) = -500., (2) = 0.}); _y0 := Array(0..2, {(1) = -500., (2) = 0.}); _ycur := array( 1 .. 2, [ ] ); _ctl := array( 1 .. 32, [( 1 ) = (3), ( 2 ) = (1), ( 3 ) = (0), ( 4 ) = (0), ( 5 ) = (0), ( 6 ) = (0), ( 7 ) = (0), ( 9 ) = (1), ( 8 ) = (0), ( 11 ) = (-1), ( 10 ) = (-1), ( 13 ) = (-1), ( 12 ) = (-1), ( 15 ) = (-1), ( 14 ) = (-1), ( 18 ) = (-1), ( 19 ) = (-1), ( 16 ) = (-1), ( 17 ) = (-500.), ( 22 ) = (-1), ( 23 ) = (-1), ( 20 ) = (-500.), ( 21 ) = (-1), ( 27 ) = (-499.), ( 26 ) = (2), ( 25 ) = (-500.), ( 24 ) = (0), ( 31 ) = (-500.), ( 30 ) = (1), ( 29 ) = (2), ( 28 ) = (0.1e-7), ( 32 ) = (0)  ] ); _fcn := proc (N, X, Y, YP) option `[Y[1] = X(z), Y[2] = Y(z)]`; YP[1] := H(X)*Y[2]+L(X)*Y[1]; YP[2] := G(X)*Y[2]+K(X)*Y[1]; 0 end proc; _pars := []; _n := 2; _ysav := Array(1..2, {(1) = 0., (2) = 1.}); if not type(_xout, 'numeric') then if member(_xout, ["start", "left", "right"]) then return _y0[0] elif _xout = "method" then return "dverk78" elif _xout = "numfun" then return round(_ctl[24]) elif _xout = "initial" then return [seq(_yini[_i], _i = 0 .. _n)] elif _xout = "parameters" then return [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] elif _xout = "initial_and_parameters" then return [seq(_yini[_i], _i = 0 .. _n)], [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] elif _xout = "last" then if _ctl[17]-_y0[0] = 0. then error "no information is available on last computed point" else _xout := _ctl[17] end if elif _xout = "enginedata" then return eval(_octl, 1) elif _xout = "function" then return eval(_fcn, 1) elif type(_xin, `=`) and type(rhs(_xin), 'list') and member(lhs(_xin), {"initial", "parameters", "initial_and_parameters"}) then _ini, _par := [], []; if lhs(_xin) = "initial" then _ini := rhs(_xin) elif lhs(_xin) = "parameters" then _par := rhs(_xin) elif select(type, rhs(_xin), `=`) <> [] then _par, _ini := selectremove(type, rhs(_xin), `=`) elif nops(rhs(_xin)) < nops(_pars)+1 then error "insufficient data for specification of initial and parameters" else _par := rhs(_xin)[-nops(_pars) .. -1]; _ini := rhs(_xin)[1 .. -nops(_pars)-1] end if; _xout := lhs(_xout); if _par <> [] then `dsolve/numeric/process_parameters`(_n, _pars, _par, _yini) end if; if _ini <> [] then `dsolve/numeric/process_initial`(_n, _ini, _yini, _pars) end if; if _pars <> [] then _par := {seq(rhs(_pars[_i]) = _yini[_n+_i], _i = 1 .. nops(_par))}; for _i from 0 to _n do _y0[_i] := subs(_par, _yini[_i]) end do; for _i from _n+1 to _n+nops(_pars) do _y0[_i] := _yini[_i] end do else for _i from 0 to _n do _y0[_i] := _yini[_i] end do end if; _octl[25] := _y0[0]; _octl[20] := _y0[0]; _octl[17] := _y0[0]; _octl[31] := _y0[0]; for _i to op(2, op(2, op(_octl))) do _ctl[_i] := _octl[_i] end do; for _i to _n+nops(_pars) do _ysav[_i] := _y0[_i] end do; if _xout = "initial" then return [seq(_yini[_i], _i = 0 .. _n)] elif _xout = "parameters" then return [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] else return [seq(_yini[_i], _i = 0 .. _n)], [seq(_yini[_n+_i], _i = 1 .. nops(_pars))] end if else return "procname" end if end if; if _y0[0]-_xout = 0. then return [seq(_y0[_i], _i = 0 .. _n)] elif _octl[31]-_y0[0] = 0. then _octl[31] := _y0[0]-sign(_xout-_y0[0]) end if; _reinit := false; if _xin <> "last" then if 0 < 0 and `dsolve/numeric/checkglobals`(0, table( [ ] ), _pars, _n, _yini) then _reinit := true; if _pars <> [] then _par := {seq(rhs(_pars[_i]) = _yini[_n+_i], _i = 1 .. nops(_par))}; for _i from 0 to _n do _y0[_i] := subs(_par, _yini[_i]) end do; for _i from _n+1 to _n+nops(_pars) do _y0[_i] := _yini[_i] end do else for _i from 0 to _n do _y0[_i] := _yini[_i] end do end if end if; if _pars <> [] and select(type, {seq(_yini[_n+_i], _i = 1 .. nops(_pars))}, 'undefined') <> {} then error "parameters must be initialized before solution can be computed" end if end if; if _reinit or _ctl[17]-_xout <> 0. then if _reinit or 0 < _ctl[18] and _xout < _ctl[31] or _ctl[18] < 0 and _ctl[31] < _xout then for _i to op(2, op(2, op(_octl))) do _ctl[_i] := _octl[_i] end do; for _i to _n+nops(_pars) do _ysav[_i] := _y0[_i] end do else _ctl[29] := 2 end if; _ctl[9] := 2; _ctl[27] := _xout; if Digits <= trunc(evalhf(Digits)) then try evalhf(`dsolve/numeric/dverk78_engine`(_fcn, var(_ysav), var(_ycur), `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, var(_ctl), var(array( 1 .. 2, [ ] )), var(array( 1 .. 2, [ ] )), var(array( 1 .. 2, 1 .. 23, [ ] )))) catch: if searchtext('evalhf', lastexception[2]) <> 0 or searchtext('real', lastexception[2]) <> 0 or searchtext('hardware', lastexception[2]) <> 0 then `dsolve/numeric/dverk78_engine`(_fcn, _ysav, _ycur, `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, _ctl, array( 1 .. 2, [ ] ), array( 1 .. 2, [ ] ), array( 1 .. 2, 1 .. 23, [ ] )) else error  end if end try else `dsolve/numeric/dverk78_engine`(_fcn, _ysav, _ycur, `dsolve/numeric/dverk78_aa`, `dsolve/numeric/dverk78_cc`, `dsolve/numeric/dverk78_dd`, _ctl, array( 1 .. 2, [ ] ), array( 1 .. 2, [ ] ), array( 1 .. 2, 1 .. 23, [ ] )) end if; if _ctl[29]-3 <> 0 then Rounding := `if`(_y0[0] < _xout, -infinity, infinity); if _ctl[29]+1 = 0 then error "cannot evaluate the solution past %1, maxfun limit exceeded (see <a href='http://www.maplesoft.com/support/help/search.aspx?term=dsolve,maxfun' target='_new'>?dsolve,maxfun</a> for details)", evalf[8](_ctl[20]) elif _ctl[29]+2 = 0 then error "cannot evaluate the solution past %1, hmin > hmax, maybe error tolerance is too small", evalf[8](_ctl[20]) elif _ctl[29]+3 = 0 then error "cannot evaluate the solution past %1, step size < hmin, problem may be singular or error tolerance may be too small", evalf[8](_ctl[20]) else error "cannot evaluate the solution past %1, unknown error code returned from dverk78: %2", evalf[8](_ctl[20]), _ctl[29] end if end if; if _Env_smart_dsolve_numeric = true then if _y0[0] < _ctl[17] and procname("right") < _ctl[17] then procname("right") := _ctl[17] elif _ctl[17] < _y0[0] and _ctl[17] < procname("left") then procname("left") := _ctl[17] end if end if end if; [_ctl[25], seq(_ycur[_i], _i = 1 .. _n)] end proc, (2) = Array(0..0, {}), (3) = [z, X(z), Y(z)], (4) = []}); _vars := _dat[3]; _pars := map(rhs, _dat[4]); _n := nops(_vars)-1; _solnproc := _dat[1]; if not type(_xout, 'numeric') then if member(x_dverk78, ["start", 'start', "method", 'method', "left", 'left', "right", 'right', "leftdata", "rightdata", "enginedata", "eventstop", 'eventstop', "eventclear", 'eventclear', "eventstatus", 'eventstatus', "eventcount", 'eventcount', "laxtol", 'laxtol', "numfun", 'numfun', NULL]) then _res := _solnproc(convert(x_dverk78, 'string')); if 1 < nops([_res]) then return _res elif type(_res, 'array') then return eval(_res, 1) elif _res <> "procname" then return _res end if elif member(x_dverk78, ["last", 'last', "initial", 'initial', "parameters", 'parameters', "initial_and_parameters", 'initial_and_parameters', NULL]) then _xout := convert(x_dverk78, 'string'); _res := _solnproc(_xout); if _xout = "parameters" then return [seq(_pars[_i] = _res[_i], _i = 1 .. nops(_pars))] elif _xout = "initial_and_parameters" then return [seq(_vars[_i+1] = [_res][1][_i+1], _i = 0 .. _n), seq(_pars[_i] = [_res][2][_i], _i = 1 .. nops(_pars))] else return [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] end if elif type(_xout, `=`) and member(lhs(_xout), ["initial", 'initial', "parameters", 'parameters', "initial_and_parameters", 'initial_and_parameters', NULL]) then _xout := convert(lhs(x_dverk78), 'string') = rhs(x_dverk78); if type(rhs(_xout), 'list') then _res := _solnproc(_xout) else error "initial and/or parameter values must be specified in a list" end if; if lhs(_xout) = "initial" then return [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] elif lhs(_xout) = "parameters" then return [seq(_pars[_i] = _res[_i], _i = 1 .. nops(_pars))] else return [seq(_vars[_i+1] = [_res][1][_i+1], _i = 0 .. _n), seq(_pars[_i] = [_res][2][_i], _i = 1 .. nops(_pars))] end if elif type(_xout, `=`) and member(lhs(_xout), ["eventdisable", 'eventdisable', "eventenable", 'eventenable', "eventfired", 'eventfired', "direction", 'direction', NULL]) then return _solnproc(convert(lhs(x_dverk78), 'string') = rhs(x_dverk78)) elif _xout = "solnprocedure" then return eval(_solnproc) elif _xout = "sysvars" then return _vars end if; if procname <> unknown then return ('procname')(x_dverk78) else _ndsol; _ndsol := pointto(_dat[2][0]); return ('_ndsol')(x_dverk78) end if end if; try _res := _solnproc(_xout); [seq(_vars[_i+1] = _res[_i+1], _i = 0 .. _n)] catch: error  end try end proc

(6)

dsol3(500)

Warning,  computation interrupted

 

NULL

NULL

``


 

Download dver.mw

 

how to evaulate the value of R(z) for different values of z=0 to 1 with an interval of 0.1 and print ten values  in one column

R(z):= 1-cos^2*(Pi*z);
 

Hi 
I am trying to expand a function f(t) in terms of fractional power series:
for example please see attached file tree.mw
 

``

restart

f := proc (x) options operator, arrow; exp(x) end proc:

alpha := 1/2:

N := 10:

f_approximate := proc (x) options operator, arrow; sum(a[i]*x^`i&alpha;`, i = 0 .. N) end proc


``


 

Download tree.mw

 

thanks 
    

Hello, to all,
On my computer I have installed Windows 7 Professional, Maple 2018.2.1 and
Physics:-Version()[2];
 2019, January 5, 13:32 hours, version in the MapleCloud: 276,

    version installed in this computer: 276
When I try to compute some examples from your poste "PDE_and_BC_during_2018.mw", I get an error in Example 8:
Example 8: This problem represents the temperature distribution in a thin circular plate whose lateral surfaces are insulated (Articolo example 6.9.2):
pde__8 := diff(u(r, theta, t), t) = (diff(u(r, theta, t), r)+r*(diff(u(r, theta, t), r, r))+(diff(u(r, theta, t), theta, theta))/r)/(25*r);
                                       /                    
                                       |                    
                                       |                    
                                       |                    
              d                    1   |/ d                \
   pde__8 := --- u(r, theta, t) = ---- ||--- u(r, theta, t)|
              dt                  25 r |\ dr               /
                                       \                    

                                      2                  \
                                     d                   |
                                  -------- u(r, theta, t)|
          /  2                \          2               |
          | d                 |    dtheta                |
      + r |---- u(r, theta, t)| + -----------------------|
          |   2               |              r           |
          \ dr                /                          /
iv__8 := D[1]*u(1, theta, t) = 0, u(r, 0, t) = 0, u(r, Pi, t) = 0, u(r, theta, 0) = (r-(1/3)*r^3)*sin(theta);
   iv__8 := D[1] u(1, theta, t) = 0, u(r, 0, t) = 0,

                                       /    1  3\           
     u(r, Pi, t) = 0, u(r, theta, 0) = |r - - r | sin(theta)
                                       \    3   /           
pdsolve([pde__8, iv__8], u(r, theta, t), HINT = boundedseries(r = [0]));
Error, (in dsolve) cannot determine if this expression is true or false: not 0 <= -Pi

or I get no answer as in Example 10:
Example 10: A Laplace PDE with one homogeneous and three non-homogeneous conditions:
pde__10 := diff(u(x, y), x, x)+diff(u(x, y), y, y) = 0;
                    /  2         \   /  2         \    
                    | d          |   | d          |    
         pde__10 := |---- u(x, y)| + |---- u(x, y)| = 0
                    |   2        |   |   2        |    
                    \ dx         /   \ dy         /    
iv__10 := u(0, y) = 0, u(Pi, y) = sinh(Pi)*cos(y), u(x, 0) = sin(x), u(x, Pi) = -sinh(x);
      iv__10 := u(0, y) = 0, u(Pi, y) = sinh(Pi) cos(y),

        u(x, 0) = sin(x), u(x, Pi) = -sinh(x)
pdsolve([pde__10, iv__10]);

There are also no answer as in Examle 10 in the Examples 15, 18, 19
Can you give me a hint,  what could be wrong?
With kind regards
Wolfgang Gellien

 

Hello everyone!

I am trying to calculate the Killing vectors for the metric below. For such, I used the packages DifferentialGeometry and Physics. However, I found different results these packages. Could someone explain why?

Thanks in advance!

killing_test1.mw

killing_test2.mw

 

So I was trying to create a shorthand for creating a plot of multiple arrows, with the arrow colour dependent on the magnitude of the vector.
I currently have a set of vectors, v, I want to display, and v[4] is the largest.

I know this could be done by creating an arrow plot for each vector seperately and then by combining them using display:
arrow1 := arrow( v[1], width=0.15,length=20,color=ColorTools:-Color( (norm(v[1])/norm(v[4]))*[0,0,1] ) );
arrow2 := arrow( v[2], width=0.15,length=20,color=ColorTools:-Color( (norm(v[2])/norm(v[4]))*[0,0,1] ) );
...
print(plots:-display([arrow1, arrow2, ...]));


But I was wondering if it could be done in a fashion similar to this:
arrows := arrow([seq(v[i], i=1..4)],width=0.15,length=20,color=ColorTools:-Color((norm(v[i])/norm(v[4]))*[0,0,1]));
print(arrows);



(btw: it works fine replacing the last i with 1, which draws all arrows nearly black, or with 4, which as you guessed, draws all arrows blue...)

Help appreciated!

Look I have actually purchased the software 3 time in total throughout my life, but i have no money at this point but i have a Linux OS now and i am enjoying learning how to use that, so i was wondering if there is a standard old verson that is open source and availble for a Linux install

 

Sum of -(2*((-1)^n-1))*sin(n*Pi*x)*exp(-Pi^2*n^2*t)/(Pi*n) from n=20??? Thank you very much

I try to use command "for a in 1,2 do Tangent(f, x = a) end do" in my Maplet but it does not work. 

Here it is:

 [Button("Tangent line", Action( Evaluate(for a in 'solve(diff(func, x) = slp, x)' do 'MMLV1'='MathML[Export]('y'=Tangent(func,x=a))' end do)))],

 

And here is all code for my Maplet

> restart:with(Maplets[Elements]):with(Student[Calculus1]):  TL2:=Maplet([ ["Input function  f(x)=", TextField['func'](20)],[Button("Display function",Action(Evaluate('MMLV'='MathML[Export](func)')))],MathMLViewer['MMLV'](), ["Input slope", TextField['slp'](10)],  [Button("Tangent line", Action( Evaluate(for a in 'solve(diff(func, x) = slp, x)' do 'MMLV1'='MathML[Export]('y'=Tangent(func,x=a))' end do)))],   MathMLViewer['MMLV1']()   ]):  Maplets[Display](TL2):
print(`output redirected...`); # input placeholder

I am trying to create an array whose elements are from another matrix. Suppose I have a matrix of n cross m dimension my array will have a dimension of 1 cross n*m. When I create  array I am getting error. The array contains only last element of matrix. The expected answer is given in attachment.

sigma.mw

Suppose there is a list with edges (L1): [{3,5},{4,3},{4,6},{3,2},{2,6}] and a list with vertices (L2): [1,5,4].

I would like to get a true-statement when a number of L2 appears in one of the edges of L1.

I tried the following:

for i in L1 do

ME:=member(i,L2):
print(ME):

od: 

This only gives false-statements. Could anyone help me?

I found a case where pdetest fails when called after another call to pdetest. I am using Physics version 272 from the clould. Using Maple 2018.2.1 on windows 10

restart;
u:='u';x:='x';t:='t';
pde := diff(u(x, t), t) + diff(u(x, t),x) =0;
sol:=pdsolve(pde,u(x,t));
pdetest(sol,pde);
    #0  OK
   
#restart;
u:='u';x:='x';t:='t';
pde:=diff(u(x,t),t)+diff(u(x,t),x)=0;
bc:=u(0,t)=0;
ic:=u(x,0)=sin(x);
sol:=pdsolve([pde,ic,bc],u(x,t)) assuming x>0;
pdetest(sol,pde);
   
     #sol := u(x, t) = -sin(-x+t)*Heaviside(-t+x)   #OK
     
     #-Dirac(-t+x)*sin(x)*cos(t)+Dirac(-t+x)*cos(x)*sin(t)+
      Dirac(-x+t)*sin(x)*cos(t)-Dirac(-x+t)*cos(x)*sin(t)   #WRONG should be 0
 

 

If I run the above again, but with restart call in between active, so that all is cleared, then pdetest gives 0 as expected on the second pde, with the same solution

 

restart;
u:='u';x:='x';t:='t';
pde := diff(u(x, t), t) + diff(u(x, t),x) =0;
sol:=pdsolve(pde,u(x,t));
pdetest(sol,pde);
   #0   #OK
   
restart;
u:='u';x:='x';t:='t';
pde:=diff(u(x,t),t)+diff(u(x,t),x)=0;
bc:=u(0,t)=0;
ic:=u(x,0)=sin(x);
sol:=pdsolve([pde,ic,bc],u(x,t)) assuming x>0;
pdetest(sol,pde);
   
   #0   #OK !! 

can any one explain why this happens?  Is this a bug? It seems like pdetest caching problem. it remembers something from the last call and this affects the result it gives for the next call.

any work around?

First 724 725 726 727 728 729 730 Last Page 726 of 2218