@radaar  Unfortunately, I am not familiar with books on Maple in English. Maybe someone else will give such advice. I have long been using only the Maple help system if I forgot something. For example, in the aswer to your initial question, I simply opened the help for  Student:-MultivariateCalculus:-ApproximateInt  command and found the  partition  option for it.

@colin12345678  From your original code it is not clear of which expression the derivative is taken. I suggested that of  k(T)/2/Pi*Int(sin(theta)^2/delta(T)/(1+delta(T)), theta=0..Pi)) . In the code below, the derivative is taken only of  k(T)/2/Pi :

And the last option corresponds to the code in your last comment. Here, the derivative is taken only from the integral:

Download 1111.mw

Download 111.mw

@David Sycamore  The procedure code needs a minimal change so that it does not check all positive integers  k , but only numbers of the type  k=6*n  (n is positive integer):

Wrapped_prime:=proc(p::prime, N::posint:=5000)
local n, k, m0, m;
n:=length(p);
for k from 6 by 6 to N do
m0:=add(10^i, i=0..k-1);
m:=m0+10^k*p+10^(k+n)*m0;
if isprime(m) then return k fi;
od;
end proc:

Using this procedure, I checked all к (multiples of 6) up to N=10000 . The computer worked for more than an hour, but could not find a prime number.

Wrapped_prime(397, 10000);
 

@mmcdara In original code after  -2*tanh(2/T)  the sign  "+"  stands.

@David Sycamore  You do not need to do anything with the code of this procedure. You just have to copy this code as plain text into your worksheet. Then you press the enter key and after that you can use the procedure as shown in the examples above. You type (or copy) the procedure name and type the desired prime number in parentheses.

@JAMET   I did not understand the meaning of the question.

@Carl Love   for this useful clarification.

@Carl Love  I know. Of course, if for OP is necessary to select the smallest elements, the sum of which does not exceed a bound, then we can use a set. Otherwise, we should use a list.

@Rouben Rostamian   If you take  n  large enough, (n-5)/6^6  will be greater than 1.

1. 4 is the the total number of the roots of the equation.

2. To solve this equation it is better to use  Student:-Calculus1:-Roots  command. In your example, it immediately returns all 4 roots in symbolic form:

Student:-Calculus1:-Roots((x-1)*(x^3-9*x^2+4), x);

@weidade37211  As a part of your equation, write  (1-10^(-15))^(10^10-1);  in a separate line and press enter (you get  overflow). This is a rational number with a giant numerator and denominator. Maple tries to calculate it exactly and overflow occurs. To avoid this, it is enough to put a decimal point on one of the exact numbers. Then all calculations will occur in float format with the accuracy established by Digits (with 10 digits by default).

(1-10^(-15))^(10^10-1);
Error, numeric exception: overflow

(1-10^(-15))^(10^10.-1);
                                                   1.

To avoid loss of accuracy, I increased  Digits  in my answer below. See:
Digits:=20:
(1-10^(-15))^(10^10.-1);
                                                 0.99999000005000083332

@Wavish  Since you do not have a clear criterion for obtaining the wished line, then the solution "by eye" is likely to be the easiest and best solution to the problem.

An example of the creation of a specific matrix function:

F:=unapply(<t, t^2; sin(t), cos(t)>, t):
F(2);

@vv  In fact, as a formal symbolic result, we get the same thing. But if we try to assign some numeric constants to the symbols, then of course we get an error:

Ec := (Ems+I*Eml)*(1+((Ems+I*Eml)/Ef-1)*Zeta*phi/((Ems+I*Eml)/Ef+Zeta))/(1-((Ems+I*Eml)/Ef-1)*phi/((Ems+I*Eml)/Ef+Zeta)):
a:=simplify(Re(Ec)) assuming positive;
b:=simplify(Im(Ec)) assuming positive;
EC:=eval(Ec,Zeta=ZETA):
simplify(evalc([Re,Im](EC)));
eval(%, ZETA=Zeta);
is(a=%[1] and b=%[2]);
Zeta:=1;

@bsoudmand  This is the output of my code (in Maple 2018.2):

In the text form:

a:=(-Ems*Zeta*(Ef^2-2*Ef*Ems+Eml^2+Ems^2)*phi^2+((Zeta-1)*Ems^3+Ef*(Zeta-1)^2*Ems^2-(Zeta-1)*(Ef^2*Zeta-Eml^2)*Ems-Ef*Eml^2*(Zeta+1)^2)*phi+Ems*(Ef^2*Zeta^2+2*Ef*Ems*Zeta+Eml^2+Ems^2))/((Ef^2-2*Ef*Ems+Eml^2+Ems^2)*phi^2+(-2*Ems^2-2*Ef*(Zeta-1)*Ems+2*Ef^2*Zeta-2*Eml^2)*phi+Ef^2*Zeta^2+2*Ef*Ems*Zeta+Eml^2+Ems^2);

b:=-Eml*(Zeta*(Ef^2-2*Ef*Ems+Eml^2+Ems^2)*phi^2+(Ef*(Ef-2*Ems)*Zeta^2+(-Ef^2-Eml^2-Ems^2)*Zeta-2*Ef*Ems+Eml^2+Ems^2)*phi-Ef^2*Zeta^2-2*Ef*Ems*Zeta-Eml^2-Ems^2)/((Ef^2-2*Ef*Ems+Eml^2+Ems^2)*phi^2+(2*Ef*(-Ems+Ef)*Zeta+2*Ef*Ems-2*Eml^2-2*Ems^2)*phi+Ef^2*Zeta^2+2*Ef*Ems*Zeta+Eml^2+Ems^2);