15364 Reputation

24 Badges

12 years, 102 days

MaplePrimes Activity

These are answers submitted by Kitonum

Unfortunately, Maple cannot cope with this task:

assume(m, posint, n, posint):

is((2*m-1)^(2^n)-1 mod 2^(n+2) =0);


But the problem is easily solved manually by induction, if we use the identity

(2*m-1)^(2^(n+1))-1=( (2*m-1)^(2^n)-1 )*((2*m-1)^(2^n)+1)

Change in the normal curve   phi(x)=1/(sigma*sqrt(2*Pi))*exp(-(x-a)^2/(2*sigma^2))  as the parameter  a  is changing from  -2  to  3  (sigma=1) :



Change in the normal curve   phi(x)=1/(sigma*sqrt(2*Pi))*exp(-(x-a)^2/(2*sigma^2))  as the parameter  sigma  is changing from  0.6  to  2  (a=1) :

plots[animate](plot,[1/sigma/sqrt(2*Pi)*exp(-(x-2)^2/2/sigma^2),x=-2..6,thickness=3],sigma=[ seq(0.6+k*0.005,k=0..280)]);

See   PathInt , LineInt and SurfaceInt commands in  Student[VectorCalculus]  Subpackage.

Found an error in my previous solution. Offer exact solution found by the exhaustive search, pre considerably narrowed the search area.

Rewrite the system as follows {a+b=7.11-c-d, a*b=7.11/c/d} . Therefore, for  the specified values ​​of  c  and  d , the values  a  and  b  satisfy the quadratic equation  z^2+(c+d-7,11)*z+7,11/c/d=0 . Discriminant is equal to  (c+d-7.11)^2-4*7.11/c/d >=0 .

Build the domain:

plots[implicitplot]([c*d*(c+d-7.11)^2-4*7.11, c+d=7.11], color=[red, blue],c=0..7.11, d=0..7.11, numpoints=10000);

It is clearly seen that each variable must be in the range  0.7..3.2


R:=[infinity, []]:

for a from 0.7 by 0.01 to 7.11/4 do

for b from a by 0.01 to (7.11-a)/3 do

for c from b by 0.01 to (7.11-a-b)/2 do

for d from c by 0.01 to min(3.2,7.11-a-b-c) do


if delta

od: od: od: od:

                         [0., [1.20, 1.25, 1.50, 3.16]]




It is better to write the procedure as follows. Then the number of factors can be arbitrary.

myproc1:=proc(L)   #  L is a list

convert(L, `*`);

end proc;


Solution of your problem:

map(myproc1, [[3,4], [2,3,4,10], [5,2,1]]);

                      [12, 240, 10]


local  i, j;

for i while x[i]=0 do; od;

for j from -1 by -1 while x[j]=0 do; od;

[i, ArrayNumElems(x)+j+1];

end proc; 

Because your system contains two redundant unknowns is easy to check that it has infinitely many solutions in four-dimensional space. But you do not look for solutions in the whole space, and on a discrete finite set  a=0.01 ... 7.11 by 0.01  and so on. I think that there does not exist exact solutions on this set.

 Natural formulation of the problem: on a given set of numbers to find a quartet  [a, b, c, d] , for which the left-hand sides of the system have the least differencies from the right-hand sides. As a measure of the difference consider  (7.11-(a+b+c+d))^2+(7.11-a*b*c*d)^2 . The procedure consists of two stages. To speed up work on the first stage we consider the wider step=0.1, and step=0.01 on the second stage near the optimum point of the  first stage.


R:=[infinity, []]:  # First stage

for a from 0.1 by 0.1 to 7.11 do

for b from a by 0.1 to 7.11 do

for c from b by 0.1 to 7.11 do

for d from c by 0.1 to 7.11 do


if delta<0.01 and delta<R[1] then R:=[delta, [a, b, c, d]]: fi:

od: od: od: od:



a0:=R[2,1]: b0:=R[2,2]: c0:=R[2,3]: d0:=R[2,4]:  # Second stage

for a from a0-0.09 by 0.01 to a0+0.09 do

for b from b0-0.09 by 0.01 to b0+0.09 do

for c from c0-0.09 by 0.01 to c0+0.09 do

for d from d0-0.09 by 0.01 to d0+0.09 do


if delta<R[1] then R:=[delta, [a, b, c, d]]: fi:

