In your first expression, TPP, you have square brackets used algebraically; in other words, they're used as a substitute for parentheses. While that is indeed standard in mathematical typesetting, and I agree that it improves readibility, it's not alllowed in Maple (nor in any other computer language that I'm aware of). The reason is that with the severe limitation of the number of special characters available on a standard keyboard, they need to all have their own meanings.

If I replace those square brackets with paremtheses, the error goes away.

In relatively recent versions of Maple, and only using 1-D input, a for-do loop (or, indeed, any do loop) can be used as an embedded expression whose output is an expression sequence:

A:= select(isprime, {$3..101});
    A := {3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 
      59, 61, 67, 71, 73, 79, 83, 89, 97, 101}

B:= {for a in A do if a mod 3 = 1 then a fi od};
    B := {7, 13, 19, 31, 37, 43, 61, 67, 73, 79, 97}

This is not just a syntactic nicety; it's often the most efficient way to solve set-building problems. However, in this case, acer's select works efficiently also, and it's what I would use.

The difference between what you perceive as the correct and incorrect results is only the constant 3/4. Being different by a constant is not incorrect for an indefinite integral.

Here's a solution that allows a decision to be made based on the number of arguments and avoids any awkwardness that may come from having arguments that don't match named parameters due to there not being any named parameters. An overload is a list of (usually anonymous) procedures all assigned to a single procedure name such that for any call to the procedure, Maple will choose the first member of the list whose declared parameters match the arguments in the call.

The purpose of the $ (called the end-of-parameters marker) in the following example is to force those procedures to balk at (rather than the default, to ignore) extra arguments. To advance to the next procedure in the list, it's necessary that the arguments not match the declared parameters; I think that no other error will cause it to advance.

There seemed to be no good reason to limit this to real constants (type realcons), so I used type algebraic. But it would work just as well if you changed those to realcons..

P:= overload([
    proc(a::algebraic, b::algebraic, $) option overload; 
        a/b 
    end proc,

    proc(a::algebraic, b::algebraic, c::algebraic, $) option overload;
        a + b*c
    end proc,
    
    #Fall-through case: You can choose to return an error, to return unevaluated (as shown here), 
    #or to leave off this case entirely:
    ()-> 'procname'(args)
]):

P(3,5);
                               3/5
P(7,1,1,1);
                         P(7, 1, 1, 1)
P(3,5,7);
                               38

It's just an undocumented feature. There are many commands in Maple that work on a wider range of types of input than they are documented to work on. If they documented it, they'd never be able to change it in the future. On the other hand, it's often convenient to treat a listlist as a Matrix.

Just about any procedure can be made into an operator-form procedure by giving it a name beginning with & (see ?&). This is most natural with procedures of 2 arguments, but it's not limited to them. For example,

`&<--`:= (a, b::{list,set}(`=`))-> eval['recurse'](a,b):
(x+3) &<-- [x= 4];
                               7

&-operators have a very high precedence among infix operators (see ?operators,precedence), so you need to be wary of correct usage of parentheses and other grouping symbols.

Regarding a comparison of eval['recurse'] and MmaTranslator:-Mma:-ReplaceRepeated: The code for both of these is short and easy to read. The actual procedure name for eval[recurse] is `simpl/eval` (it's actually an appliable module rather than a procedure, but that's an insignificant technicality here). So,

showstat(`simpl/eval`);
showstat(MmaTranslator:-Mma:-ReplaceRepeated); 

The concept is weirdly named. I'd call it the UNbinding number. (I think some mathematician had an over-sexualized imagination when naming it the bondage number.) Anyway, for your example 7-regular graph with 48 automorphisms, I can very easily find a set of 6 edges whose removal increases the domination number from 4. It's more difficult to prove that no set of 5 edges suffice (binomial(84,5) ~ 31 million). By brute-force all-subsets search, I've proved that no 4-subset of edges will work. Thus, the "bondage number" is 5 or 6.

There are only 300 (exactly) minimal dominating sets. If you go back to the thread on those, I've posted new code that returns the set of 300. For each candidate set of edges, it's much easier computationally to check whether any of these 300 is still a dominating set after the edges are removed than it is to recompute the domination number from scratch. I'll post some code here along those lines.

Regarding your comment on symmetry (primarily from your linked StackExchange thread): My intuition is that the symmetry will have a profound effect on the computational effort required by various algorithms to compute the bondage number. In my new Answer in the domination-number thread, I've shown how to partition the 300 minimal dominating sets into 12 equivalence classes under automorphism (two sets being considered equivalent if there's an automorphism mapping one to the other). This partitioning takes less than one second, including the time required to find the 48 automorphisms and convert them to vertex permutations. My intuition is that these equivalence classes could somehow be used to reduce the computation needed to get the bondage number, but I haven't been able to make any further developments on that idea. And it may be an average-case reduction rather than a worst-case reduction.

