@Feenix 

Now you need to give us the call to findproot that gives the error. That is, what is the f, var, and k? (Well, I can figure out the var part, but you should give the complete call anyway when asking for debugging.) And we need the code to the procedures polyvariations and midpoint. In order to debug the code, we generally need to be able to run the code. Isn't that obvious?

And please don't post "Thank you" messages to threads that you weren't participating in!!! The only effect of that was to push your own Question off the bottom of the Active list and to anger and frustrate all the users who rely on the Active list to find relevant new posts.

You're wrong about zero_one being irrelevant to the error. It's key. The map in the last line of findproot is expecting every member of the list L returned from zero_one to have at least two operands. Apparently, some member does not.

I can squeeze out a little more time savings (maybe 20 - 25%)---perhaps at the expense of some pedagogic value---by using in-place Vector operations as much as possible, including using ArrayTools:-Alias. Now this can also serve as an example of how to use the time-saving but confusing Alias.

With a graph of 1024 vertices, my procedure is now more than 30 times faster than GraphTheory:-SequenceGraph. Here is the procedure, now with extensive comments.

Download degree_sequence.mw

@Markiyan Hirnyk 

It should be mentioned, especially for a novice DirectSearch user, that the solution x = 46 must be discarded. It is a shame that DirectSearch even reports these "solutions" with high residuals.

My procedure RealizeDegreeSequence is also many times faster than GraphTheory:-SequenceGraph. The problem with the latter can be seen in its line 14 where the edge set is built by successive unions, whereas my edge set is built by a table.

Download degree_sequence.mw

@Kitonum 

This will also work in older versions of Maple:

H:= table(zip(`=`, [t], L)):

Indeed, (x,y)-> x OP y can be replaced with simply `OP` for almost all binary operators OP and in almost all contexts. 

@MDD 

It's not an error. I explicitly forbade 0 as the target because it needs to be treated as a special case. However, if you insist, here's a version that does what you want with 0:

PolyLinearCombo:= proc(
     F::list(polynom),
     f::polynom,
     V::set(name):= indets([F,f], And(name, Not(constant))),
     $
)
local C:= CoeffsOfLinComb([f, F[]], V);
     if f=0 then  return (true, [0$nops(F)])  end if;
     if C[1]=0 then  (false, [])  else  (true, -C[2..] /~ C[1])  end if
end proc:

@MDD 

The third argument to PolyLinearCombo, if present, must be a set, not a list. So change that to

PolyLinearCombo([1], a, {x});

and 

PolyLinearCombo([a], 1, {x});

If you do that, you'll get correct results.

I made a small change so that if you accidentally enter a list, you'll get an error:

CoeffsOfLinComb:= proc(
     L::list(polynom),
     V::set(name):= indets(L, And(name, Not(constant))),
     $
)
local
     c, k, C:= {c[k] $ k= 1..nops(L)},
     S:= solve({coeffs(expand(`+`((C*~L)[])), V)}, C),
     F:= indets(rhs~(S), name) intersect C=~ 1
;
     eval([C[]], eval(S,F) union F)
end proc:

PolyLinearCombo:= proc(
     F::list(polynom),
     f::And(polynom, Not(identical(0))),
     V::set(name):= indets([F,f], And(name, Not(constant))),
     $
)
local C:= CoeffsOfLinComb([f, F[]], V);
     if C[1]=0 then  (false, [])  else  (true, -C[2..] /~ C[1])  end if
end proc:

@Markiyan Hirnyk 

Okay, you're right, it's easy. Yes, I read the (very brief) help before replying. It has nothing to say on the matter. The key thing is that GraphTheory:-SequenceGraph maintains the order in its generic sequence labelling---a fact that isn't mentioned on its very brief help page---but which I can see from reading the procedure's code.

Anyway, my procedure has significant pedagogic value for teaching this fundamental graph algorithm (often the first algorithm taught in a graph theory course). It does three things simultaneously: It determines whether the sequence is graphical, it generates the required graph, and it maintains the vertex order.

@Markiyan Hirnyk 

Answer edited. Actually, I edited it while you were replying.

By the way, you mean ?fracdiff rather than ?fdiff.

@Markiyan Hirnyk Sure, here's an example.

Now your job is to relabel the vertices using the original correspondence. That is, n must have degree 6, m must have degree 10, c must have degree 10, x must have degree 4, etc. You may do it programmatically or "by hand". Of course, I'll allow you to regenerate the random selections, in which case the actual correspondences will differ.

Download degree_sequence.mw

@Markiyan Hirnyk It would be difficult to do that while maintaining the original correspondence between the degrees and the labels, especially for a large graph. To do it automatically would require a procedure about as long as the one that I just gave.

@Mac Dude 

Fourteen years ago I wrote a program to convert plots to logarithmic form (along 1, 2, or 3 axes). This was long before the option axis[n]= [mode= log] existed. IIRC, it worked on any plot structure except the ISOSURFACE (the structure used by implicitplot3d). I have no idea what it'll do with dual-axis plots (I don't know whether you're using those). It has options that give you a lot more control over the tickmarks than even with the modern tickmarks options. It's in the Maple Applications Center under the name "Improved logarithmic plotting in 2 and 3 dimensions".

If you can't figure it out, send me your program that generates the non-logarithmic plot, and I'll see if I can adapt it.

@Mac Dude 

Simply showstat(`plots/display`);

There's no need to fear overwriting your Maple installation. Just save any changed procedures to your own directory.

@tomleslie 

At first I considered suggesting DynamicSystems:-BodePlot, but I can't see how to make it work with explicit data, which I think is what the OP has.

@Axel Vogt 

Good procedure, Axel. It may go a long way towards an algorithmic solution to the problem. I replaced your floor with ceil, and it made no difference in any example that I tried. But I wonder if there is any example where it makes the difference between an answer and no answer.

Kitonum: Your example h(n) shows a limitation in Maple's product, not really in limit. Of course, all infinite products and sums are limits of sequences, but the areas of Maple that are used are very different.