1007 Reputation

1 years, 247 days

Explain the undocumented “Enter triggers...

Maple 2024

There exists a new (?) checkbox  in the Interface tab of the Options dialog:

But I cannot find any find any explanation about it in the corresponding help page. What is the purpose of this feature?

Wrong `coulditbe`?...

Maple 2024

If I understand correctly, both of

```int(RETURN(is(y::positive)), y = 0 .. x) assuming 0 <= x, x < 1;
int(RETURN(coulditbe(y = 1)), y = 0 .. x) assuming 0 < x, x < 1;```

should output . However, Maple simply returns  for the second one.
Isn't this result incorrect? Or am I missing something?

Unexpected results from GraphTheory:-Wie...

Maple 2024

OEIS A034828 and OEIS A000292 (which give the Wiener index for the cycle graph and the path graph respectively) mention that

the Wiener index of the cycle of length 19 is 855 and
the Wiener index of the path with 19 edges is 1330

However,

```GraphTheory:-WienerIndex(GraphTheory:-CycleGraph(19));
=
38

GraphTheory:-WienerIndex(GraphTheory:-PathGraph(20));
=
38

```

So what happened here?

Wrong minimal polynomials?...

Maple 2024

Consider the following exact algebraic number

 > restart;
 > kernelopts('version'):
 > Physics:-Version():
 >
 >
 memory used=0.97MiB, alloc change=12.00KiB, cpu time=31.00ms, real time=27.00ms, gc time=0ns
 (1)
 >
 (2)
 >
 memory used=70.25GiB, alloc change=48.00MiB, cpu time=23.63m, real time=21.81m, gc time=3.18m
 (3)
 >
 (4)

I would like to find its minimal polynomial (without a priori knowledge).

According to the documentation,

if is an exact algebraic number, and and are not given, then `PolynomialTools:-MinimalPolynomial(expr)` will call  to compute an exact minimal polynomial of . If a name is not specified for the variable , then  will be used.

Regretfully, it is easy to see that the minimal polynomial of  cannot be the returned . And when I invoke  directly, the result is still not correct (and this evaluation takes a rather long time).
Another help page mentions that

the call `mp := evala(Minpoly(expr, _X))` computes the monic minimal polynomial of  in the variable  over the field of rational numbers (or multivariate rational functions); the resulting polynomial will not contain any algebraic numbers or functions.

However, as `type(mp, polynom(rational, _X))` gives , we know that cannot be the desired minimal polynomial of either.
So, what is the proper way to compute the minimal polynomial of  in Maple?

Code:

```use alpha=1-(1/2)/(1-(RootOf(16*_Z*(_Z*(2*_Z*(_Z*(8*_Z*(_Z*(_Z*(_Z*(32*_Z*(8*_Z-33)+1513)-812)-13)+267)-1469)-330)+811)+279)+345,index=2)-1/2)**2) in
expr:=(1+alpha)*sqrt(1-alpha**2)+(3+4*alpha)/12*sqrt(3-4*alpha**2)+2*(1+alpha)/3*sqrt(2*(1+alpha)*(1-2*alpha))+(1+2*alpha)/6*sqrt(2*((1-alpha)**2-3*alpha**2))
end:
CodeTools:-Usage(PolynomialTools:-MinimalPolynomial(expr));```

Of note, the minimal polynomial of an algebraic number  is the unique irreducible monic polynomial of smallest degree  with rational coefficients such that  and whose leading coefficient is 1

Why does `simplify` fail to rewrite cert...

Maple 2024

As the following worksheet shows,

 >
 > kernelopts('version');
 > Physics:-Version();

 > with(RealDomain):
 > eval(MTM:-det(<    a, b/2, d/2 |    b/2, c, e/2 |    d/2, e/2, f   >), PDETools:-Solve(MTM:-det(<      x**2 + y**2, x1**2 + y1**2, x2**2 + y2**2, x3**2 + y3**2 |      x, x1, x2, x3 |      y, y1, y2, y3 |      1, 1, 1, 1     >) = inner([a, b, c, d, e, f], [x**2, x*y, y**2, x, y, 1]),    {f, e, d, c, b, a}, 'independentof' = {y, x}))/MTM:-det(<   x1, x2, x3 |   y1, y2, y3 |   1, 1, 1  >): simplify(`%`);

 > eval(MTM:-det(<    a, b/2, d/2 |    b/2, c, e/2 |    d/2, e/2, f   >), PDETools:-Solve(MTM:-det(<      x**2 - y**2, x1**2 - y1**2, x2**2 - y2**2, x3**2 - y3**2, x4**2 - y4**2 |      x*y, x1*y1, x2*y2, x3*y3, x4*y4 |      x, x1, x2, x3, x4 |      y, y1, y2, y3, y4 |      1, 1, 1, 1, 1     >) = inner([a, b, c, d, e, f], [x**2, x*y, y**2, x, y, 1]),    {f, e, d, c, b, a}, 'independentof' = {y, x}))/(MTM:-det(<    x2, x3, x4 |     y2, y3, y4 |     1, 1, 1   >)*MTM:-det(<    x3, x4, x1 |     y3, y4, y1 |     1, 1, 1   >)*MTM:-det(<    x4, x1, x2 |     y4, y1, y2 |     1, 1, 1   >)*MTM:-det(<    x1, x2, x3 |     y1, y2, y3 |     1, 1, 1   >)): simplify(`%`);

If I understand correctly, , by default, should try combining every part of an expression with every other to apply a vast range of potential transformations to look at many different forms of it and make progress in picking out the simplest possible one. So, why is `simplify` unable to touch certain sub-expressions when they are encountered at intermediate stages in a computation?