I told you before that you need to change Gamma to GAMMA. You said that you did, but I still see Gamma.

Try entering it as A[b,c]. This makes it an indexed variable. The output will be subscripted like you want. An indexed variable is not quite the same thing as the atomic variable that you were trying to create, but it'll work if you do not assign values to A, b, or c.

The characters that you see are not apostrophes. Note that they lean to the left. They're called "back quotes" or "accents graves" or, in Maple, "name quotes". They let you make any string of characters, no matter how weird, into a variable.

However, you shouldn't be seeing those back quotes in your output. If I enter 

`A__b,c`;

then my output appears without quotes as A_b,c

You can set defaut options for all 3-D plots with the command

plots:-setoptions3d('axesfont'= ["TimesNewRoman", 24], 'labelfont'= ["TimesNewRoman", 24]);

These options can be overridden, if desired, on any individual plot command simply by including a different version of the option in the individual command.

You can use plots:-setoptions to do the same thing for 2-D plots.

These can be put into an initialization file which is automatically run whenever a new worksheet is loaded or a restart is executed.

One way:

(Int = rcurry(int, 'AllSolutions'))(1/x, x= a..2);

I have verified conclusively that the bondage number of your example graph is 7 by showing that a certain 7-subset of edges is a bondage set (that part is extremely easy), and using multithreaded processing with the Iterator package to verify exhaustively that none of the 439,381,916 edge subsets with less than 7 edges is a bondage set. With careful multithreading (using 8 threads on my computer), I reduced the average real time to verify whether an edge subset is a bondage set to about 17.3 microseconds (equivalent to about 3.4 million subsets checked per minute).

I'll put the main code and the worksheet separately because the main code is in a Code Edit Region within the worksheet.

MinBondageSet:= module()
option `Author: Carl Love <carl.j.love@gmail.com> 2023-Jun-22`;
local
    #Declaring module locals that are modified in multithreaded code as "thread_local"
    #causes the creation of a separate copy for each thread.
    A::thread_local #modified adjacency array after edge removal
