@Joe Riel My choice for a name for a built-in identity function is `1`.

@Joe Riel Perhaps D[1$0] would be more clear. Personally, I'll use D[].

@Christian Wolinski Your effort to make it into a worksheet is appreciated.

@abbastalebi Word format is not very helpful. Plaintext or worksheet is best. Anyway, I think that I got all the necesssary code from Christian's worksheet transcription of your Question. 

So, what does parameter beta represent? Is it meant to be input to or output from the system?

Currently, the total differential order of the system is 3, and there's 1 parameter, beta. That's 4, yet you have 6 initial and boundary conditions. Those two things (the 4 and the 6) need to be equal. You could add two more output parameters.

What is your version of Maple?

@Christian Wolinski The ubiquitous line 

print(`output redirected...`); #input placeholder

is garbage automatically added by some method of copy-and-pasting from 2D Input to plaintext. It's just clutter, and there's no reason to retain it in the worksheet.

Your worksheet above is not an Answer to this Question. It's a small help, but it's not an Answer or even an attempted Answer.

@Joe Riel In this context, I'd like to use D[ ], not 1, as the left-operand identity. Anyway, vote up. I was going to post a solution using LinearAlgebra:-Generic, but I think that yours is adequate.

It's always bothered me to need to waste the time needed to evaluate Maple-level procedures x-> x or ()-> args when it could be a builtin. Even D is Maple level.

You need to post your code. There are hundreds of unrelated things that could cause that error.

Please post your input code in a form such that I can easily copy-and-paste it into a worksheet. The output of the code is just clutter in this format. You can also simply attach a worksheet.

You have a three-point problem, with conditions at -10, 0, and 10. It'll need to be solved stepwise.

Would you please define "eigenvalue" in this context? I'm familiar with eigenvalues of square matrices and and of boundary value problems, but not of solitary algebraic equations.

Regarding your Digits:= 5: It causes no problem here, because this is just presentation rather than numeric computation. But, if you're habituated to it, it's going to cause problems for you eventually: It's too low. This number affects the precision of almost all internal floating-point computations, not just the results that are displayed. It's generally not enough significant digits to be safe.

Someone will probably mention at this point that there's a setting for the number of displayed digits, which doesn't affect the internal computations. However, the implementation of this feature is so cruddy that I won't mention it further.

What was the Linux command line that you used to compile it? I'm expecting something like

gcc -shared gauss1.c -ogauss.so

If you want practice writing Gaussian elimination code, that's all well and good. But if your goal is just to solve systems, then I doubt that you'd be able to beat the external Gaussian elimination code that already comes with Maple. 

@Joe Riel  Yes, I was aware that it was discouraged. Do you have any idea of the reason? Some things are discouraged for what seem to me to be reasonable reasons, and others for reasons that seem to me to be paternalistic "hand holding". If it's the latter, then I have no interest in following the recommendation.

@nm Your inclusion of function in the typespec of is_solution_trivial works, but you can be more specific by changing it to specfunc(PDESolStruc). The type name specfunc stands for specific function.

What you're calling a "list" is properly called a set in Maple. A list is a separate closely related type. Specifically, when you enclose something with curly braces { }, it becomes a set. This corresponds to usual mathematical notation and differs from Mathematica (whose notation I find to be highly idiosyncratic).

So, in your most-recent case, the PDE solutions are returned as a set of set of equations; the corresponding Maple type is set(set(`=`)). Putting these cases together, the procedure becomes

is_solution_trivial:= (pde, sol::{`=`, specfunc(PDESolStruc), set(`=`), set(set(`=`))})-> 
   evalb(eval(`if`(sol::set, sol, {sol}), depvars(pde)=~ 0) = {0=0}) 
:

Instead of a convert, the command op can be used to extract the underlying sequence from a set or list S:

op(S)

While op can be used on almost anything, this form can only be used for a set or list:

S[]

You seem to be confused about the distinction between name quotes `` and unevaluation quotes ' '. The name quotes can turn anything into a name. If the thing that they enclose is already a name, such as your `function` and `sequence`, then they do nothing at all. If you want a piece of code to use a name strictly as a name, regardless of whether that name has been assigned a value, then use unevaluation quotes: 'function'. That's usually not needed in procedure headers, however.

@mmcdara The same thing can also be achieved without seq:

x__||(1..4)

The above can be used on the left side of the assignment operator :=.

It can also be done with a sequence of symbols rather than a range of integers as the right operand of ||:

x__||(a,e,i,o,u)

One should keep in mind that names constructed with || or cat or nprintf or convert(..., name) (essentially, those constructed by any method other than indexing, x[...]) can never be local.

@Al86 Okay, I've taken your function to be (x-2)^2*(3-x). Then one possible command is

ImageTools:-Embed(IterativeMaps:-Bifurcation([x], [r*(x-2)^2*(3-x)], [0.2], 0, 0.3));

Note that the parameter r must be used. As far as I can tell, it must be literally r, which seems very unMapleish to me. There are a vast number of options mentioned on the help page to use color to bring out various features of the above plot.