The answer can't be determined from the given diagram. The top triangle is not necessarily right. What appears to be a rectangle may actually be a trapezoid.

If you can't see the Matrix (which will happen if it is too large), then issue the command

interface(rtablesize= infinity);

before the Matrix command.

Download table.mw

Excellent question!

First: This has nothing to do with your problem, but you should get rid of with(linalg). You are not using that package anyway, and it is deprecated (not intended to be used in new code).

The key to your problem is to never assign values to the Vector b's symbolic variables, h, y[0], and z[0] in this case. Rather, assign values to different variables and use eval to put them into b. Please let me know if you can understand the following example:

Download evalVector.mw

Please let me know if you have any trouble understanding the example or applying it to your situation.

Generating the Cartesian product of lists (all tuples) is discussed extensively in this post from 2007. Note that if (b+1)^n is large, say greater than 10 million, you may be better off using an iterator, i.e., generating the tuples one at a time rather than all at once (see ?combinat,cartprod ). The cut-off point for using an iterator depends on how much memory you can devote to storing the tuples. If you need help with an iterator, let me know. AFAIK, there is no benefit to using an iterator if you have the memory to do it non-iteratively, because iterators take significantly more processor time.

To generate them all at once, the best of the procedures from the thread mentioned above is this absolute gem of compact self-modifying code by Joe Riel:

CartProdSeq:= proc(L::seq(list))
local Seq,i,j;
option `Copyright (C) 2007, Joseph Riel. All rights reserved.`;
     eval([subs(Seq= seq, foldl(Seq, [cat(i, 1..nargs)], seq(cat(i,j)= L[j], j= nargs..1, -1)))])
end proc:

To use it with the parameters that you specified:

CartProdSeq([$0..b] $ n);

Change e^4 to exp(4). Then enter what you have above, ending each statement with a semicolon (if you're using 1D input). Then do

evalf(%);

The evalf is what converts it to a decimal form.

Does something make you think that there are nontrivial solutions? There are none.

There is no numeric option to solve. The equivalent is achieved with fsolve:

fsolve({E||(1..3)}, {c,d,e});

I agree with Axel that you should get rid of simplify(..., size). And don't change it plain simplify either.

Make the determinant computation thus

det_2:= abs(1/LinearAlgebra:-Determinant(J_2, method = minor));

If you make those changes, the whole computation will finish in five minutes or so and use about 1/2 G.

I disagree with Axel's skepticism about the overall feasibility of your computation. I have seen many examples where codegen:-optimize with the tryhard option reduced an expression from thousands of pages to a hundred or so lines of code. And, it does it in a few minutes.

The outer lattice, which is the trees connected by the black lines in the diagram, is 25^2; the inner lattice, the ones connected by the blue-grey lines, is 24^2.

We can use evalindets to set the _NN1~ variables that isolve returns to 0. It can even be a one-liner:

evalindets([seq(rhs(isolve({K*(K-1) > 6*C-2, K>0})[]), C= 2..10)], name, 0);

For the benefit of other readers: the goal here is to find the roots of

tan(sqrt(z)) = sqrt(z)

And I will assume that you're only interested in real roots.

For some reason that I don't understand, the AllSolutions option to solve does not provide any useful formula for the roots. Likewise with applying allvalues to the RootOf formula returned by solve.

The real roots can be found with RootFinding:-NextZero, but there are some subleties in its use. The main sublety here being that you have to give it a range over which to search for roots. First, note that there are no negative real roots, that the first root is 0, and that there is a countably infinite sequence of roots.

Root:= table():  Root[0]:= 0:
for k to 9 do
     Root[k]:= RootFinding:-NextZero(
          z-> tan(sqrt(z))-sqrt(z),
          Root[k-1],
          maxdistance= (Root[k-1]+5)^2
     )
od:
Root:= convert(Root, list);

There are several issues.

1. Remove the inner brackets. If brackets were needed for mathematical grouping (they're not in this case), they would have to be round parentheses. The outer brackets are fine---they indicate that you're building a list.
2. You need to give the command evalf(%). This is the command that reduces things, as much as possible, to decimal values.
3. I can't tell how you entered Pi. If you typed pi, you need to change it to Pi.

If you check these things and it still doesn't work, please upload your worksheet so that I can see what you actually typed.

Here is a procedure to generate the Matrix A such that A.variables = polynomials. I had to take off the (t)s to do this. That is, I changed a[1](t) to a[1], etc. They can be added back easily at any later time. If you prefer, I can change the procedure so that it takes them off and puts them back.

Download problem_4A.mw

Download problem_4A.mws

Change g:-`.` to g:-`*`.

Also, highly recommended: Change array to Array and get rid of evalm.

Recommended: Check out ifactors to replace ifactor. The output format is easier to work with in programs (do op manipulations, etc.); ifactor is mainly for interactive display.

No integer whatsoever has the stated property since 2014 is divisible by primes greater than 9, namely 19 and 53.

ifactor(2014);
                         (2) (19) (53)

A more interesting year for this question will be 2016 = 8*7*4*3*3.

The technique for solving this problem is essentially the same as for your previous problem.

Download I-T.mw