output - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim

DEtools[rifsimp] Algorithm Output






The output of the rifsimp command is a table. A number of possible table formats (or entries) may or may not be present as they depend on specific options. The format changes from a table containing the simplified system to a nested table when casesplit is activated.


Single Case


This entry gives all equations that have been solved in terms of their leading indeterminate.


This entry gives all inequations (equations of the form expression <> 0) that hold for this case. These may be part of the input system, or decisions made by the program during the calculation (see rifsimp[cases] for information on pivots introduced by the algorithm).


This entry describes what assumptions were made to arrive at this simplified system (see rifsimp[cases].)


This table contains all equations that are nonlinear in their leading indeterminate. The equations in this list form a Groebner basis and can be viewed as purely algebraic because any differential consequences that result from these equations are already taken care of through spawning (see rifsimp[nonlinear]).  If the initial option has been specified, then these equations are isolated for the highest power of their leading derivatives, otherwise they are in the form expr=0.


This table entry contains all equations that are nonlinear in their leading indeterminate, but either are not in Groebner basis form or have differential consequences that are not accounted for (see spoly and spawn in rifsimp[nonlinear]).  Whenever equations appear in this entry, the system is in incomplete form and must be examined with care.


This table entry contains all equations that rifsimp did not attempt to solve (see unsolved in rifsimp[adv_options]).  Whenever equations appear in this entry, the system is in incomplete form and must be examined with care.


This table entry contains all equations that have not yet been examined (i.e. Unclassified). This entry is only present when looking at partial calculations using rifread, or when a computation is halted by mindim.


If this entry is present, then the output system is missing due to either a restriction or an error. The message in this entry indicates what the restriction or error is.


This entry is only present when the mindim option is used (see rifsimp[cases]), or for maxdimsystems.  For the case where a single constraint is in effect (such as through use of the option mindim=8), the right-hand side is a single number (the dimension for the case). For multiple constraints, it is a list of dimension counts, one for each constraint in the mindim specification.


Here are examples of status messages:

"system is inconsistent"

No solution exists for this system.

"object too large"

Expression swell has exceeded Maple's ability to calculate.

"time expired"

Input time limit has been exceeded (see ctl, stl and itl in rifsimp[options]).

"free count fell below mindim"

Free parameters have fallen below the minimum (see mindim in rifsimp[adv_options]).


Of the above, only the "object too large" message actually indicates an error.


To summarize, if the input system is fully linear in all indeterminates (including unknown constants), then only the Solved entry will be present. If the system is (and remains) linear in its leading indeterminates throughout the calculation, but has indeterminate expressions in the leading coefficients, then Solved, Pivots, and Case will be present. If equations that are nonlinear in their leading indeterminates result during a calculation, then Constraint will also be present. If the status entry is present, then not all information for the case will be given.


If mindim is used, then the dimension entry will be set to the dimension of the linear part of the system for the case when status is not set, and an upper bound for the dimension of the case if the count fell below the minimum dimension requirement.


Multiple Cases


For multiple cases (using the casesplit option), numbered entries appear in the output table, each of which is itself a table of the form described above.


For example, if a calculation resulted in 10 cases, the output table would have entries '1=...',..., '10=...', where each of these entries is itself a table that contains Solved, Pivots, Case, or other entries from the single case description.


In addition to the numbered tables is the entry casecount, which gives a count of the number of cases explored. Cases that rejected for reasons other than inconsistency will have the Case entry assigned, in addition to the status entry. Inconsistent cases, for multiple case solutions, are removed automatically.


So what is the difference between Pivots and Case?


