I suggest another way to solve the problem. We define the equation of the first curve explicitly, and the equation of the circle – parametrically. When curves are specified explicitly or parametrically (as opposed to specified by implicit equations), the quality of plotting is usually better. In addition, it is easier to solve various problems related to  curves, for example, finding the length of the curve or making animation, etc. In this example, we first find the values of the parameters corresponding to the ends of the circular arc. We also animated this curve using the technique from my post  https://mapleprimes.com/posts/207840-Combinations-Of-Multiple-Animations

restart;
x0:=1.588125352: y0:=0:
t1:=solve(x0=1.81+0.94*cos(t));
t2:=solve(y0=0.42+0.94*sin(t));
A:=plot((-1)*0.39*x^2 + 1.459*x ,x=0..1.588125352, color=red):
B:=plot([1.81+0.94*cos(t),0.42+0.94*sin(t), t=t1..t2], color=red):
with(plots):
plots:-display(A, B, scaling=constrained, size=[800,400]);
A1:=animate(plot,[(-1)*0.39*x^2 + 1.459*x ,x=0..a, color=red], a=0..1.588125352):
B1:=animate(plot,[[1.81+0.94*cos(t),0.42+0.94*sin(t), t=t1..s], color=red], s=t1..t2):
display([A1, display(op([1,-1,1],A1),B1)], insequence, scaling=constrained, size=[800,400]);

                          t1:=1.809081766
                         t2:=-0.4631947616

restart;
eq:=-2.*10^(-12)*p[1](t)*q[1](t) + 7.133360604*10^(-8)*p[1](t)*q[0](t) + 2.839877758*10^(-7)*q[0](t)*p[2](t) + p[0](t)*q[0](t) + p[0](t)^2 + q[0](t)^3 + p[1](t) + 8*q[4](t):
selectremove(s->degree(s)<=1, eq);  # Or
selectremove(s->degree(s)<=1, [op(eq)]);

To draw circular arcs in 3D you can use the  plots:-spacecurve  command. I also made your code more compact by using the  map  command and multiple assignments. This allowed us to remove a lot of repetitions.

restart;
with(plots): with(plottools): with(geom3d):
Con := cone([0, 0, -2], 0.7, 2, transparency = 0.8, color = "SpringGreen"):
map(point@op, [[A, 0, 0, 0], [B, 0, 0, -2], [C, 0.7, 0, 0]]):
S1, S2, S3 := map(segment@op, [[AB, [A, B]],[AC, [A, C]],[BC, [B, C]]])[]:
G := draw([S1, S2, S3], linestyle = [dash,dash,solid], color = red, thickness = 2):
l := textplot3d([[0, 0, 0, "A", align=right],[0, 0, -2, "B",align=right],[.8, 0, 0, "C",align=left]], font=[times, bold, 20]):
P := plottools:-point(coordinates~([A,B,C]), color=blue, symbol=solidsphere, symbolsize = 14):
Arc1:=spacecurve([0.7+0.35*cos(t),0,0.35*sin(t)], t=-Pi..-Pi/2-arctan(0.7/2), color=red, thickness=2):
Arc2:=spacecurve([0.4*cos(t),0,-2+0.4*sin(t)], t=arctan(2/0.7)..Pi/2, color=red, thickness=2): 
G0:=textplot3d([[0.06, 0, -1.65, alpha, font=[times, bold, 16], color = red], [0.5, 0, -0.1, typeset(`#msup(mn("67"),mo("°"))`), font=[times, bold, 15], color = red]]):
display(Con, G, l, P, G0, Arc1, Arc2, scaling = constrained, orientation = [45, 70], view=[-0.8..0.8,-0.8..0.8,-2.1..0.1], axes=none);

Should be assign instead of assigne.

restart;
x := rand(0. .. 1.)();                        
y := x+f(x):
subsindets(y, numeric, evalf[4]);
evalindets(y, numeric, evalf[4]);

Use  add  instead of sum:

