Maple Questions and Posts

These are Posts and Questions associated with the product, Maple

I wanted to derive the q(w) term in the following expression to get ∂ f/∂q(w), but I got an error

every thing is correct but i dont know why my PDE is not be zero, i did by another way is satidy but i change whole equation by sabstitutiin then i did ode test is satisfy by putting case in equation and solution with condition but when i want to use pdetest  test in pde is not satisfy ?

restart

_local(gamma)

with(PDEtools)

NULL

undeclare(prime)

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

(1)

declare(Omega(x, t)); declare(U(xi)); declare(V(xi)); declare(Theta(x, t))

Omega(x, t)*`will now be displayed as`*Omega

 

U(xi)*`will now be displayed as`*U

 

V(xi)*`will now be displayed as`*V

 

Theta(x, t)*`will now be displayed as`*Theta

(2)

xi := -t*tau+x

-t*tau+x

(3)

NULL

NULL

lambda := -tau/c; epsilon := -tau/c; delta := (2*c^2-gamma*tau)/(gamma-2*tau)

-tau/c

 

-tau/c

 

(2*c^2-gamma*tau)/(gamma-2*tau)

(4)

NULL

case1 := [c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

[c = RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)/gamma, A[0] = 0, A[1] = RootOf(_Z^2*gamma+2*tau), B[1] = 0]

(5)

K := Omega(x, t) = RootOf(_Z^2*gamma+2*tau)*tanh(xi)*exp(I*gamma*(delta*t+x))

Omega(x, t) = -RootOf(_Z^2*gamma+2*tau)*tanh(t*tau-x)*exp(I*gamma*((2*c^2-gamma*tau)*t/(gamma-2*tau)+x))

(6)

NULL

pde1 := I*(diff(Omega(x, t), `$`(t, 2))-c^2*(diff(Omega(x, t), `$`(x, 2))))+diff(U(-t*tau+x)^2*Omega(x, t), t)-lambda*c*(diff(U(-t*tau+x)^2*Omega(x, t), x))+(1/2)*(diff(Omega(x, t), `$`(x, 2), t))-(1/2)*epsilon*c*(diff(Omega(x, t), `$`(x, 3))) = 0

I*(diff(diff(Omega(x, t), t), t)-c^2*(diff(diff(Omega(x, t), x), x)))-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

(7)

NULL

subs(case1, pde1)

I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0

(8)

T := simplify(I*(diff(diff(Omega(x, t), t), t)-RootOf(-gamma^3*tau+2*_Z^2+2*gamma*tau-4*tau^2)^2*(diff(diff(Omega(x, t), x), x))/gamma^2)-2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)*tau+U(-t*tau+x)^2*(diff(Omega(x, t), t))+tau*(2*U(-t*tau+x)*Omega(x, t)*(D(U))(-t*tau+x)+U(-t*tau+x)^2*(diff(Omega(x, t), x)))+(1/2)*(diff(diff(diff(Omega(x, t), t), x), x))+(1/2)*tau*(diff(diff(diff(Omega(x, t), x), x), x)) = 0)

(1/2)*(2*gamma^2*(tau*(diff(Omega(x, t), x))+diff(Omega(x, t), t))*U(-t*tau+x)^2+(diff(diff(diff(Omega(x, t), t), x), x))*gamma^2+tau*(diff(diff(diff(Omega(x, t), x), x), x))*gamma^2-(4*I)*((1/4)*gamma^3+tau-(1/2)*gamma)*tau*(diff(diff(Omega(x, t), x), x))+(2*I)*(diff(diff(Omega(x, t), t), t))*gamma^2)/gamma^2 = 0

(9)

pdetest(K, T)

-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*(-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*t*tau)+exp(2*x))^3)

(10)