The Pivots entry contains the inequations for the given case in simplified form with respect to the output system. The Case entry is a list with elements of the form [assumption,leading derivative] or [assumption,leading derivative,"false split"]. It describes the actual decision made for the case split in unsimplified form (i.e. as it was encountered in the algorithm). The assumption will be of the form expr0 or expr=0, where expr depends on the dependent variables, derivatives and/or constants of the problem. The leading derivative is the indeterminate the algorithm was isolating that required the assumption. If the third "false split" entry is present, then it was later discovered that one branch of the split is entirely inconsistent, so the actual splitting was a false splitting, as the displayed assumption is always true with respect to the rest of the system. For example, if the algorithm were to split on an equation of the form a&DifferentialD;&DifferentialD;yfy+fy=0, the Case entries that correspond to this case split are a0&comma;&DifferentialD;&DifferentialD;yfy, and a=0&comma;&DifferentialD;&DifferentialD;yfy. If it was found later in the algorithm that a=0 leads to a contradiction, then the Case entry would be given by [a<>0,diff(f(y),y),"false split"].


Note that when faclimit or factoring are used (of which factoring is turned on by default), it is possible to introduce a splitting that does not isolate a specific derivative. When this occurs, the case entry will be of the form assumption&comma;faclimit or assumption&comma;factor.


Occasionally both the Case and Pivots entries contain the same information, but it should be understood that they represent different things.




As discussed above, some options have the effect of preventing rifsimp from fully simplifying the system. Whenever DiffConstraint or UnSolve entries are present in the output, some parts of the algorithm have been disabled by options, and the resulting cases must be manually examined for consistency and completeness.



As a first example, we take the overdetermined system of two equations in one dependent variable f(x), and two constants a and b.




Call rifsimp for a single case only (the default).




We see that under the given assumptions for the form of a and b (from Pivots), the only solution is given as f(x)=0 (from Solved). Now, run the system in multiple case mode using casesplit.




We see that we have four cases:




All cases except 2 have f(x)=0.

Looking at case 2 in detail, we see that under the constraint a = b^2 (from Solved) and b <> 0 from Pivots, the solution to the system will be given by the remaining ODE in f(x) (in Solved). Note here that the constraint on the constants a and b, together with the assumption b <> 0, imply that a <> 0, so this constraint is not present in the Pivots entry due to simplification. It is still present in the Case entry because Case describes the decisions made in the algorithm, not their simplified result. Also, case 4 has no Pivots entry. This is because no assumptions of the form expression0 were used for this case.

One could look at the caseplot with the command:


As a final demonstration involving this system, suppose that we are only interested in nontrivial cases where f(x) is not identically zero. We can simply include this assumption in the input system, and rifsimp will take it into account.


ans1atableCase=a0&comma;&DifferentialD;2&DifferentialD;x2fx&comma;false split&comma;b0&comma;&DifferentialD;&DifferentialD;xfx&comma;false split&comma;Solved=&DifferentialD;&DifferentialD;xfx=fxb&comma;a=b2&comma;Pivots=fx0


We see that the answer is returned in a single case with two false split Case entries. This means the computation discovered that the a=0 and b=0 cases lead to contradictions, so the entries in the Case list are labelled as false splits, and the alternatives for the binary case splittings (cases with a=0 or b=0) are not present.

For the next example, we have a simple inconsistent system:





tablestatus=system is inconsistent


So there is no solution u(x) to the above system of equations.

The next example demonstrates the UnSolve list, while also warning about leaving indeterminates in unsolved form.




So we run rifsimp, but only solve for f(x), leaving g(x) in unsolved form. Unfortunately, the resulting system is inconsistent, but this is not recognized because equations containing only g(x) are left unsolved. As discussed earlier in the page, these equations come out in the UnSolve list.




When equations are present in the UnSolve list, they must be manually examined.

Here is a nonlinear example.




By default rifsimp spawns the nonlinear equation to obtain a leading linear equation, and performs any required simplifications. The end result gives the following output:


tableCase=fx=0&comma;&DifferentialD;&DifferentialD;xfx&comma;false split&comma;Solved=fx=0


We have only one consistent case. Attempting to perform this calculation with the spawn=false option gives the following:




So it is clear that by disabling spawning, the system is not in fully simplified form (as indicated by the presence of the DiffConstraint entry), and we do not obtain full information about the system.

See Also