Maple does not solve your system, but just repeats the input. He always does this when the system is inconsistent.

Example:

fsolve({x^2+y^2=-1, x+y=1});

               fsolve({x+y = 1, x^2+y^2 = -1},{x, y})

Mathematica explicitly says that the system is inconsistent:

In[1]:= NSolve[{(-(1/((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p))))*((0.002 + 0.001)*
Sin[-0.39] - (0.001 + 1*(e + p))*
Cos[-0.39]*(e*(-m + (0.68/d) + (0.599/g)) +
j*m) - (1/((0.002 + 0.001)^2 + (0.001 +
1*(e + p))*(0.001 + 1*(j + p))))*((0.001 + 1*(j + p))*
Sin[-0.39] - (0.002 + 0.001)*
Cos[-0.39])*(j*(-n + (0/i) + (-0.73/l)) +
e*n)))/(2*10) == -0.12, (-((0.002 + 0.001))*
e/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*d)*(e*(-m + (0.68/d) + (0.599/g)) +
j*m) - ((0.001 + 1*(j + p))*
e)/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*d)*(j*(-n + (-0.73/l)) + e*n) + (e*n)/
d)/(2*10) == -0.069, (-((0.002 + 0.001))*
e/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*g)*(e*(-m + (0.68/d) + (0.599/g)) +
j*m) - ((0.001 + 1*(j + p))*
e)/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*g)*(j*(-n + (-0.73/l)) + e*n) + (e*n)/
g)/(2*10) == -0.079, (-(0.001 + 1*(e + p))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*i)*(e*(-m + (0.68/d) + (0.599/g)) +
j*m) - (-(0.002 + 0.001))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*i)*(j*(-n + (-0.73/l)) + e*n) - (j*m)/
i)/(2*10) == -0.003, (-(0.001 + 1*(e + p))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*l)*(e*(-m + (0.68/d) + (0.599/g)) +
j*m) - (-(0.002 + 0.001))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*l)*(j*(-n + (-0.73/l)) + e*n) - (j*m)/
l)/(2*10) == -0.023, -(1*
c*(1/((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p))))*((0.001 + 1*(j + p))*
Sin[-0.39] - (0.002 + 0.001)*Cos[-0.39])*e)/
d == -0.109, -(1*c*(-(0.002 + 0.001))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*i)*e)/d ==
0.0003, -(1*
f*(1/((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p))))*((0.001 + 1*(j + p))*
Sin[-0.39] - (0.002 + 0.001)*Cos[-0.39])*e)/
g == -4.928, -(1*f*(-(0.002 + 0.001))*
j/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*l)*e)/g ==
0.013, -(1*
h*(1/((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p))))*((0.002 + 0.001)*
Sin[-0.39] - (0.001 + 1*(e + p))*Cos[-0.39])*j)/
i == -0.058, -(1*h*((0.002 + 0.001))*
e/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*d)*j)/
i == -0.0005, -(1*
k*(1/((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p))))*((0.002 + 0.001)*
Sin[-0.39] - (0.001 + 1*(e + p))*Cos[-0.39])*j)/
l == -1.39, -(1*k*((0.002 + 0.001))*
e/(((0.002 + 0.001)^2 + (0.001 + 1*(e + p))*(0.001 +
1*(j + p)))*d)*j)/l == -0.011}, {c, d, e, f, g, h, i,
j, k, l, m, n, p}]

Out[1] = {}

Easier to solve your problem by  dsolve  command.

Finding  f(x)  and construction of the function  f :

restart;

g(x):=1/(1+cot(x)):

dsolve({diff(f(x), x)= g(x), f(Pi/4)=1}, f(x));

assign(%);

f:=unapply(f(x), x);

Checking:

f(Pi/4);

is(diff(f(x), x)=g(x));

                               1

                             true

Should be:

area:=proc(T::list(list))

1/2*abs(T[1,1]*(T[2,2]-T[3,2])+T[2,1]*(T[3,2]-T[1,2])+T[3,1]*(T[1,2]-T[2,2]));

end proc:

Examples:

T1:=[[x1,y1], [x2,y2], [x3,y3]]:

T2:=[[0,0], [1,2], [3,0]]:

area(T1);

area(T2);

Using  Vieta's formulars:

simplify((a+b)^3+(b+c)^3+(c+a)^3, {a+b+c=0, a*b+a*c+b*c=2013/2012, a*b*c=-2014/2012});

                              3021
                              ------
                              1006

It can be solved by hand if to use the identity

 (a+b)^3 + (b+c)^3 + (c+a)^3 = -3* a* b* c + 2* (a + b + c)^3 - 3* (a + b + c)* (a *b + a* c + b* c)

A straight line in the plane can be defined by its equation or two points through which it passes, rather than  a vector. The procedure  ISC  solves your problem.

