That needs to use nested seqs:

seq(seq([A[i],B[j]], i= 1..5), j= 1..4);

or

seq(seq([A[i],B[j]], j= 1..4), i= 1..5);

A better way, which doesn't require hardcoding the list sizes, is

seq(seq([i,j], j= B), i= A);

A method that works for an arbitrary list of lists L, each of arbitrary length, is

L:= [A,B]:
CP:= combinat:-cartprod(L):
'CP[nextvalue]()' $ mul(nops~(L));

You can't assign to a procedure's parameter, n in this case. You need to copy the parameter to a local variable, and then assign to that.  Like this:

cs:= proc(N::posint)::nonnegint;
description "Find the number of steps for a Collatz sequence to reach 1.";
local n::posint:= N, q::posint, r::identical(0,1), count::nonnegint;
     for count from 0 while n > 1 do
          q:= iquo(n, 2, 'r');
          n:= `if`(r=0, q, 3*n+1)
     end do;
     count
end proc:

Also, your count was off by one to my mind: cs(1) should be 0.

The properties (in the strict Maple sense of "properties") of an object can be inquired with the about command; however, this is only useful if you've used the assume command, which is the command which gives objects properties.

Somewhat similar to properties are attributes, which can be inquired with attributes. An object will only have attributes if you give it attributes with setattribute. You can give attributes whatever meaning you want.

To see all subexpressions of an expression e, use indets(e, anything). The anything can be replaced with any type expression (in the strict Maple sense of "type" (see ?type)). For example, all the integrals in e can be found with indets(e, specfunc({Int,int})). This makes indets one of the most useful and most commonly used commands.

To have e broken down into a logical (but not visual) tree which includes the smallest detail of information, use ToInert(e). This is often too much information to wade through by reading; however, this information can be manipulated programmatically. Some of this information may be arranged in a logical fashion that doesn't exactly correspond to the internal representation of the object, but does correspond to the logical representation of the object.

To have e broken down into a more-visual tree, but which uses some more-cryptic abbreviations, use dismantle(e). This information, as far as I know, corresponds precisely to the internal representation. This information is quite difficult to manipulate programmatically.

Ultimately, everything in a computer is stored as numbers. If you really want to go down to that level, use disassemble(addressof(e)). This will break it down one tree level only. Each given number can be broken down further with disassemble if it's an address. It's a good idea to follow the dismantle tree when you are doing this.

You should put your Maple version in the header of your Question. There's check-off boxes and a pull-down menu for it.

Your zero-one Matrix can be created like this:

n:= 4:
subsMatrix:= <seq(x[], x= Iterator:-CartesianProduct([0,1]$n))>;

Your list of substitution equations can be created directly from the iterator like this:

A:= [seq(a[i], i= 1..n)]:
subsEqs:= [seq(
     select(e-> rhs(e)=0, A=~ convert(x[], list)),
     x= Iterator:-CartesianProduct([0,1]$n)
)];

So note that there's no need to create the subsMatrix if its only purpose was to be an intermediary for the creation of the subsEqs.

Your error? It's probably that you need to say LinearAlgebra:-RowDimension rather than simply RowDimension and likewise for ColumnDimension.

The Iterator package comes with Maple 2016. If you have older Maple, let me know.

In bcs, you need to put parentheses around f1 in the first boundary condition and around f3 in the fourth boundary condition.

The command indets(sys2 union {bcs11} union bcs, name) can be used to find such problems. It this case, it told me that D was being considered a name (as well as an operator).

You asked:

How can I see the order of vertices of square? Because, perhaps you sorted....

Kitonum's code maintains the four vertices of each square as a set, and all the squares themselves are in a set. Sets in Maple are sorted into stored in an order determined by Maple (mostly lexicographic order). To maintain the order of the vertices within the squares, it's necessary to store the squares as lists instead of sets. This causes duplicate squares, so they need to be divided into equivalence classes by their equality as sets, and have a representative of each equivalence class selected. A command that can form equivalence classes is ListTools:-Classify.

Here's a procedure that does this for any sphere with integer center and radius. This is based on Kitonum's code but is generalised to work for any sphere with integer center coordinates and radius. It takes significantly more time because of the equivalence class finding. The coding is more complex due to the many subtle list-set-table conversions required.

Download AllDistinctIntegerSquares.mw

I can get Maple to put it into the following relatively simple Sum form, which is not as simple as the one shown in the paper. Note that the only difference in the input is that I used Sum with an uppercase S. That's the inert form of sum, but diff still knows what to do with it.

The following commands have inert forms that the other commands know how to handle. In all cases, the inert form is the same word capitalized: sum, product, diff, int, eval, limit.

Download diff_double_sum.mw

Note that the formulae that you entered aren't quite as general as those in the paper. In the paper, the sums have coefficients that depend on n and m.

Is this what you're looking for?

linspace:= proc(r::range(complexcons), n::posint)
local a:= op(1,r), h:= (op(2,r)-a)/n, k;
     [seq(a+k*h, k= 0..n)]
end proc:

