The  explicit  option allows you to get the values of all roots at once. A total of 5 roots were found. Explicit expressions for the roots from the second to the fifth are very cumbersome:

restart;

eq1 := alpha + beta*r[c] - d*n[c] - Upsilon*n[c]*(n[r] + r[c]) - n[r]*(alpha - d*n[c] - b*(n[r] + r[c]));
eq2 := `eϒ`*n[c]*(n[r] + r[c]) - mu*n[r] + d*n[c]*n[r] + b*n[c]*n[r] - alpha*n[r];
eq3 := b*n[c]*n[r] + d*n[c]*n[r] - alpha*n[r] - beta*r[c] + mu*n[r];

Sol:=[solve({eq1, eq2, eq3}, {n[c], n[r], r[c]}, explicit)];
m:=nops(Sol);
for k from 1 to m do
Sol||k:=Sol[k];
od;

See help  ?examples,Physics .

restart;
T[e]:=1.2: T[i]:=0.01: delta[p]:=0.2:
V:=n(x)^2*((T[e]+T[i])/T[e])*((((n(x)-1)*(1+1/(2*delta[p]))))-ln(n(x))-ln(n(x))+ln(2*delta[p]));
Eq:=diff(n(x),x)=sqrt(-2*V);
dsolve({Eq, n(0)=1}, n(x), numeric);
plots:-odeplot(%,[x,n(x)], x=0..1);

Example:

d:=gcdex(x^3-1, x^5-1, x, 's', 't');
s, t;
is(d=s*(x^3-1)+t*(x^5-1));

restart;
`&I;` = (1/64)*(`&D;`^4-d^4)*Pi;

Example 1) :

geometry:-conic(c, x^2+x*y+y^2+2*x-2*y, [x, y]):
geometry:-detail(c);

Knowing the lengths of the major and minor semiaxes and the center, you can easily write down the standard equation of this ellipse.

restart;
ina := proc (n) false end :
a := proc (n) option remember; local k;
if n < 5 then k := 2*n-1
else for k from 2 while ina(k) or igcd(k, a(n-1)) <> 1 or igcd(k, a(n-2)) <> 1 or igcd(k, a(n-3)) <> 1
do  od; 
fi; ina(k) := true; k;
end proc:

m:=40:
L:=[seq([n,a(n)], n = 1 .. m)];
plot(L, view=[0..m,0..a(m)], size=[800,500]);

Use the  randpoly  command for this:

restart;
randomize():
for k from 1 to 54 do
pol[k]:=sort(x^4+randpoly(x, coeffs = rand(0. .. 2.), dense, degree = 3));
od;

Download QuestionAnim_new.mw

It works:

restart;
with(plots):
with(plottools):
Explore(plot([a*x^2, a*x^2+1], x=-1...1., -3..3), a=-1...1.);

Download simplification_new.mw

If we plot the expression under the square root sign in the denominator, then we see that this expression, as a function of  t , takes on parts of the interval not only positive, but also negative values, and at some points it is equal to 0. Therefore, we are dealing with an improper integral from a complex-valued function. If this integral is calculated over the interval where this expression is positive, then the numeric result is obtained instantly:

restart;
Expr:=4*x*y*(y^4+2*x*y-2)/sqrt((1-(2*x*y)^2+(-3*y^2+1)^2)*(1+(y^2-1)^2));
plot(eval(op(1,denom(Expr)), [x,y]=~ [-(1+sqrt(2))*cos(t)-(sqrt(2)-1)*sin(t), cos(t)-sin(t)]), t=0..2*Pi);
evalf(Int(eval(Expr, [x, y] =~ [-(1+sqrt(2))*cos(t)-(sqrt(2)-1)*sin(t), cos(t)-sin(t)]),t=Pi/2 .. 3*Pi/4));

In the Real Domain for the cube root, use the  surd  command. Your equation can probably only be solved numerically:

restart;
plot([9*log10(x + 1), surd(x,3)], x=-1..1, -1.5..1.5);
Student:-Calculus1:-Roots(9*log10(x + 1)=surd(x,3), x=-1..1);

                                                 [ - 0.1179028301,  0.,  0.1432344750]

I'm guessing that this column of numbers is received in a loop. If you want to convert these numbers to a list, then just give an indexed name to each number and then use the  convert(... , list) command to get the desired list.

Example:

restart;
for n from 1 to 10 do
L[n]:=ithprime(n):
print(%);
od:

convert(L, list);

                               2
                               3
                               5
                               7
                               11
                               13
                               17
                               19
                               23
                               29
              [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
 

restart:
CartProd:=proc(L::list({set,list}))
local n;
n:=nops(L);
if n=1 then return L[1] else
[seq(seq([op(p),l], l=L[n]), p=thisproc(L[1..n-1]))] fi;
end proc:

Examples of use:

CartProd([{a,b,c},{e,f}]);

CartProd([[0,1]$4]);

        [[a, e], [a, f], [b, e], [b, f], [c, e], [c, f]]

   [[0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 1, 1], 

     [0, 1, 0, 0], [0, 1, 0, 1], [0, 1, 1, 0], [0, 1, 1, 1], 

     [1, 0, 0, 0], [1, 0, 0, 1], [1, 0, 1, 0], [1, 0, 1, 1], 

     [1, 1, 0, 0], [1, 1, 0, 1], [1, 1, 1, 0], [1, 1, 1, 1]]