A := Matrix(7,7,[[1,-5,0,0,0,0,0],
[0,1,-5/4,0,0,0,0],[0,0,1,-5/4,0,0,0],
[0,0,0,1,-5/4,0,0],[0,0,0,0,1,-5/4,0],
[0,0,0,0,0,1,-5/4],[0,0,0,0,0,0,1]]):

B := Vector(7,[1,1/4,1/4,1/4,1/4,0,204]):

with(LinearAlgebra):

# Here's what happened at some of the steps.

B[7]:=B7: # generalization, instead of a particular B[7]

sol:=LinearSolve(A,B); # solve that system

eqs:=seq(sol[i],i=1..7); # not really necessary; same as sol[i], but shows them

# You want to know which values of B7 give integer
# values to all the members of that sequence.

# Each eq[i] must be equal to a (very possibly
# different) integer. Integer solutions to the
# equation x=eq[i] are sought. The isolve routine
# is for computing such things, and it allows one
# to specify a name in the event that the solutions
# are parametrized.

# Take the equation x=eq[3] for example.

#> isolve(x=eqs[3],Z||3);
# {x = 499 + 625 Z3, B7 = 204 + 256 Z3}

# The equation in the above result which specifies
# x = 499 + 625*Z3 is of no immediate interest. If
# you know B7 then you can find all the x's using
# the eq sequence, or using sol.

# And yes, the key is to extract the equation of the
# form B7=.... from the above result. Fortunately,
# Maple's `type` routine can check for such patterns
# easily. One of those two equations will be found
# to be of the right type, and one will not.

#> type( x = 499 + 625*Z3, identical(B7)=anything );
# false

#> type( B7 = 204 + 256*Z3, identical(B7)=anything );
# true

# Generate all those equations, including those with
# B7 given by parametrized equations, at once.

seq(isolve(x=eqs[i],Z||i), i=1..7);

# Extract from that only the equations of the form
# B7 = ...., and do it all at once. The `map`
# routine lets it all be done at once. The % token
# is maple's programmatic way to allow access to the
# previous result.

# I put {} around % so that there would be something
# for `map` to get a grip on. Otherwise, `map` would
# see all the sequence at once and wouldn't know
# which arguments were which.

# The above is a common trick in Maple. Suppose
# that you have a routine, `foo`, which can take
# either two or more arguments. How do you
# know whether the call foo(a,b,c) was meant to
# be foo( a, (b,c) ) a two-argument call with an
# sequence of two things b and c as the second
# argument *or* foo(a,b,c) with a three-argument
# call. How convenient if you can instead do it
# as foo(a,{b,c}), when it's clear what the second
# argument is. So, passing sequences is generally
# ambiguous. Better to somehow encapsulate any
# sequence that you want to get passed as a single
# argument.

# Encapsulating a sequence in a list with [] or
# in a set with {} is a pretty common Maple trick.

# In my actual case, `map` is going to
# return a set if I pass it {%} instead of the
# sequence which is what % actually was. I used `op`
# on the result because I want the contents of the
# result set and not that actual set.

map(y->op(select(x->type(x,identical(B7)=anything),y)),{%}):

# So now there are seven equations of the form
# B7 = ...., for you particular Matrix A and Vector B.
# There are other examples of A and B for which the
# seven equations B7=... would contain an x. In such
# a case, this crude approach would break down and
# not work without some extra efforts. As it is,
# the example is simple enough.

# All seven of these equations B7=.... must have
# integer solutions, for each solution to your
# problem. So I called isolve on them all at once
# because they must *all* hold at once for the B7
# to be a valid solution value.

isolve(%);

# The above call gives a solution in which all
# the variables are parameterized. Only the B7 or Z7
# part of the result is of interest. So extract it,
# once again using `map` and % to denote the previous
# result.

select(x->type(x,identical(Z7)=anything),%);

# So, that might explain some of my thinking at the
# time.

# As for your other questions, you could consider
# these results.

> S1 := {u = v, a = b, f = g, a = g}:
> select(x->type(x,identical(a)=anything),S1);
{a = b, a = g}

> op(select(x->type(x,identical(a)=anything),S1));
a = b, a = g

> S := {u=v,a=b,a=g,f=g}, {q=r,a=d,a=p,j=k}:
> map( y->op(select(x->type(x,identical(a)=anything),y)), {S});
{a = b, a = g, a = d, a = p}

# At an even lower level,

S1;

op(S1);

# I hope that helps some.

acer

Maple is (mostly) interpreted, rather than compiled. The Maple kernel interprets the source of the routines which are stored in its system archives (libraries). There are some very nice benefits for us all, partially brought about by this aspect of Maple.

One such benefit is the runtime debugger, see the help-page ?stopat for some introduction. Another such benefit is that the contents of Maple's own library functions can be viewed by the user.

For example,

showstat(discont); # show with line numbers

interface(verboseproc=3):
eval(discont); # lineprint the routine

One can even view routines local (but not exported) from a module, which are normally hidden. Eg,

restart:
showstat(Statistics:-Visualization:-BuildPlotStruct);
kernelopts(opaquemodules=false):
showstat(Statistics:-Visualization:-BuildPlotStruct);

Some compiled routines, built into the kernel, are not accessible. Eg,

showstat(print);
showstat(irem);

While there is some variation in quality due to the long span over which Maple has evolved, the quality is rather good and studying it can help one learn some math as well as the maple language.

acer