@MaPal93 This might work given that massive computer that you have. My plan:

1. Once again, we let Eq be the equations (actually expressions implicitly equated to 0), and let V be the variables being solved for (I'll call them decision variables from now on).
2. Once again, we set all other variables (I'll call them parameters) to 1. This'll make the system much easier to solve, and I want to do this proof-of-concept before substantially more effort is expended on solving with the parameters.
3. New idea:  Since the expressions are algebraic functions, they can be converted to polynomials, which are much easier to solve, and Maple can do the conversion in 2 seconds. This usually introduces extra solutions, but all the original ones are preserved. The extras can be filtered out by checking if they satisfy the original system.
4. The details of converting to polynomial form are

• extract the numerators, discard the denominators (command numer)
• command evala@:-Norm does the heavy algebra
• extract numerators again, because there were denominators under square roots that weren't touched by the first extraction.

5. Use the Groebner-basis method to solve the polynomial system. In Maple 2022 (and perhaps some earlier versions) this uses parallel processing. I got near 100% CPU utilization on my 4x2 hyperthreaded computer.

The degree of all the polynomials is 14, much lower than I was expecting.

Here are the commands:

P:= indets(Eq, name) minus V; #extract parameters
EqN:= ((numer@evala@:-Norm@numer)~@eval)(Eq, P=~ 1):
SolE:= CodeTools:-Usage(
    [SolveTools:-PolynomialSystem](
        EqN, V, engine= groebner, backsubstitute= false, preservelabels
    )
):
(length, length~, nops)(SolE);

Let that run either until it's finished, your memory is nearly full, or you can't take it anymore. Use operating system tools (such as Windows Task Manager) to keep an eye on processor utilization. It should start out strong. If not, kill it, and give the command 

kernelopts(numcpus);

and report the result here.

@Ronan Not true; a^b is positive for any positive a and real b; a^b is a uniquely defined complex number for any complex numbers a and b other than a and b both 0. Finally, it is not the primary purpose of the sign command to determine whether something is positive or negative.

Yes, of course it's true that x^2 = 3 has two roots, one positive and one negative, but only the positive one is called "the square root of 3".

It's especially weird that sign has no problem with the I; it's the square root that it objects to:

sign(I);
             1
sign(3^(1/2));
Error, unable to evaluate sign

@lcz Here's a one-liner for all k-cliques:

AllCliquesFixedSize:= (G::Graph, k::And(posint, Not(1)))->
    select(nops=k, (op~)~(combinat:-choose(GraphTheory:-Edges(G), k*(k-1)/2)))
:
AllCliquesFixedSize(K4, 3);
          {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}}

The complexity is, of course, O(binomial(n, k*(k-1)/2)), where n is the number of edges (rather than vertices).

@jalal Like this:

df:= DataFrame(
    subsindets[flat](
        Matrix(`~`[Vector@F](C)),
        {undefined, And(complexcons, Not(realcons))},
        ()-> dne
    ), 
    columns = C, rows = F(x)
);

This is the other set operation that I mentioned: 

FixedSizeBlocks2:= (S::set, L::nonnegint)-> local p, r, q:= iquo(nops(S), L, r), k;
    {seq}(
        {seq}(S[[seq](p[(k-1)*L+1..k*L])], k= 1..q),
        p= Iterator:-SetPartitionFixedSize([L$q, r])
    )
:
GT:= GraphTheory:
K4:= GT:-CompleteGraph(4):
FixedSizeBlocks2(GT:-Edges(K4), 3);
    {{{{1, 2}, {1, 3}, {1, 4}}, {{2, 3}, {2, 4}, {3, 4}}}, 
      {{{1, 2}, {1, 3}, {2, 3}}, {{1, 4}, {2, 4}, {3, 4}}}, 
      {{{1, 2}, {1, 3}, {2, 4}}, {{1, 4}, {2, 3}, {3, 4}}}, 
      {{{1, 2}, {1, 3}, {3, 4}}, {{1, 4}, {2, 3}, {2, 4}}}, 
      {{{1, 2}, {1, 4}, {2, 3}}, {{1, 3}, {2, 4}, {3, 4}}}, 
      {{{1, 2}, {1, 4}, {2, 4}}, {{1, 3}, {2, 3}, {3, 4}}}, 
      {{{1, 2}, {1, 4}, {3, 4}}, {{1, 3}, {2, 3}, {2, 4}}}, 
      {{{1, 2}, {2, 3}, {2, 4}}, {{1, 3}, {1, 4}, {3, 4}}}, 
      {{{1, 2}, {2, 3}, {3, 4}}, {{1, 3}, {1, 4}, {2, 4}}}, 
      {{{1, 2}, {2, 4}, {3, 4}}, {{1, 3}, {1, 4}, {2, 3}}}}

The number of partitions produced by the procedure is n!/(L!^q * q! * (n-L*q)!), where n = nops(S) and q = floor(n/L).

The n1 is the summation index variable. Note the n1 = 1 under the summation sign. You could change it to any otherwise-unused variable, provided that you change all 4 occurrences.

@Carl Love Even after setting all parameters to 1 and examining some subsets of size 6 that contain the 6 decision variables, I can make no progress with either solve or even fsolve. They're too large or complicated. I give up.

If someone else wants to look at this: At least all the equations are algebraic functions (rational functions & fractional exponents) with the highest exponent being 4 and the only fractional exponent being 1/2.

@vs140580 Okay, how about this?

IsLabeledIsomorphicSubgraph:= proc(
    G1::Graph, G2::Graph, Labels::{set, list}({string, symbol, integer})
)
uses GT= GraphTheory;
local R:= GT:-IsSubgraphIsomorphic(G1, GT:-InducedSubgraph(G2, Labels), 'isomorphism');
    if [R][1] then subs(R[2], GT:-Edges(G1)) else false fi    
end proc
:

@MaPal93 Sorry, I made a mistake in the command  EqP:= eval(Eq, indets(EqN, name)=~ 1): That sets all variables to 1, including the decision variables V. Change it to

EqP:= eval(Eq, (indets(EqN, name) minus V)=~ 1):

@MaPal93 Why do you think that there's a solution? 

@mehdibgh There are two different variables t here: a global t in the matrices, and a local t in the procedure. Easiest way to fix it (but not the most-robust way): Change for t from to for :-t from. The :- prefix always refers to a global variable.

There are some possibilities of ambiguity for the 2nd case. What do you want returned for

SublistSubs([a,a]= x, [a,a,a], type2) ?

Both [x, a, a] and [x, x, a] seem reasonable. 

@Stretto An inert operator expression is type function in Maple, with the function name being the operator in backquotes, such as `%/`. (That doesn't generalize to non-inert operator expressions.) If f is a function, then op(k, f) is its kth argument, and op(0, f) is the function name. So, 3 %/ 6 is stored internally as `%/`(3, 6).

I think that this procedure will handle all cases (even when there's no inert operators in the expression):

NumerDenom:= (e::algebraic)-> local f;
    eval([numer,denom](evalindets[2](e, specfunc(`%/`), f, value@map)), f= (x-> x))
:
NumerDenom(x*3 %/ 6/y);
             [3 x, 6 y]

Since I think that that handles all cases, using an overload isn't necessary; but since you asked, the command is overload, it has a help page, and, yes, it filters through a list of procedures until finding the first one whose parameters are a type match for the arguments.

@jalal The code for a "does not exist" symbol is

dne:= `#mo("∄");`;

Then you could do subs(undefined= dne, whatever ).