restart;
B := (n, i, p) -> binomial(n, i)*(p^i)*(1-p)^(n-i)/i;
F:=(n,p)->add(B(n,i,p),i=1..n);
F(2,1);

I understood this as multiplying the inverse of a matrix by a vector, since in a cross  product both factors must be vectors. To multiply a matrix by a vector, an ordinary point is used:

restart;
xA := 4;
yA := 10;
xB := 0;
yB := 0;
xC := 13;
yC := 0;
Mat := Matrix(3, 3, [xA, xB, xC, yA, yB, yC, 1, 1, 1]);
phi := (x, y) -> Mat^(-1).<x, y, z>;
phi(4, 18/2);
phi(4, 10);
phi(13, 0);

You forgot the multiplication signs:

restart;
factor(a^2+2*a*b+b^2); 
sqrt(a^2+2*a*b+b^2);
sqrt(a^2+2*a*b+b^2) assuming a+b>=0;
sqrt(a^2+2*a*b+b^2) assuming a+b<0;

In the solution below, Pascal's triangle has a more traditional form:

restart;
for n from 0 to 7 do
print(cat(seq(cat(`   `,binomial(n,k),`   `), k=0..n)));
od:

Example a) 
Let  the points E(1,0), F(0,1), G(0,3), H(3,0). The Green's Theorem 

restart;
with(VectorCalculus):
SetCoordinates(cartesian[x, y]):
P:=x^2*y: Q:=x*y^2:
I1:=LineInt(VectorField(<P, Q>), Path(<cos(t), sin(t)>, t=0..Pi/2)): # Integration along the EF curve
I2:=LineInt(VectorField(<P, Q>), Path(<0,t>, t=1..3)): # Integration along the FG curve
I3:=LineInt(VectorField(<P, Q>), Path(<3*cos(t),3*sin(t)>, t=Pi/2..0)): # Integration along the GH curve
I4:=LineInt(VectorField(<P, Q>), Path(<t,0>, t=3..1)): # Integration along the HE curve
A:=I1+I2+I3+I4; # Left side of Green's formula
B:=int(eval((diff(P,y)-diff(Q,x))*r, [x=r*cos(t),y=r*sin(t)]), [r=1..3, t=0..Pi/2]); # Right side of Green's formula

Example b) can be solved similarly.

Examples:

restart;
L:=[a,b,c,d]:
L1:=map(t->t$3, L);
combinat:-permute(L1, 3);
nops(%);
combinat:-choose(L1, 3);
nops(%);

I think you are working in the real domain. So

restart;
is(-ln(1/c)=ln(c)) assuming c>0;

                                                 true

You can easily do this using the  InertForm  package:

restart;
b := Matrix(3, 6, [[-1/2, 0, 1/2, 0, 0, 0], [0, 0, 0, -1/2, 0, 1/2], [0, -1/2, -1/2, 1/2, 1/2, 0]]);
InertForm:-Display((1/2)%*(2*b), inert=false);

To plot arrows at the ends of the axes, as well as for labels for the axes (near the ends of the axes), you can use the tools of the  plots  package:

restart;
with(plots):
y:=x->1/abs(x):
arrow_x:=arrow([4.7,0],[0.01,0], width=0, head_width=0.2, head_length=0.3, shape=arrow):
arrow_y:=arrow([0,5.7],[0,0.01], width=0, width=0, head_width=0.3, head_length=0.2, shape=arrow):
label_x:=textplot([4.5,-0.3,"x"], font=[times,bold,16]):
label_y:=textplot([-0.5,5.5,"y"], font=[times,bold,16]):
display(plot(y, -4.7..4.7, -0.7..5.7, color=red, thickness=2), arrow_x, arrow_y, label_x, label_y);

To avoid labels for the axes that Maple builds by default, we used the operator form of specifying the function  plot(y, -4.7 .. 4.7, ... )

Edited.

Maple already has such a built-in procedure called the  combinat:-randperm  (random permutation).

Example of use:

restart;
randomize():
n:=70: m:=30:
combinat:-randperm([1$n, 0$m]);

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