simplify(-(1/2)*2^(1/2)*(-tau/gamma)^(1/2)*((8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(8*I)*tau*c^2*U(-t*tau+x)^2*gamma^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+32*gamma^5*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+192*gamma^2*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-128*tau^4*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^4*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-96*gamma^3*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(128*I)*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-32*gamma^4*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+16*gamma^5*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-8*gamma^6*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(32*I)*gamma^3*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*U(-t*tau+x)^2*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*U(-t*tau+x)^2*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(12*I)*gamma^5*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))-(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))-(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))-64*gamma^4*c^2*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+64*gamma^3*tau^2*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(24*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(12*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(16*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(48*I)*gamma^2*tau^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(96*I)*gamma^2*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^3*tau*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*x*gamma-12*x*tau)/(gamma-2*tau))+(2*I)*c^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(4*I)*tau^2*gamma^6*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(6*I)*tau*gamma^5*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(40*I)*gamma^3*tau^3*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+(16*I)*gamma^4*c^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(20*I)*gamma^4*tau^2*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+4*gamma*t*tau-8*t*tau^2+2*x*gamma-4*x*tau)/(gamma-2*tau))+I*tau*gamma^7*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+6*gamma*t*tau-12*t*tau^2)/(gamma-2*tau))+(192*I)*tau^3*gamma*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau))+(8*I)*c^4*gamma^4*exp(((2*I)*gamma*c^2*t-I*gamma^2*t*tau+I*x*gamma^2-(2*I)*gamma*x*tau+2*gamma*t*tau-4*t*tau^2+4*x*gamma-8*x*tau)/(gamma-2*tau)))/(gamma^2*(gamma-2*tau)^2*(exp(2*tau*t)+exp(2*x))^3))

-(-tau/gamma)^(1/2)*((I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-((1/8)*I)*tau*gamma^7+(((1/4)*I)*c^2+((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(-((3/2)*I)*c^2-(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3+((5/2)*I)*tau^2+(-8*c^2+2)*tau+I*(c^2+2)*c^2)*gamma^4-4*(((5/4)*I)*tau^2+(-2*c^2+3)*tau+I*c^2-(1/2)*I)*tau*gamma^3+6*(I*tau^2-2*I+4*tau)*tau^2*gamma^2+((24*I)*tau^3-16*tau^4)*gamma-(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-t)*tau-I*c^2*t-2*x)*gamma+4*t*tau^2+8*x*tau)/(-gamma+2*tau))+(-I*gamma^3*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2+((1/8)*I)*tau*gamma^7+(-((1/4)*I)*c^2-((1/2)*I)*tau^2-tau)*gamma^6+(4*tau^2+(((3/2)*I)*c^2+(3/4)*I)*tau+2*c^2)*gamma^5+(-4*tau^3-((5/2)*I)*tau^2+(-8*c^2+2)*tau-I*(c^2+2)*c^2)*gamma^4+4*(((5/4)*I)*tau^2+tau*(2*c^2-3)+I*c^2-(1/2)*I)*tau*gamma^3-6*(I*tau^2-2*I-4*tau)*tau^2*gamma^2+(-(24*I)*tau^3-16*tau^4)*gamma+(16*I)*tau^4)*exp((I*(t*tau-x)*gamma^2+2*((I*x-2*t)*tau-I*c^2*t-x)*gamma+8*t*tau^2+4*x*tau)/(-gamma+2*tau))+I*gamma^2*(exp((I*(t*tau-x)*gamma^2+2*(-I*c^2*t+I*x*tau-3*x)*gamma+12*x*tau)/(-gamma+2*tau))-exp((I*(t*tau-x)*gamma^2+2*((I*x-3*t)*tau-I*c^2*t)*gamma+12*t*tau^2)/(-gamma+2*tau)))*(gamma*(-(1/2)*gamma+tau)*(c-tau)*(c+tau)*U(-t*tau+x)^2-(1/8)*tau*gamma^5+((1/4)*c^2+(1/2)*tau^2)*gamma^4+tau*(-(3/2)*c^2+1/4)*gamma^3+(c^4-(3/2)*tau^2)*gamma^2+3*tau^3*gamma-2*tau^4))*2^(1/2)/(gamma^2*(exp(2*t*tau)+exp(2*x))^3*(-(1/2)*gamma+tau)^2)

(11)
 

 

Download pdetest.mw

Is there something one can do to make Maple give same result each time? It seems all random.

Calling odetest sometimes gives internal error. 

            Error, (in trig/normal/sincosargs) too many levels of recursion

But it is random when and how it happens. Worksheet below shows that sometimes when adding infolevel[odetest]:=5; make the error go away. sometimes trying 2 or 3 times also makes the error go away.

This makes it impossible to reason about things, as sometimes I get different result using same exact code.

Is there something one can do to remove this internal error? Why it happens sometimes only?  Do I need to clear something before calling odetest to make sure same result is obtained each time?

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

Physics:-Version();

`The "Physics Updates" version in the MapleCloud is 1841 and is the same as the version installed in this computer, created 2025, January 3, 8:59 hours Pacific Time.`

libname;

"C:\Users\Owner\maple\toolbox\2024\Physics Updates\lib", "C:\Program Files\Maple 2024\lib"

restart;

sol:=y(x) = 1/2*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*
2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+
I)^2)/((I*2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(1/3)/(I*2^(1/2)+I);
ode:=x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*diff(y(x),x) = 0

y(x) = (1/2)*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+I)^2)/(((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)*(I*2^(1/2)+I))

x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*(diff(y(x), x)) = 0

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

odetest(sol,ode);

Error, (in trig/normal/sincosargs) too many levels of recursion

infolevel[odetest]:=5;

5

odetest(sol,ode);

odetest: Performing an implicit solution test

odetest: Performing an explicit (try hard) solution test

odetest: Performing an implicit solution (II) test

odetest: Performing another explicit (try soft) solution test

0

odetest(sol,ode,y(x));

odetest: Performing an implicit solution test

odetest: Performing an explicit (try hard) solution test

odetest: Performing an implicit solution (II) test

odetest: Performing another explicit (try soft) solution test

0

infolevel[odetest]:=0;

0

odetest(sol,ode,y(x));

0

restart;

sol:=y(x) = 1/2*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*
2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+
I)^2)/((I*2^(1/2)-1+I)*(I*2^(1/2)+1+I)^2)^(1/3)/(I*2^(1/2)+I);
ode:=x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*diff(y(x),x) = 0