od: od: od: od:


         [.11296e-3, [.8, 1.8, 1.9, 2.6]]  # Result of the first stage

  [.266342400e-7, [.80, 1.76, 1.92, 2.63]]  # Result of the second stage



7.11-convert([.80, 1.76, 1.92, 2.63],`+`);

7.11-convert([.80, 1.76, 1.92, 2.63],`*`);




local L, i, j;


for i while x[i]=0 do


L:=[op(L), i];

for j from -1 by -1 while x[j]=0 do


[op(L), ArrayNumElems(x)+j+1];

end proc; 




          [1, 4]

It is easy to prove that in any interval  RealRange(n, n+1) , where  n is positive integer, function  x -> frac(x*floor(x)) - 1/2  has exactly n roots. Thereforу in  RealRange(1,100)  there are  add(n, n=1..99) = 4950  roots.  

Use geometry package. Specify the coordinates of all the objects. The solution is obvious:


assume(y1>0, x2>0, x3>0, x3<x2):

point(A,0,0), point(B,x1,y1), point(C,x2,0), point(R,x3,0):

line(BC, [B, C]), line(AB, [A, B]), line(AC, [A, C]), ParallelLine(PR, R, BC):

intersection(P, PR, AB):

ParallelLine(PQ, P, AC):

intersection(Q, PQ, BC):

line(AQ, [A, Q]), line(BR, [B, R]):

intersection(M, PR, AQ), intersection(N, PQ, BR):

triangle(APM, [A, P, M]), triangle(PBN, [P, B, N]), triangle(RQC, [R, Q, C]):

S1, S2, S3:=area(APM), area(PBN), area(RQC);


3^((x+3)/(5*x-2))-4 >= 5*3^((9*x-7)/(5*x-2)):  #   The original inequality

convert((x+3)/(5*x-2), parfrac);

convert((9*x-7)/(5*x-2), parfrac);

# Change in the original inequality y=3^(17/5/(5*x-2))

solve(5*(3^(9/5))/y<=(3^(1/5))*y-4, y);  # Solution for y

solve(3^(17/5/(5*x-2))>=3*3^(4/5));  # The final result



sys := {x = expand(a*(3*cos(t) - cos(3*t))), y = simplify(expand(a*(3*sin(t) - sin(3*t))))};

subs(sin(t)=solve(sys[2], sin(t)), subs(cos(t)=sqrt(1-sin(t)^2), sys[1]));

eq:=subs(y=abs(y), simplify(lhs(%)^2=rhs(%)^2)) ;

a:=1:   plots[implicitplot](eq, x=-4..4, y=-4..4, thickness=2, numpoints=10000);

The next procedure solves the problem:


local L, M, Div, k, i, K, j, T, P;

uses numtheory;


if n=1 then return [1,1] else




Div:=divisors(n) minus {1, n};

for k in Div while n/k>=k do

M:=[op(M), [n/k, k]];




for i from 3 to bigomega(n) do


for j from 1 to nops(L[i-1]) do

Div:=divisors(L[i-1][j,1]) minus {1, L[i-1][j,1]};

for k in Div while L[i-1][j,1]/k>=k and k>=L[i-1][j,2] do

K:=[op(K),[L[i-1][j, 1]/k, k, op(L[i-1][j][2..nops(L[i-1][j])])]];

od; od;




L:=[seq(L[i], i=1..bigomega(n))];


M:=[]; T:=[seq(ithprime(k), k=1..bigomega(n))];

for i from 1 to nops(L) do

P[i]:=[seq(T[k], k=1..i)];

for j from 1 to nops(L[i]) do

M:=[op(M), mul(P[i][t]^(L[i][j,t]-1), t=1..nops(P[i]))];

od: od:


[n, min(M)]; fi;


end proc:




[seq(Divs(n), n=1..100)];



plot3d([r*cos(t), r*sin(t)*cos(alpha), r*sin(t)*sin(alpha)], t=0..Pi, r=0..1, scaling=constrained, axes=normal, view=[-1..1, -1..1, -1..1]);

Easy to prove that the formula


gives the integer values ​​for each n.

The first 10 terms of the sequence:

1, 3, 6, 12, 33, 51, -22, -384, -1383, -3557

First 221 222 223 224 225 226 227 Last Page 223 of 239