## 12950 Reputation

8 years, 362 days

## map...

You may use
map(`*`, ineq, c);
It results a<b even when c is negative.
To avoid potential errors, you may use:
map(`*`, ineq, abs(c));  #  assuming c>0;

## sequence...

The "shortcut" < ... > obviously has very special evaluation (and parsing) rules, otherwise ";" would not work.

There are many Maple commands that do not accept directly sequence parameters. For example:

```S := k, k=1..3;
#                       S := k, k = 1 .. 3

sum(S);
#                               6

# Error, (in simpl/relopsum) invalid terms in product: 1 .. 3

#                              6```

## Branch...

When you dsolve without IC, the branch of LambertW is not known and the generic branch "0" is used (instead "-1").

The correct approach is to use the option implicit for dsolve without IC. Then change accordingly eq. It will be OK.

## assert...

A double (or multi) limit is in general more difficult than an iterated limit. But in your case the function (given by expr) is very simple, so both limits are easy to compute. And are indeed, if kernelopts('assertlevel'=2) is removed. However probably a  debugging assertion in limit/multi... produces the error.

## Strange automatic simplification...

```'(sqrt(2)*infinity + 1)/infinity';
#                              0

'(a*infinity + 1)/infinity';
#                              0

'(2*infinity + 1)/infinity';
#                           undefined

'(infinity^2 + 1)/infinity';
#                           undefined

'arcsin((sqrt(3)*infinity + 2)/(2*infinity))';
#                           arcsin(0)
```

## Numeric...

Unfortunately, you will need numerical values for n and s. For example:

```restart;
Int((n*p+exp(n*p))*exp(-p)*p^(s-1)*f^s/((n*p+exp(2*n*p))*factorial(s)), p = 0 .. 1):
J:=simplify(%):
K:=eval(J, [n=2,s=3]):
# value(K);
evalf(K);```

0.008566509780 * f^3

## NULL...

() means NULL

So, the ODE has not solutions. Actually this is easy to check. Calling dsolve without initial value it results the general solution:
Y = ln(-ln(x)*ln(5)-c*ln(5))*x/ln(5)
and

limit(Y, x=0) = 0,  so y(0) cannot be 5.

## Zeta(2)...

For infinite sums, SummationSteps can show only how to prove the convergence.
Your sum Zeta(2) can be computed using many methods; see e.g. the references in the wiki article Basel problem - Wikipedia.
Your sugested method cannot work in Maple. Note first that
Zeta(2) = Product( 1 / (1 - 1/p^2), p = primes)

(I have corrected your formula). Observe that:

1. primes (wrongly suposed to be the set of prime numbers in Maple) is infinite, so it cannot work for Product. Maple rejects even the syntax.
2. convert cannot obtain a power series from a constant.

Edit. You should replace (in this case) ChatGPT with a Calculus textbook.

## f1...

```f1:= x -> local y:= x-floor(x/(2*Pi))*2*Pi; piecewise(y < (1/2)*Pi, 2*y, y < Pi, Pi, y <= (3/2)*Pi, 3*Pi-2*y);

```

Now f=f1.

I don't quite understand Q2.

## formal...

The hypergeom command uses analytic continuation, but sum does not (by default).

If you want it, just define:

```F:=z->sum(po(1,n)^2/po(1/2,n)^2*z^n/(n+1),n=1..infinity, formal);
```

Then:

F(4);
8*hypergeom([1, 2, 2, 2],[3/2, 3/2, 3],4)
F(4.);
-1.215795612 + 1.672715456 I

## size...

simplify(expr) is simpler in the sense that the result does not contain a sqrt any more.
Using simplify(expr, size), expr remains unchanged.

## value...

```p := pds:-value(output = procedurelist);
p(0, 0.1);
#        [x = 0., t = 0.1, u(x, t) = -0.587785252292473]
```

You may want to use

```f:=(x,t)->rhs(p(x,t)[-1]):
f(0.23,0.5)
#                       -0.991900750572342```

## proc...

```rem_d:=proc(n::integer, d::posint)
local q:=n, q1;
if (d=1 or n=0) then return infinity fi;
while irem(q,d,'q1')=0 do q:=q1 od;
q
end proc;```

rem_d(294912,8)  #  9

## Solution...

```f := -log[2](7/10*x)+log[3](3*x-1):
#plot(f, x=1/3 .. 40);
limit(f, x=infinity);
#                           -infinity

fsolve(f, x=0.34 .. 100, maxsols=4);
#                   0.3730125034, 16.60731835

a,b:=%;
#               a, b := 0.3730125034, 16.60731835

evalf(eval(f, x=(a+b)/2));  # >0
#                          0.339241451