ISC:=proc(T, Eq)  # T -  list of vertices of the triangle, Eq - equation of the line

local f;

f:=unapply(lhs(Eq)-rhs(Eq), op(indets(Eq)));

if not (convert([seq(f(op(T[i]))<0, i=1..3)], `and`) or

convert([seq(f(op(T[i]))>0, i=1..3)], `and`)) then true  else false  fi;

end proc:

Examples:

ISC([[0,0],[10,10],[10,0]], x+y=-1);

ISC([[0,0],[10,10],[10,0]], x+y=1);

                          false

                          true

If you want  Maple considers  I  as a symbol rather than imaginary unit, surround  I in command lines by oblique quotes. In the output  this is not visible.

restart;

K:=sin(2*a)*sin(2*b)/(sin(a)*2*cos*(b)^2+cos(a)^2*sin(b)^2+`I`[ex]/`I`[tr]):

r:=`I`[ex]/`I`[tr];

subs(`I`[ex]=`I`[tr]*'r', K);

restart;

expr:=4*sin(a)*cos(b)*cos(a)*sin(b):

applyrule(sin(x::symbol)=sin(2*x)/2/cos(x), expr);

                       sin(2*a)*sin(2*b)

Instead  plot(x^(2/3), x=-1..1);  write  plot((x^2)^(1/3), x=-1..1);

By default, Maple operates in the complex domain and a value, such as  (-8) ^ (2/3),  it considers  as  ((-8) ^ (1/3)) ^ 2 = (1 + sqrt (3) * I)^2  rather than  ((-8) ^ (1/3)) ^ 2 = (-2)^2 =4  because of 3 complex values  (-8) ^ (1/3)  Maple returns the value with smallest argument. 

simplify(8^(2/3));

            4

convert((1/2)*Pi, degrees);

               90*degrees

int(abs(x-2), x);

plot(%, x=-1..5);

restart;

a := miu1(t) = diff(lambda1(t),t) + lambda3(t):

b := miu2(t) = diff(lambda2(t),t) + lambda1(t) - 4*lambda3(t):

c := miu3(t) = diff(lambda3(t),t) + lambda2(t) - 3*lambda3(t):

d := miu(t) = 2*diff(lambda3(t),t$2) - 5*diff(lambda3(t),t) + 7*lambda3(t):

e:=diff(c, t):

S:=subs({diff(lambda1(t),t)=A,diff(lambda2(t),t)=B,diff(lambda3(t),t)=C,

diff(lambda3(t),t,t)=E}, {a,b,c,d,e}):

eliminate(S, {A,B,C,E});

op(%[2])/5;

I also don't understand the Question 2.

There are different ways to solve this problem. For example, it is a sequence of digits after the decimal point in the expansion of the fraction  248590/1369863  to decimal fraction:

evalf[48](248590/1369863);

                         0.181470701814707018147070181470701814707018147070

restart;

ys := [1.8*a+.4000000000*b+103.9*c-.5000000000*e-102.6*g = 0, .5000000000*b+102.6*c+.3*d+.3500000000*e-102.1*g = 0, -3.3*a-1.050000000*b+102.4*c+.7*d+.2500000000*e-105.1*g = 0, -2.5*a+1.450000000*b+102.6*c+3.3*d+1.050000000*e-102.4*g = 0, -1.6*a+1.100000000*b+105.8*c+.3*d+1.750000000*e-105.5*g = 0, -.7*a-.2500000000*b+105.1*c-.2*d+.2000000000*e-105.7*g = 0, -.3*a-.3500000000*b+102.1*c+2.5*d-1.450000000*e-102.6*g = 0, .2*a-.2000000000*b+105.7*c+1.6*d-1.100000000*e-105.8*g = 0]:

B := [a, b, c, d, e, g]:

A:=Matrix([seq([seq(coeff(lhs(ys[i]), B[j]), j=1..nops(B))], i=1..nops(ys))]);

Your system has infinitely many solutions, depending on two parameters  a  and  g .

The decision with checking:

sys:=[1.8*a+.4000000000*b+103.9*c-.5000000000*e-102.6*g = 0, .5000000000*b+102.6*c+.3*d+.3500000000*e-102.1*g = 0, -.3*a-.3500000000*b+102.1*c+2.5*d-1.450000000*e-102.6*g = 0, -2.5*a+1.450000000*b+102.6*c+3.3*d+1.050000000*e-102.4*g = 0, -3.3*a-1.050000000*b+102.4*c+.7*d+.2500000000*e-105.1*g = 0, -.7*a-.2500000000*b+105.1*c-.2*d+.2000000000*e-105.7*g = 0]:

sol:=solve(sys);

eval(sys, sol);