MaplePrimes Questions

Hi,

Is there a way to vary C in steps of fractions of Pi ? Thanks

Q_Pi_scaling.mw

What am I missing here?  I type in a simple differential equation and I get .. unable to parse error.

For practice, I would like to calculate the left-hand limit according to the attached file. The computer does not finish. The result pi^2/6 is known from a calculation "on foot".

restart

``

limit((1-t)^2*(sum(k*t^k/(1-t^k), k = 1 .. infinity)), t = 1, left)

limit((1-t)^2*(sum(k*t^k/(1-t^k), k = 1 .. infinity)), t = 1, left)

(1)

"(->)"``

``

Download test.mwtest.mw

Hello, an interesting issue about set equivalence.

Logically, the two sets are equivalent by derivation.

The first principal case, for set A, k=0, the element values ​​are Pi/6 and 5*Pi/6, which corresponds to the case of k=0 (element value is Pi/6) and k=1 (element value is 5*Pi/6) in set B. Obviously, the k value is not one-to-one correspondence, but just a letter representing a positive integer. As for the second general case, it is the same steps I thought.

So, how to verify that the two sets are equivalent? I know Maple cannot do it in one step, but I don't know how to do it?

A := solve(sin(x) = 1/2, allsolutions = true)

(1/6)*Pi+2*Pi*_Z5, (5/6)*Pi+2*Pi*_Z5

(1)

A := `assuming`([`union`({(1/6)*Pi+2*k*Pi}, {Pi-(1/6)*Pi+2*k*Pi})], [k::integer])

{(1/6)*Pi+2*k*Pi, (5/6)*Pi+2*k*Pi}

(2)

B := `assuming`([{k*Pi+(1/6)*(-1)^k*Pi}], [k::integer])

{k*Pi+(1/6)*(-1)^k*Pi}

(3)

is(A = B)

false

(4)

restart

alpha = 'alpha'

alpha = alpha

(5)

solve(sin(x) = alpha, x, allsolutions = true)

2*Pi*_Z1+arcsin(alpha), -arcsin(alpha)+Pi+2*Pi*_Z1

(6)

A := `assuming`([`union`({arcsin(alpha)+2*k*Pi}, {Pi-arcsin(alpha)+2*k*Pi})], [k::integer])

{arcsin(alpha)+2*k*Pi, Pi-arcsin(alpha)+2*k*Pi}

(7)

B := `assuming`([{k*Pi+(-1)^k*arcsin(alpha)}], [k::integer])

{k*Pi+(-1)^k*arcsin(alpha)}

(8)

is(A = B)

false

(9)
 

NULL

Download verify_set_A_and_set_B_is_equivalent.mw

I have Maple 2024 and successfully loaded the FeynmanIntegral package with:

with(Physics); with(FeynmanIntegral);

Maple confirms that FeynmanIntegral is loaded by displaying:

[Evaluate, ExpandDimension, FromAbstractRepresentation, Parametrize, Series, SumLookup, TensorBasis, TensorReduce, ToAbstractRepresentation, epsilon, varepsilon]

However, when I attempt to evaluate a Feynman integral, Maple only displays the unevaluated expression instead of computing it:

Delta(q); %FeynmanIntegral(1/p^2*1/(p + q)^2, p);

And explicitly calling Evaluate() does not compute the result:

Evaluate(Delta(q));

  1. Using Evaluate() explicitly:

    FeynmanIntegral:-Evaluate(1 / (p^2 * (p + q)^2), p);

    Result: No evaluation, only displays the input.

  2. Assigning the integral to a variable before evaluating:

    I := FeynmanIntegral(1 / (p^2 * (p + q)^2), p); Evaluate(I);

    Result: Still does not evaluate.

  3. Using dimension= instead of d= when specifying the spacetime dimension:

    FeynmanIntegral:-Evaluate(1 / (p^2 * (p + q)^2), p, dimension = 4 - 2*epsilon);

    Result: No evaluation.

  4. Checking if FeynmanIntegral functions exist:

    showstat(FeynmanIntegral);

    Result: The package seems loaded, but it does not execute calculations.