From your example, it looks like perhaps by "similar" you mean "identical".  If that is the case, then Maple already recognizes identical subexpressions and makes use of that in its internal storage. It's only the displayed form of expressions that don't show this. 

Here's a procedure that will show you the common subexpressions that Maple has recognized:

CommonSubExprs:= e->
    select(se-> numboccur(expr, se) > 1, indets(e, {`+`, `*`, `^`, 'function'}))
:

The idea can be easily extended to more types than I've used above. I was just guessing that  `+`, `*`, `^`, function would cover what you need.

Any of the expressions returned by the procedure can be substituted by a variable with the ordinary subs command.

You just need to use the given ordering as an index of the vertex list:

R:= IsChordal(s, eliminationordering):
if [R][1] then op(3,s)[R[2]] fi;

If by Gamma you mean the generalized factorial function, then you need to spell it GAMMA (all uppercase). The cause of the error is that it doesn't know what Gamma means,

I improved my algorithm from above (made it faster) and added extensive explanation of how it works. Considering the code you've posted recently, you desperately need to study this explanation.

Your example graph has a lot of symmetry, 48 automorphisms. In the worksheet below, I show some techniques for analyzing the symmetry, including dividing the 300 minimal dominating sets into 12 equivalence classes under the automorphisms. The equivalence relation is specifically that two minimal dominating sets are equivalent if there is an automorphism of g mapping one to the other. 
 

Download DominationSet.mw

It can be done simply with subs by substituting the reciprocal of the desired denominator for the reciprocal of the current denominator, like this:

subs(1/rhs(eq_Dx)= 1/Dx, eq_K1_m4);

Let's say that you want the indices from 1 to 2, 1 to 3, 1 to 4, and 1 to 5. Then do

S:= Array(1..2, 1..3, 1..4, 1..5);

I'm guessing that @mmcdara is joking with his "non-answer", but his Reply got me thinking, and I came up with another "non-answer" that may be useful for you (so, it's actually an Answer).

If you have a device (such as a phone) with a camera and the Android or iOS operating system, then download the free Maple Calculator app to it. The app can translate photos of typeset or handwritten mathematical formulae into Maple code. I'm not aware of that photo-translation capability being available in Maple itself.

Tap the camera 📷 icon, then frame and photograph your formula. After a few seconds, you'll probably get an error message like "Sorry, this took too long to compute", which doesn't matter because you're not interested in computing it anyway. Tap the "upload to Cloud" icon. When it's done, it'll tell you the filename in the MapleCloud. In this case, the filename is the exact Maple sum command that you need.

Of course, the intended purpose of this photo-to-cloud facility is to let you download that Cloud file to Maple proper. But, for your immediate purpose, the file title has everything you need, so you don't even need to open Maple.

The error is because the target label is not in a procedure or loop. Not being in a procedure or loop is also called being "at top level".

There is no good reason for you to ever use goto. In addition to being widely frowned upon in most languages, the Maple implementation is very inefficient. 

There used to be a help page for it. But using the command is so discouraged that the help page has been removed.