;
export
    #All of this module's exports are essentially "static", but they're not declared
    #"static" because this module is not an "object"
    VL, n, V, A0, #VL = vertex labels, n= # of vertices, V={$n}, A0 = list of vertex neighborhoods
    edges, NE,
    DS, #minimum dominating sets of input graph, as a listlist

    #returns the set of minimum dominating sets of G as a listlist:
    MinDominatingSets:= module()
    local 
        N, s,
        Scans:= subs~(
            _s=~ [0, s, s[-1]],
            proc()
            local N0:= eval(N), Ns, v;
                N:= evaln(N); #garbage collection 
                (
                    for s, Ns in eval(N0) do
                    (
                        for v from _s+1 to n do
                            if (N[s,v]:= Ns union A0[v]) = V then [s,v] fi
                        od
                    )
                    od
                )
            end proc
        ),
        ModuleApply:= proc($)
        local Scan, R;
            N:= table([()= {}]);
            for Scan in Scans do if (R:= Scan()) <> () then return [R] fi od;
            [do R:= Scan() until R <> ()]
        end proc
    ;
    end module,

    GetEdges:= ()-> local k; seq['reduce'= `union`](`{}`~(k, select(`>`, A0[k], k)), k= 1..n-1),

    GetGraphData:= proc(G::Graph) #Assign exports specific to this graph:
        VL:= op(3,G);
        n:= nops(VL);                    
        V:= {$n};                             
        A0:= [seq](op(4,G) union~ `{}`~(V));  
        edges:= GetEdges();
        NE:= nops(edges);
        DS:= MinDominatingSets()
    end proc,

    #This proc essentially makes a local copy of the modified graph,
    #but does so in an efficient way:
    RemoveEdges:= proc(E::{set,list}(set), $)
    option threadsafe;
    local A1:= rtable(A0), e;
         for e in E do A1[e[1]] minus= {e[2]}; A1[e[2]] minus= {e[1]} od;
            A:= seq(A1); #This is why A is thread_local
            return
       end proc,

       #returns true iff no dominating set of the original graph is still dominating after
       #edge removal:
       CheckDS:= proc() option threadsafe; local d; andseq(`union`(A[d]) <> V, d= DS) end proc,
       
    #much slower than CheckDS, but potenially useful for some "greedy" algorithms: selects 
    #all of the original dominating sets that are still dominating after edge removal:
    ReduceDS:= ()-> select(d-> `union`(A[d]) = V, DS),

    ModuleApply:= module()
        local 
         k,        #size of edge subsets being checked
            Min, Max,    #min and max values of k to use  
            C,        #combinations Iterator for k-subsets
          st,        #time at start of an iteration
            found?,     #Flag set in one thread to make the others stop: Has a bondage set been found?

            TimeReport:= proc() #per-iteration userinfo timing report and estimate:
            local T:= time['real']() - st;
                if k = Min or T = 0 then return fi;
            userinfo(
                1, 'MinBondageSet', 'NoName',
                sprintf(
                    "Time to check %d-subsets of edges: %9.1f s; "
                    "expected time to check %d-subsets: %9.1f s.",
                    k, T, k+1, T*(NE-k)/(k+1)
                ) 
            ) 
        end proc
      ;
    export
            CheckSplit:= proc(rnk, num) #main multithreaded procedure:
            option threadsafe;
           local (h,g):= ModuleIterator(Object(C, 'rank'= rnk)), J:= g(), B;
                to num while h() do
                    RemoveEdges((B:= edges[[seq](J+~1)]));
                    if CheckDS() and not found? then found?:= true; return B fi
               until found? #can be set true by any thread
            end proc,

            ModuleApply:= proc(
               G::Graph,    
            { #keyword options:
                #Return after fully processing the input graph but 
                #before examining any edge subset:
                    setup_only::truefalse:= false,

                    #Skip the setup phase because the setup of G is already stored
                    #in the module:
                    no_setup::truefalse:= false,
                    
                    #sizes of edge subsets to check for being bondage sets:
                set_sizes::range({posint, identical()}):= .. 
                },
                $
            )
        uses It= Iterator, TT= Threads:-Task;
        local ne, R;        
            if not no_setup then GetGraphData(G) fi;
            if NE = 0 then return {} fi;
            if setup_only then return fi;

            Min:= lhs(set_sizes); if Min=() then Min:= 1 fi;
            Max:= rhs(set_sizes); if Max=() then Max:= NE fi;
            ne:= binomial(NE, Min);
            found?:= false;
            for k from Min to Max do
                    st:= time['real']();
                    C:= It:-RevolvingDoorCombination(NE, k);
                    R:= TT:-Start('passed', 'Tasks'= [CheckSplit, It:-SplitRanks(ne)[]]);
                    if R <> () then return R fi;
                    ne*= (NE-k)/(k+1); #update binomial(NE, k) -> binomial(NE, k+1) 
                    TimeReport()
            od
            end proc
    ;
    end module,

    #utility that lets the user convert vertex-label indices (default output) back
    #to the original vertex labels,
    LabelVertices:= e-> evalindets(e, integer[1..n], j-> VL[j])
;
end module
:

Download BondageNumber.mw

Suggestions:

The circles for r = 1/3 and r = 2/3 serve no didactic purpose, and thus I think that they're detrimental to the pedagogy.

You need rays for theta = Pi/4, 3*Pi/4, etc.

The vertical lines should not extend beyond the circle. If they go outside the circle, it's easy to mistake them as stray marks. Their color should be more visible.

Your series has no free variables. The concept of radius of convergence doesn't make sense without a free variable such that the convergence of the series depends on that free variable being within a certain "radius" of some point. The concept of power series requires a free variable which is raised to "powers".  

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.