I expect FeynmanIntegral:-Evaluate(...) to automatically compute the dimensional integral using Feynman rules and return a result.

  1. Is FeynmanIntegral:-Evaluate() broken in Maple 2024?
  2. Are there additional setup steps needed to enable full functionality?
  3. Has anyone successfully used FeynmanIntegral for automatic dimensional integration?
  4. Are there alternative Maple functions/packages for computing Feynman integrals in dimensional regularization?

Any help would be greatly appreciated!

this function i have is so long and my parameter are twenty they are two much when i make a change in explore i the change is so slow and i can't see some of this parameter how act to figure when i change becuase the placement of parameters i want some of parameter being in right  and some of them being in right  and figure be in the middle for see them together can we do something like that?

figure.mw

How do we simplify the arguments of the exponential in (1)? Further how to express (1) into hyperbolic/trig functions? 
 

restart

with(LinearAlgebra)

Bans := -8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+(2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-(2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+(2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4)))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+(2*(delta3^2+delta4^2))*(y*a*delta1^2+(1/2)*t)*delta2+(2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4)))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

-8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))+(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))-(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

(1)

argexp1 := simplify((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+(2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)), size)

(-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(y*delta3^3*a*I+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+y*delta4^2*a*I)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+delta2*I)*(delta4*I-delta3)*(delta3+delta4*I)*(delta2*I-delta1))

(2)

 

argexp2 := ((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-(2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-I*t*(1/2)+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4)))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))

((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+t*I)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(y*delta3^3*a*I-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+y*delta4^2*a*I)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+delta2*I)*(delta4*I-delta3)*(delta3+delta4*I)*(delta2*I-delta1))

(3)

simplify(argexp1+argexp2)

2*(x+y+t)^2*(B2+B1+B3+B4)

(4)

terms := op(Bans)