linspace(0..1., 4);

     [0., .250000000000000, .500000000000000, .750000000000000, 1.00000000000000]

The name linspace comes from a very similar function in Matlab.

Why not simply have a variable, Nlists, that you add 1 to every time you find a list?

Nlists:= Nlists + 1;

Since your task seems so large (you mentioned 11 trillion lists in another Questions), you should describe it in more detail so that we can discuss its feasibility. Perhaps there is already a combinatorial formula to count it. Perhaps your lists could be generated by the Iterator or combstructs package. Note that you can't fit 11 trillion lists on even a large disk. You'll need to use an iterator of some sort. That is, the lists need to be created, examined, counted, and garbage collected in a loop. Maple will handle the garbage collection on its own.

The bottom of your Question is about the data structure that you should use. I think that a DataFrame would be good for this. A DataFrame is like a Matrix except that the rows and columns are indexed by labels rather than by numbers. I think that your columns should be labeled by weather phenomena and the rows should be labeled by date and hour. See ?DataFrame.

There are no functional differences. If there were, we'd occasionally have to ask people when they asked Questions here what edition they had so that we could answer. That has never happened as far as I'm aware. In Maple V (about 15 years ago), there was a small difference in the student edition: Precision was limited to 100 digits. I'm not aware of any differences after that.

You need one more boundary condition. (You need one extra boundary condition per parameter.) So I took every possible pair of boundary conditions from the set extra_bcs. Of the 36 possible pairs, 25 finish without error. I also cleaned out the totally unnecessary junk like newsys2, approxsolx, abserr, and initmesh. I think that those were things leftover from another problem that you solved with Preben. They don't apply to this problem.

For some reason, not all of the output is shown below. But you'll see it when you download the worksheet.

Download warning-2.mw

For a 2-D plot, use option background. For a 3-D plot, use option image. For example,

plot(x^2, x= -2..2, background= "MyPic.jpg");

See ?plot,options and ?plot3d,options.

Unless someone says differently, I'd say Edgardo S. Cheb-Terrab. He wrote most/all of that stuff and is a frequent contributor here on MaplePrimes.

You can use a control variable and while conditions to do the multi-level break that you want. Here's how:

A := [[1, 2], [1, 7], [5, 6], [1, 6], [1, 9], [6, 5], [9, 1], [2, 1], [7, 1], [6, 1], [5, 6]];
n := 9;
continue:= true;
for i to n while continue do
     for j to n while continue do
          for k to nops(A) while continue do
               if [i, j] = A[k] then
                    a := ListTools:-Search([i, j], A);
                    b := ListTools:-Search([j, i], A);
                    if a < b then
                         f := `mod`(b-a, 2);
                         if f = 1 then continue:= false end if
                    end if
               end if
          end do
     end do
end do;
if continue then print(A) end if;

Another way to do a multi-level break is to use return. See below.

Your program can certainly be made much more efficient, but I'll need to think about that for a little while.

[A little while passes.]

Okay, here's a significant simplification of your program:

A := [[1, 2], [1, 7], [5, 6], [1, 6], [1, 9], [6, 5], [9, 1], [2, 1], [7, 1], [6, 1], [5, 6]];
n := 9;
continue:= true;
for p in A while continue do
     if p::[posint$2] and max(p) <= n then
          a:= ListTools:-Search(p, A);
          b:= ListTools:-Search([p[2],p[1]], A);
          if a < b and (b-a)::odd then continue:= false end if
     end if
end do;
if continue then print(A) end if;

This can of course be made simpler if you know a priori that the condition in the first if statement is always true.

I'm skeptical about the necessity of the a < b check.

If you really have 11 trillion of these lists, we'll need to make this a lot faster. If by some extreme efficiency measures we could process one million lists per second, that's still about 4 months of computation. This can be reduced significantly by parallel and/or distributed processing. This problem looks like a good candidate for it.

[Half a night and half a day passes.]

I'm convinced that the a < b is unnecessary given that your original code was checking every member of A.

A return statement makes a bigger jump than a break statement: It jumps out of the whole procedure. To use it, we need to be in a procedure, which is a good idea anyway. So here's the code:

A := [[1, 2], [1, 7], [5, 6], [1, 6], [1, 9], [6, 5], [9, 1], [2, 1], [7, 1], [6, 1], [5, 6]]:
n := 9:

ListProcess:= proc(A::list)
local k,p,b;
     for k to nops(A) do
          p:= A[k];
          if p::[posint$2] and max(p) <= n then
               member([p[2],p[1]], A, 'b');
               if (b-k)::odd then return NULL end if
          end if
     end do;
     return A
end proc:

ListProcess(A);

The NULL after the first return, and the return itself on the penultimate line of the procedure are superfluous. I just included them to clarify things for a newbie reading the code.

I don't know your lists, so I don't know if the check in the if statement is superfluous. If so, then the p can be done away with also, and the procedure code becomes

ListProcess:= proc(A::list)
local k,b;
     for k to nops(A) do
          member([A[k][2],A[k][1]], A, 'b');
          if (b-k)::odd then return end if
     end do;
     A
end proc: