You can only solve an equation for the highest derivative of each function. What is the reason that you want to solve for the second derivative of f4 rather than the third derivative?

What's sys? How's Maple supposed to know the ODEs that you've written on the paper just from sys? And I don't see anything about y(t) on your paper.

@Markiyan Hirnyk Yes, I like your way better. To handle more-general cases, change the key to (c-> evalf(rhs(c[-1]))).

@patient It can be done like this

linspace:= (a,b,n)-> a +~ (b-a)/(n-1)*[$0..n-1]:
U1:= eval(U(x), res):
U2:= proc(alpha)
local x;
     U1(parameters= [alpha]);
     plots:-spacecurve([x, alpha, U1(x)], x= -1..-.02, color= black, thickness= 0)
end proc:
plots:-display(
     [seq(U2(alpha), alpha= linspace(0.1, 10, 23))],
     axes= frame, labels= [x, alpha, ``], orientation= [-86, 68]
);

@patient Here's how to do the 3-D plot that you want:

U1:= eval(U(x), res):
U2:= proc(x,alpha)
     U1(parameters= [alpha]);
     U1(x)
end proc:
plot3d(U2, -1..-0.02, 0.1..10, labels= [x, alpha, U], axes= boxed);

@Earl Better yet, any polygon can be partitioned into triangles whose vertices are vertices of the polygon.

@Carl Love I made an incorrect generalization from the n=2 to n=3 case. At first I thought that no group of three should occur more than once. Actually, it is much more strict: No pair can appear as part of one of the groups of three more than once. This seems to be a much more difficult problem, and the number of solutions is far less than 51 or 55. Brian's generalization of Kitonum's solution only applies to the more-liberal case: that no group of three occurs more than once.

@ben2015 It's easy. Use a Vector, not a list. Use add and mul rather than sum and product.

A:= <a||(1..10)>:
F:= unapply(add(A(k)*(1-A(k))^2*mul((1-2*A(l))^3, l= 1..k-1), k= 1..10), a||(1..10));

@Earl I'm not sure if this helps, but any polygon can be partitioned into triangles.

@brian bovril 

My argument is that 55 is an upper bound, not an upper and lower bound, for the g=12, n=3 case (binomial(12,3) / (12/3) = 55). You got 51 solutions, so 51 is a lower bound. Do you have reason to believe that there are more than 51 solutions?

@max125 By "parsed", vv means that in the 2-D input, Maple attempts to interpret your expression as it's being typed. With Maple Input (also called 1-D input), no interpretation is attempted until you press Enter, and only the characters that you actually typed and which appear on your screen are interpretted. The word "parse" is nearly synonymous with "interpret".

@wgarn 

In regular Maple, the command

ans := map(proc (x) options operator, arrow; expand(convert(convert(x, rational), expln)) end proc, {ans});

can be shortened to

ans:= (expand@convert)~({ans}, compose, rational, expln);

I don't know if this also works in Maple TA.

@vv 

It's a very interesting attempt. It has some flaws that can perhaps be worked out without seriously increasing the timing. The most interesting part is that it shows that subs(A=~B, C) is implemented in a smart way when A, B, and C are very long lists. The easy/naive way would be O(nops(A)*nops(C)). From using your procedure, I suspect that it's either O(nops(A)*ln(nops(C))) or O(ln(nops(A))*nops(C)). Either the first or the second argument is first sorted so that subsequent lookups take logarithmic time.

The flaws: The first flaw is the same as that with L1toL2_C: If the lists have repeated elements then the return value isn't a permutation of the indices even when L1 is indeed a permutation of L2. The second flaw applies only to your added attempt that tries to use Arrays. If some of the elements of L1 are themselves lists, then the returned result may be utter nonsense. For example

L1:= [[a,b],a]:
L2:= [a,[a,b]]:
Perm1to2_E_bis(L2,L1);

Regarding the timing: Nothing can be concluded from a single trial which shows results so close. The results aren't reproducible. You need repeated trials, and you need to try them in both orders, or (preferably) with a intervening restart. I did do repeated tests of L1toL2_C versus Perm1to2_D with nops(L1) as high as 2^22 (four million) and I reached no conclusion.

@Markiyan Hirnyk I withdraw the statement "remove(has, fnormal(...), 0.*I) works...." I must replace it with "It's never a good idea to use remove(has, fnormal(...), 0.*I); use simplify(fnormal(...), zero) instead." My original statement was simply intended to give your code the benefit of the doubt since you'd already used the remove construct, apparently sucessfully. Upon closer inspection, I found that your remove commands did nothing, because your expressions didn't contain 0.*I after you'd applied fnormal. On the other hand, since has(1. + 0.*I, 0.*I) returns false, the remove wouldn't have worked even if your expression had contained 0.*I.

@Kitonum Your technique shows directly and manifestly that seven is a lower bound for the answer. On the other hand, the fact that your answer is itself a partition of the set of all 28 pairs of golfers shows that seven is also an upper bound. In other words, binomial(g,n) / (g/n) is an upper bound for the answer, where g is the number of golfers and n is the size of their grouping (n=2 in this case).