y(x) = (1/2)*x*(-1-(1+I*3^(1/2))*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(2/3)-2*((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)-I*((I*2^(1/2)+I)^2-1)*3^(1/2)+(I*2^(1/2)+I)^2)/(((I*2^(1/2)+(-1+I))*(I*2^(1/2)+1+I)^2)^(1/3)*(I*2^(1/2)+I))

x^3+3*x*y(x)^2+(y(x)^3+3*x^2*y(x))*(diff(y(x), x)) = 0

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

odetest(sol,ode,y(x));

Error, (in trig/normal/sincosargs) too many levels of recursion

odetest(sol,ode,y(x));

0

Download why_odetest_sometimes_fail_internal.mw

Add tracelast; after an error gives long output with this at end

...
#(\`trig/normal\`,8): sincosargs := [\`trig/normal/sincosargs\`(a)];
 \`trig/normal/sincosargs\` called with arguments: ((-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064)*(10+7*2^(1/2))^(1/2)+(6008*6^(1/2)-8496*3^(1/2)+10408*2^(1/2)-14720)*cos((1/24)*Pi)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: ((-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064)*(10+7*2^(1/2))^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: (-2472*2^(1/2)+3496)*3^(1/2)-4288*2^(1/2)+6064
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: (-2472*2^(1/2)+3496)*3^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: -2472*2^(1/2)+3496
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))
 \`trig/normal/sincosargs\` called with arguments: -2472*2^(1/2)
 #(\`trig/normal/sincosargs\`,2): return op(map(procname,{op(x)}))

Not only is it random error, it also can not be cought using try/catch. So the whole program now stop and there is no way around it. If it was at least possible to trap the error, then it will not be a big deal. But when not even possible to trap Maple errors, then what is one to do? 


Update Jan 18, 2025

I did not want to make new post on this, even though the error is different, but it is similar issue to this post.

I found another example of this random failure of odetest using same input.  May be this will help Maplesoft find the cause. 

The internal error this time is Error, (in depends) too many levels of recursion

In this worksheet below. the same ode and 3 solutions were used. As you see, sometimes odetest do not generate internal error, and sometimes it does. All happen on 3rd call to odetest. 

So it is completely random why this happen. The first and 4ht tries generate no error, but the second and the third do. All were run after restart is called. So one would expect same output from each try,

restart;

interface(version);
Physics:-Version();

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

`The "Physics Updates" version in the MapleCloud is 1841 and is the same as the version installed in this computer, created 2025, January 3, 8:59 hours Pacific Time.`

First Try

 

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*x*(1+LambertW(-x*exp(-c__1))))+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

Error, (in depends) too many levels of recursion

 

 

 

 

Second Try

 

restart;

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))+4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

4*LambertW(-x*exp(c__2))*exp((2*I)*LambertW(-x*exp(c__2))+(2*I)*c__2+I*arctanh(-exp((2*I)*LambertW(-x*exp(c__2)))/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))+exp((2*I)*c__2)/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2)))*x)+4*exp((2*I)*c__2+(2*I)*LambertW(-x*exp(c__2)))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2))))

 

 

 

Third  Try

 

restart;

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

Error, (in depends) too many levels of recursion

 

 

 

4th  Try

 

restart;

ode:=1+y(x)^2+(x-exp(-arctan(y(x))))*diff(y(x),x) = 0;
sol_1:=y(x) = -tan(LambertW(-x/exp(_C1))+_C1);
timelimit(30,odetest(sol_1,ode,y(x)));

sol_2:=x*exp(arctan(y(x)))-arctan(y(x)) = _C1;
timelimit(30,odetest(sol_2,ode,y(x)));

sol_3:=y(x) = tan(-LambertW(-x*exp(_C2))+_C2);
timelimit(30,odetest(sol_3,ode,y(x)));

1+y(x)^2+(x-exp(-arctan(y(x))))*(diff(y(x), x)) = 0

y(x) = -tan(LambertW(-x/exp(_C1))+_C1)

4*LambertW(-x*exp(-c__1))*exp(-I*arctanh(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)-1/(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1))+(2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((1+LambertW(-x*exp(-c__1)))*x*(exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2)+4*exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)/((exp((2*I)*LambertW(-x*exp(-c__1))+(2*I)*c__1)+1)^2*(1+LambertW(-x*exp(-c__1))))

x*exp(arctan(y(x)))-arctan(y(x)) = c__1

0

y(x) = tan(-LambertW(-x*exp(_C2))+_C2)

4*exp((2*I)*c__2+(2*I)*LambertW(-x*exp(c__2)))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2))))+4*LambertW(-x*exp(c__2))*exp((2*I)*LambertW(-x*exp(c__2))+(2*I)*c__2+I*arctanh(-exp((2*I)*LambertW(-x*exp(c__2)))/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))+exp((2*I)*c__2)/(exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))))/((exp((2*I)*LambertW(-x*exp(c__2)))+exp((2*I)*c__2))^2*(1+LambertW(-x*exp(c__2)))*x)

 

Download bug_odetest_jan_18_2025.mw

Hello

Following on from my earlier question:

https://www.mapleprimes.com/questions/239620-Round-Robin-With-Double-Bye

a colleague has produced (admittedly hurriedly) a sports schedule over 14 weeks for a 8-team double bye, and a 10-team over 15 weeks. 
Looking at it, and counting the possible combinations, neither seem optimal...

The 8 team has equal byes, the 10 uneven.

Edit. Ideally no team would have 2 byes in a row. 

Is there a solution in maple over these weeks? given the min duration would be 13 weeks and the max 15 weeks?
In the previous solution by mmcdara the 8 bye schedule each team has played 6 times after week 8, but since the roster is truncated to 14 or 15, there will be some weeks when no byes are required (all teams playing) to even things up.
Similarly, the 10 bye each team has played 8 times after week 10, but since the roster is truncated to 14 or 15, there will be some weeks when no byes are required.

Any help would be welcome!
double_bye.xls

Edit: I made some counting errors. It's 28 and 45 as Carl pointed out
double_bye_revised.xls

Hello,

I present the result of work on a new project in the field of classical mechanics. It is a grateful and interesting topic that gives a lot of satisfaction. I am attaching the Maple worksheet.

Best regards

Rolling_Disk_3D_on_x0y_plane.mw

Hey guys,

I have to solve a bunch of systems of polynomial equations und dome restrictions given by inequalitites. I have 8 variables, 8 equations and and 13 inequalitites. Since the simple solve or SemiAlgebraic command are not able to solve every system I tryd some other ways. Right now I try to bring the set of equations and ineqaulities in a better from or structure using RealTriangulize from the RegularChains library. Later on I want to take those results and use solve or SemiAlgebraic again, hoping, that Maple than finds the solutions and is not calculating for houres without a result. I already know, that you can have diffrent outputs for RealTriangularize (I know list, record, piecewise and zerodimensional, althought the last one is not really helpful). Since I want to go on wirking with the results I need to have them in a form, that I can read of the new equations and inequalities to put them into solve. Often that works totaly fine, but sometimes I get an output I dont understand. I understand what It means but I dont understand why Maple uses that type of output. If you have a look in the attached file you can see what I mean:

restart; with(RegularChains); eq_5334 := {y*(m*x-m-n+1)+(-x+1)*n-x = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (-x-y+1)*p+m*y^2+x-y = 0, (x^2-x)*m+y*(t-1)-n+1 = 0, -k*n+s*x = 0, m*x*y-p = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; eq_5380 := {(-x-y+1)*p+m*x*y = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (m-1)*y^2+(-x+1)*y-p+x = 0, (x-1)*(m-1)*y-x^2-n+x = 0, m*x^2+(-m-n+1)*x+(-y+1)*n+t*y-1 = 0, -k*n+s*x = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; eq_5382 := {(-x-y+1)*p+m*x*y = 0, y*(m*x-m-n+1)+(-x+1)*n-x = 0, (-p+t)*k+p*y-t = 0, (k-x-y)*t-k*p+y = 0, (-x-y+1)*t+(-k+y)*n+x*s = 0, (-x-y+1)*p+m*y^2+x-y = 0, m*x^2+(-m-n+1)*x+(-y+1)*n+t*y-1 = 0, -k*n+s*x = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < n+(t-1)*p, 0 < (m*y-1)*n+(1-p)*(m*x-m+1), 0 < (m*x-m-t+1)*p+m*y*(t-n), 1 < x+y, k < 1, m < 1, s < t, t < 1}; sys := eq_5334; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5334 := RealTriangularize(sys, R, output = piecewise); sys := eq_5380; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5380 := RealTriangularize(sys, R, output = piecewise); sys := eq_5382; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5382 := RealTriangularize(sys, R, output = piecewise); sys := eq_5382; SuggestVariableOrder(sys); R := PolynomialRing(%); dec_5382_record := RealTriangularize(sys, R, output = record)

[AlgebraicGeometryTools, ChainTools, ConstructibleSetTools, Display, DisplayPolynomialRing, Equations, ExtendedRegularGcd, FastArithmeticTools, Inequations, Info, Initial, Intersect, Inverse, IsRegular, LazyRealTriangularize, MainDegree, MainVariable, MatrixCombine, MatrixTools, NormalForm, ParametricSystemTools, PolynomialRing, Rank, RealTriangularize, RegularGcd, RegularizeInitial, SamplePoints, SemiAlgebraicSetTools, Separant, SparsePseudoRemainder, SuggestVariableOrder, Tail, Triangularize]

 

[s, k, n, p, m, t, x, y]

 

R := polynomial_ring

 

dec_5334 := [[x*s+((-x^2+x)*m-t*y+y-1)*k = 0, (m*x*y-t)*k+(x+y)*t-y = 0, n+(-x^2+x)*m-t*y+y-1 = 0, -m*x*y+p = 0, (x^2*y+(y^2-y)*x-y^2)*m-x+y = 0, t*y^2-y^2+x = 0, (15*y^2+24*y+20)*x-6*y^2-13*y-10 = 0, y^3-y-2 = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < 12891634966*y^2+19613071879*y+16947294542, 0 < 1256597*y^2+1911761*y+1651926, 0 < 6310892468*y^2+9601263717*y+8296275330, 0 < 1401*y^2+2130*y+1840, 0 < 1-k, 0 < 1-m, 0 < 72927541996846438*y^2+110950482461140595*y+95870270479707846, 0 < 1-t]]

 

[s, k, n, p, m, t, y, x]

 

R := polynomial_ring

 

dec_5380 := piecewise(`and`(`and`(`and`(0 < x^3-2*x^2+3*x-1, 0 < x^3+2*x^2+x-1), x^3+x^2+x < 1), 0 < 3*x-1), [[s*x+((1-x)*y*m+(x-1)*y+x^2-x)*k = 0, (m*y^2-y^2-t+(1-x)*y+x)*k+(y+x)*t-y = 0, n+(1-x)*y*m+(x-1)*y+x^2-x = 0, p-m*y^2+y^2+(x-1)*y-x = 0, m*y-x-y+1 = 0, t*y^2+(x-1)*y^2+(2*x^2-2*x)*y+x^3-2*x^2+x = 0, (3*x-1)*y^2+(3*x^2-3*x)*y+x^3-2*x^2+x = 0, 0 < k, 0 < m, 0 < s, 0 < y, 0 < -6*x^6-9*x^5*y+20*x^5+27*x^4*y-27*x^4-32*x^3*y+19*x^3+17*x^2*y-7*x^2-3*x*y+x, 0 < 3*x^6+3*x^5*y-14*x^5-10*x^4*y+26*x^4+11*x^3*y-24*x^3-3*x^2*y+11*x^2-2*x*y-2*x+y, 0 < 6*x^5+9*x^4*y-17*x^4-18*x^3*y+17*x^3+11*x^2*y-7*x^2-2*x*y+x, 0 < y+x-1, 0 < 1-k, 0 < -m+1, 0 < t-s, 0 < 1-t]], [])

 

[s, k, n, p, m, t, x, y]

 

R := polynomial_ring

 

dec_5382 := piecewise(`and`(`and`(y^3-2*y^2+y < 1, 0 < y-1), 23*y^3-37*y^2+13*y-3 <> 0), [[-k*n+s*x = 0, (p-t)*k+(y+x)*t-y = 0, (y+x-1)*n+(-x*y+y)*m+x-y = 0, (y+x-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, x^3+(3*y-2)*x^2+(2*y^2-3*y+1)*x-y^3+y^2 = 0, 0 < k, 0 < s, 0 < x, 0 < -2*x^2*y^2-2*x*y^3+2*y^4+x^2*y+3*x*y^2-3*y^3-x*y+y^2, 0 < x^2*y^2+2*x*y^3+y^4-x^2*y-4*x*y^2-3*y^3+2*x*y+3*y^2-y, 0 < -x^2*y-x*y^2+y^3+x*y-y^2, 0 < y+x-1, 0 < 1-k, 0 < t-s, 0 < 1-t]], 23*y^3-37*y^2+13*y-3 = 0, [[-k*n+s*x = 0, (p-t)*k+(y+x)*t-y = 0, (y+x-1)*n+(-x*y+y)*m+x-y = 0, (y+x-1)*p-m*y^2-x+y = 0, m*y-1 = 0, t*y^2+x^2+(y-1)*x-y^2 = 0, (2377326*y^2-1587000*y+302588)*x^2+(390793*y^2+497766*y+138115)*x-507805*y^2+152032*y-109047 = 0, 23*y^3-37*y^2+13*y-3 = 0, 0 < k, 0 < m, 0 < s, 0 < x, 0 < y, 0 < 700112222844255556263586865*x*y^2-260269572171898884295316974*x*y-93795749047261033657544191*y^2+73822886321394794237709987*x+34866975665513154551125606*y-9877974587657378842117575, 0 < -26166721441919*x*y^2+9412709182291*x*y+53422638514257*y^2-3387596446782*x-21180373503698*y+6484087812711, 0 < 21236600258115*x*y^2-8079468597142*x*y-3053799376681*y^2+2340822678357*x+1387037467490*y-370794765921, 0 < y+x-1, 0 < 1-k, 0 < -m+1, 0 < t-s, 0 < 1-t]], [])

 

[s, k, n, p, m, t, x, y]

 

R := polynomial_ring

 

`Non-fatal error while reading data from kernel.`

(1)

NULL

I would like to get results like in dec_5334. I can easily go on working with this kind of form. In dec_5380 you can see a diffrent output. I dont see the point of giving me this output. the second line i basically epmty. and in the first line the solution is broken into peaces. when a certain solution just works under some inequalitites, why dont they put those four inequalities inside of the list in front of it? Is there a workaround for the "normal" output? Or is there a way to read off the lines from this kind of structure, with the open { in front ?

The same problem appears in dec_5382. WHy dont give me a list with to lists of equations and inequalities to show me both solutions?
In the last example dec_5382_record you can see the output when you change the corresponding option in RealTrinagularize. But here I again have the problem that I dont know how to read of the equations and inequalities from the open curly bracket.

If anyone could help me, I would be very glad. Thank yu in advance.

Regards

Felix

Download Output_of_RegularChains.mw


Does any one have any idea to demonstrate, using Maple, that for any couple (a, b) of strictly positive integers

(a*b)! / (a! * (b!)^a) 

is an integer?

Hi

Can someone improve my AI code so I get to the final team's config directly, rather than a series of set iterations? thanks 

teams.mw

set 1: Michael K, Andy C
set 2: Michael G, Mitch
set 3: Jez, Dean B
set 4: Anthony B, Rik B
set 5: Ilya, Fariborz
set 6: Eugene, Tania
set 7: Bill, Stevs
set 8: Victor, Jane
set 9: Nash, Ben
 

Why doesnt this example work in my Maple 2021.1 from the user manual?

restart;
L := [seq(i, i = 2 .. 1000)];
divisor := 2;
while (numelems(L) > 0)  do  divisable,  L:=selectremove(i->(i mod divisor=0), L):
Error, unterminated loop

n:=numelems(divisable);  

if (n>0) then  printf("%d integers%s whose smallest prime divisor is %d\\n",n,  'if'(n>1, "s", ""), divisor):  end if;  

divisor :=nextprime(divisor);  

end do:
Error, unable to parse
 

Is there a way to put in intervals and get the output as inequality Notation? Something like this ->

I have a system of 4 nonlinear equations in 4 lambda variables. I cannot obtain a solution using solve():

4_nonlinear_equations.mw

I can sometimes simplify similar systems by rescaling equations to reduce parameters. With only 3 parameters (sigma_v, sigma_d, sigma_d3) in this case, complexity arises from the interactions of the 4 lambdas in the 4 equations. Upon examining the equations (highlighted in yellow), I suspect hidden symmetries. Is it possible to solve the system by rewriting the equations in terms of each other to find an equivalent system? I am exploring if a smarter and simpler reformulation could lead to a solution. Thank you.

I am very frustrated with the geometry package.
I wanted to draw a circle thru 3 points and so I opened the geometry package help pages.
> restart;
> with(geometry);
> with(plots);

Here is the example given there
> circle(c1, [point(A, 0, 0), point(B, 2, 0), point(C, 1, 2)], 'centername' = O1)

As you can see the command uses the point command from the geometry package which is

> point(C, 1, 2)

Maple consistently uses := as the assignment operator. Not with this command. One would expect the syntax to be

>C:=point([-1. 2]);

or some such but no, that is not how it works.Notice that I am not alone in my opinion about this being a violation of standard Maple syntax; the Maple parser AGREES with me

> type(point(C,1,-3),point);
                             false

Perhaps I am just being grouchy but pointplot works fine with
> pointplot([[1, 3],[1.7, 2],[-1, 7]])

But
> pointplot([P1,P2,P3]);
Error, (in plots:-pointplot) number of elements in list must be a multiple of 2

Oh well, let’s see what we get with our circle construction
>display(c1);

Error, (in plots:-display) expecting plot structure but received: c1

Bad guess on my part.

> radius (c1)
yields the correct number and
> center(c1)
yields the name of the circle but
>coordinates(center_c1);
yields what I want. Peculiar but OK , let's go on.
I can write the equation of the circle now that I have the center and radius but hopefully I try

>  equation(c1); and get an error message!!!

The commands center, radius work but equation does not! Here is what works
> Equation(c1)

If one really wants to CONFUSE the user why not eQuaTiOn? Who would guess that? (Sorry to be sarcastic but …) At least with the equation and implicit plot one can finally get a plot of the circle. Is that CLUMSY?

sometimes I need to check if an ode is missing y(x) or not. Since diff(y(x),x) has y(x) in it, then can not just check if the ode has y(x) or not as is, as this will always gives true if diffy(y(x),x) is there of any order.

Currently what I do, is change all y',y'',y''', etc... to Z,Z^2,Z^3,etc... and then after that it is safe to check if y(x) exist or not.

Is there a better way to do this? Below is what I currently do and it works. Just wondering if there could a more elgent way to do this.

restart;

interface(version);

`Standard Worksheet Interface, Maple 2024.2, Windows 10, October 29 2024 Build ID 1872373`

ode:=y(x)*diff(y(x),x$2)^2+diff(y(x),x$3)+y(x)*sqrt(diff(y(x),x))+3*x+3=1/(x*y(x)*diff(y(x),x$5));
ode_order := Student:-ODEs:-DifferentialOrder(ode,y(x)):
ode:=convert(ode,D):
for N from 1 to ode_order do
    ode:=eval(ode,[(D@@N)(y)(x)=Z^N]);
od:
ode

y(x)*(diff(diff(y(x), x), x))^2+diff(diff(diff(y(x), x), x), x)+y(x)*(diff(y(x), x))^(1/2)+3*x+3 = 1/(x*y(x)*(diff(diff(diff(diff(diff(y(x), x), x), x), x), x)))

y(x)*Z^4+Z^3+y(x)*Z^(1/2)+3*x+3 = 1/(x*y(x)*Z^5)

has(ode,y(x))

true

 

 

Download find_if_any_ode_has_yx_jan_6_2025.mw

First 6 7 8 9 10 11 12 Last Page 8 of 2181