-8*delta2*delta4*delta1*(delta3^2+delta4^2)*exp((-(2*I)*y*a*(delta3^2+delta4^2)*delta1^3+((2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+((2*I)*y*delta4^2*a-I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2-(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1+2*(I*y*delta3^3*a+(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3+(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -8*delta2*delta3*delta4*(delta1^2+delta2^2)*exp(((2*I)*y*a*(delta3^2+delta4^2)*delta1^3+(-(2*I)*y*delta3^3*a+(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-(2*I)*y*delta4^2*a+I*t)*delta3+delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta1^2+(2*I)*(y*delta2^2*a-(1/2)*t)*(delta3^2+delta4^2)*delta1-2*(I*y*delta3^3*a-(1/2)*(x+y+t)^2*(B2+B1+B3+B4)*delta3^2+(-((1/2)*I)*t+I*y*delta4^2*a)*delta3-(1/2)*delta4^2*(x+y+t)^2*(B2+B1+B3+B4))*delta2^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), (delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B1+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B3))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B1+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B1+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), (delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((delta3+I*delta4)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(delta4^2+I*delta4*delta1+delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(-2*y*delta4^3*a+2*(x+y+t)^2*(B2+B3)*delta4^2+(-2*a*delta3^2*y-t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B3))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*delta1^2*(-y*delta4^3*a+(x+y+t)^2*(B2+B3)*delta4^2+(-(1/2)*t-y*a*delta3^2)*delta4+delta3^2*(x+y+t)^2*(B2+B3)))/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -(delta2^2+2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(-I*delta3^2-I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((-2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B1+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B1+B4))*delta2^2-2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B1+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B1+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1))), -(delta2^2-2*delta4*delta2+delta4^2+(delta3-delta1)^2)*((I*delta4-delta3)*delta2^2+(I*delta3^2+I*delta4^2)*delta2+delta1*(-delta4^2+I*delta4*delta1-delta3*(delta3+delta1)))*exp((2*y*a*(delta3^2+delta4^2)*delta2^3+(2*y*delta4^3*a+2*(x+y+t)^2*(B2+B4)*delta4^2+(2*a*delta3^2*y+t)*delta4+2*delta3^2*(x+y+t)^2*(B2+B4))*delta2^2+2*(delta3^2+delta4^2)*(y*a*delta1^2+(1/2)*t)*delta2+2*(y*delta4^3*a+(x+y+t)^2*(B2+B4)*delta4^2+(y*a*delta3^2+(1/2)*t)*delta4+delta3^2*(x+y+t)^2*(B2+B4))*delta1^2)/((delta1+I*delta2)*(I*delta4-delta3)*(delta3+I*delta4)*(I*delta2-delta1)))

(5)

NULL


 

Download argument.mw

Hi everyone,

I'm trying to compute the cohomology group of some Lie algebras using the LieAlgebra package, but it appears that the Cohomology command doesn't provide the correct basis for the higher dimensional cohomology group, instead repeating up to the correct dimension only one element.

For example, with the following Lie algebra

L1:=_DG([["LieAlgebra", Alg1, [6]], [[[1, 3, 2], 1], [[1, 2, 3], -1], [[4, 6, 5], 1], [[4, 5, 6], -1]]])
DGSetup(L1)

the command

C := RelativeChains([])

does provide the correct k-forms on Alg1, but then

H := Cohomology(C)
provides
[[theta4,theta1],[theta1 &w theta4, theta1 &w theta4, theta1 &w theta4],[theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3,theta1 &w theta2 &w theta3], [theta1 &w theta2 &w theta3 &w theta4,theta1 &w theta2 &w theta3 &w theta4,theta1 &w theta2 &w theta3 &w theta4],[theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6, theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6], [theta1 &w theta2 &w theta3 &w theta4 &w theta5 &w theta6]

A similar thing does happen for the examples provided in the online help (e.g. example 1 from https://de.maplesoft.com/support/help/Maple/view.aspx?path=DifferentialGeometry/LieAlgebras/Cohomology). Is the command broken?

Any help is really appreciated.

when i use change maple to latex most of that equation when i want to change the place of term are change how i can fix that for example in (R) if watch in exponential the x is first term but after changing to latex are change which i have to change by hand how i can fix this issue?

restart

with(PDEtools)

with(LinearAlgebra)

NULL

with(SolveTools)

_local(gamma)

Warning, A new binding for the name `gamma` has been created. The global instance of this name is still accessible using the :- prefix, :-`gamma`.  See ?protect for details.

 

undeclare(prime)

`There is no more prime differentiation variable; all derivatives will be displayed as indexed functions`

(1)

NULL

declare(u(x, y, z, t))

u(x, y, z, t)*`will now be displayed as`*u

(2)

declare(f(x, y, z, t))

f(x, y, z, t)*`will now be displayed as`*f

(3)

NULL

W := Lambda = k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

Lambda = k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

(4)

latex(W)

\Lambda = k_{i} \left(w_{i} t +y l_{i}+r_{i} z +x \right)+\eta_{i}

 

Lambda[1] := k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i]

(5)

Q := f = 1+exp(Lambda[1])

f = 1+exp(k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i])

(6)

Q1 := subs(W, Q)

f = 1+exp(k[i]*(t*w[i]+y*l[i]+z*r[i]+x)+eta[i])

(7)

latex(Q1)

f =
1+{\mathrm e}^{k_{i} \left(w_{i} t +y l_{i}+r_{i} z +x \right)+\eta_{i}}

 

eq15 := w[i] = (-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))/(2*mu)

w[i] = (1/2)*(-1+(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1)^(1/2))/mu

(8)

latex(eq15)

w_{i} =
\frac{-1+\sqrt{-4 \beta  \mu  l_{i}-4 \delta  \mu  r_{i}-4 \mu  k_{i}^{2}-4 \alpha  \mu +1}}{2 \mu}

 

R := f(x, y, z, t) = 1+exp(k[i]*(x+l[i]*y+r[i]*z+(-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))*t/(2*mu))+eta[i])

f(x, y, z, t) = 1+exp(k[i]*((1/2)*(-1+(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1)^(1/2))*t/mu+y*l[i]+r[i]*z+x)+eta[i])

(9)

latex(R)

f =
1+{\mathrm e}^{k_{i} \left(\frac{\left(-1+\sqrt{-4 \beta  \mu  l_{i}-4 \delta  \mu  r_{i}-4 \mu  k_{i}^{2}-4 \alpha  \mu +1}\right) t}{2 \mu}+y l_{i}+r_{i} z +x \right)+\eta_{i}}

 
 

NULL

Download latex.mw

For the following task I only get the numerical solution 2.356... :
sum(n=1 to oo)[arctan(2/n^2)]
The known "closed" result is 3*pi/4.

Dear team,

Here below you can see a simple program containing 3 loops. The problem is  that even for low iterations the execution time seems endless. I kept this program running for over 10 minutes to no avail.   Could you help me? 

Here you are the technical details of my HP laptopper

 

Hi everyone,

I am trying to visualize the integral of x3 over the interval x=−1 to x=1. I tried using:

with(plots):
display(
   plot(x^3, x = -1 .. 1, color = black, thickness = 2),
   shadebetween(x^3, 0, x = -1 .. 1, color = cyan)
);

This works, but I wondered if there’s a better or more elegant way to visualize definite integrals. For example:

  • Can I add transparency to the shaded region?
  • Is there a built-in function that directly plots definite integrals with shading?
  • Any tips for improving the aesthetics of such plots?

Thanks in advance for any help!

Download εμβαδόν_χωρίου.mw

Windows 10. From normal command line window:

"C:\Program Files\Maple 2024\bin.X86_64_WINDOWS\mint.exe" foo.mpl

Gives this

The file foo.mpl is

export module ODE() 
    option object; 
    export ode::`=`;
end module;

Notice the funny looking characters in the output.

Why does it happen?

restart

with(PDEtools)

undeclare(prime, quiet); declare(u(x, y, z, t), quiet); declare(f(x, y, z, t), quiet)

``

(1)

thetai := k[i]*(t*w[i]+y*l[i]+z*r[i]+x)

eqw := w[i] = (-1+sqrt(-4*beta*mu*l[i]-4*delta*mu*r[i]-4*mu*k[i]^2-4*alpha*mu+1))/(2*mu)

Bij := proc (i, j) options operator, arrow; -24*mu/(sqrt(1+(-4*beta*l[j]-4*delta*r[j]-4*alpha)*mu)*sqrt(1+(-4*beta*l[i]-4*delta*r[i]-4*alpha)*mu)-1+((2*r[i]+2*r[j])*delta+(2*l[i]+2*l[j])*beta+4*alpha)*mu) end proc

NULL

theta1 := normal(eval(eval(thetai, eqw), i = 1)); theta2 := normal(eval(eval(thetai, eqw), i = 2))

eqf := f(x, y, z, t) = theta1*theta2+Bij(1, 2)

eqfcomplex := collect(evalc(eval(eval(eqf, l[2] = conjugate(l[1])), l[1] = a+I*b)), t)

eq17 := u(x, y, z, t) = 2*(diff(diff(f(x, y, z, t), x), x))/f(x, y, z, t)-2*(diff(f(x, y, z, t), x))^2/f(x, y, z, t)^2; equ := simplify(eval(eq17, eqfcomplex))

So we want to find a substitution that removes the time dependence from u. One way is to find the maximum and see how it moves. Here, the first solution gives what we want.

ans := solve({diff(rhs(equ), x), diff(rhs(equ), y), diff(rhs(equ), z)}, {x, y, z}, explicit)

 

NULL

Download hfz.mw

Hi! An basic and interesting issue.

First, why I run worksheet again and again, I will get different output (even seems understandable)? I guess maybe the memory is not renewed?

Second, how to obtain the periodic solution without adding ```k*Pi``` manually?

`assuming`([solve(sqrt(2)*sin(2*x-(1/6)*Pi) = 1)], [`in`(x, real)])

5/24

(1)

x := solve(sqrt(2)*sin(2*x-(1/6)*Pi) = 1)+k*Pi

5/24+k*Pi

(2)
 

NULL

Download periodic_solution_of_a_simply_Sine_function.mw

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