AlgebraicAdd (2) 

Setting the option "AlgebraicAdd" to False allows one to search the specified functional form, up to multiplication (but not addition) by an algebraic number. This can vastly speed up the search, since special range properties are exploited for certain known functions:

In[21]:=

Out[21]=

Compare with the longer time required without this option:

In[22]:=

Out[22]=

AlgebraicFactor (2) 

Setting the option "AlgebraicFactor" to False allows one to search the specified functional form, up to addition (but not multiplication) of an algebraic number:

In[23]:=

Out[23]=

Compare with the longer time required without this option:

In[24]:=

Out[24]=

If both "AlgebraicAdd" and "AlgebraicFactor" options are set to False, the search can be faster but may miss linear combinations of the functional form:

In[25]:=

Out[25]=

In[26]:=

Out[26]=

FormulaComplexity (2) 

If not enough digits are specified, a careful balance between precision and complexity of the result should be reached through the option "FormulaComplexity". In fact, often the desired formula is likely to be the simplest. For example:

In[27]:=

Out[27]=

The result has the desired functional form and matches the digits:

In[28]:=

Out[28]=

However, by reducing the allowed complexity threshold, a simpler result is found:

In[29]:=

Out[29]=

In[30]:=

Out[30]=

By setting "FormulaComplexity" high, more intrinsically complex formulas can be found:

In[31]:=

Out[31]=

In[32]:=

Out[32]=

MaxSearchRounds (3) 

The maximum number of argument search rounds is set to 50 by default. If the value of the option "SearchRange" is set to Automatic, this also means that the maximum integer argument and maximum rational argument denominator are both 50:

In[33]:=

Out[33]=

By default, larger or smaller arguments respectively are not reachable:

In[34]:=

Out[34]=

Changing the value for the option "MaxSearchRounds" allows a solution to be found:

In[35]:=

Out[35]=

MonitorSearch (2) 

If the option "MonitorSearch" is set to True, the search round number is printed temporarily during evaluation:

In[36]:=

Out[36]=

If only one argument is specified, or a list of functions appears in the second argument, the function being evaluated is printed also:

In[37]:=

Out[37]=

OutputArguments (2) 

If the option "OutputArguments" is set to True, the output is an association with the function arguments:

In[38]:=

Out[38]=

In[39]:=

Out[39]=

This option is especially useful in the case the functional form evaluates in such a way so to lose information on its arguments. For example, find a matrix whose determinant is equal to a certain number:

In[40]:=

Out[40]=

In[41]:=

Out[41]=

RationalSolutions (4) 

By default, the option "RationalSolutions" is set to False. This means no simple rational solution is considered valid and more sophisticated solutions are searched for:

In[42]:=

Out[42]=

In[43]:=

Out[43]=

If the option "RationalSolutions" is set to True, a simpler exact solution can be found:

In[44]:=

Out[44]=

If the functional form searched for is the Identity, there is no need of this option:

In[45]:=

Out[45]=

Similarly when both the "AlgebraicFactor" and "AlgebraicAdd" options are set to false, rational solutions are automatically allowed:

In[46]:=

Out[46]=

The solution in this case is clearly:

In[47]:=

Out[47]=

RootApproximantMethod (4) 

By default, only a limited set of algebraic numbers can be obtained (through a pre-defined lookup table):

In[48]:=

Out[48]=

In[49]:=

Out[49]=

It is possible to recognize other algebraic numbers by using the built-in function RootApproximant, through the option "RootApproximantMethod" set to "BuiltIn":

In[50]:=

Out[50]=

In[51]:=

Out[51]=

The problem with the built-in method is that most of the time is spent trying to recognize random reals as higher roots and this makes the search much slower. In this example, the search using the built-in method is over 100 times slower (and requires one more digit):

In[52]:=

Out[52]=

In[53]:=

Out[53]=

In[54]:=

Out[54]=

As an intermediate solution, in case some algebraic number is missed and you still want a fast search, you could specify a custom lookup table:

In[55]:=

Out[55]=

In[56]:=

Out[56]=

In[57]:=

Out[57]=

Notice that the built-in method may miss or misinterpret some algebraic numbers:

In[58]:=

Out[58]=

In[59]:=

Out[59]=

In case complex algebraic numbers are searched for, you can specify a custom table for their phases:

In[60]:=

Out[60]=

Without this option, the complex phase is assumed to be within π ResourceFunction["FareyRange"][-1,1,1/100]:

In[61]:=

Out[61]=

SearchArguments (2) 

Through the option "SearchArguments" you can specify each particular search argument to be tried:

In[62]:=

Out[62]=

This can vastly speed up the search and serves as a debugging tool.

If more than one argument appears in the functional form, you can specify "SearchArguments" as a list of lists, or equivalently as an association:

In[63]:=

Out[63]=

In[64]:=

Out[64]=

SearchComplex (2) 

Search for complex values of the argument:

In[65]:=

Out[65]=

Notice that this option determines only the complex character of the arguments, while complex values by themselves do not necessarily require it:

In[66]:=

Out[66]=

SearchQueries (2) 

Return only the results from Wolfram Alpha by setting the option "SearchQueries" to 0:

In[67]:=

Out[67]=

If you specify a higher number, the number of results remains bounded by the second integer argument:

In[68]:=

Out[68]=

In[69]:=

Out[69]=

SearchRange (4) 

By default, for each search round the arguments span the Farey range determined by ResourceFunction["FareyRange"][-round,round,round]. For example:

In[70]:=

Out[70]=

In[71]:=

Out[71]=

Otherwise, it is possible to set the option "SearchRange" to "Plain", which creates the shorter rational range Range[-round,round,1/round]:

In[72]:=

Out[72]=

In[73]:=

Out[73]=

Notice the longer time required with the default "Farey" range:

In[74]:=

Out[74]=

In[75]:=

Out[75]=

Of course, for other arguments, the converse may be true.

Another possible value for this option is "Integer", whereby only integer arguments are searched within the range Range[-round,round]:

In[76]:=

Out[76]=

In[77]:=

Out[77]=

It is possible to specify, as an option value, a custom range function of the search round number:

In[78]:=

Out[78]=

SearchTimeLimit (1) 

Limit the time spent by the search algorithm:

In[79]:=

Out[79]=

In[80]:=

Out[80]=

Notice that, as in this example, the total time spent by the function may be higher than this option's value, because the time spent on querying Wolfram Alpha is not counted in it.

SignificantDigits (2) 

The option "SignificantDigits" is automatically set to the number of real digits (before 0) specified in the given number. If you want to ignore some numerical error, you can specify a lower value for it:

In[81]:=

Out[81]=

Without this option setting, the same call takes a large amount of time:

In[82]:=

Out[82]=

The numerical error is less than the required precision:

In[83]:=

Out[83]=

Specify more significant digits than those available (consider extra digits as valid zeros):

In[84]:=

Out[84]=

In[85]:=

Out[85]=

The search is unsuccessful because the higher digits do not match:

In[86]:=

Out[86]=

Keep in mind that, with significant numerical error, the search for the right formula becomes much harder.

WolframAlphaQueries (2) 

The number of Wolfram Alpha query results returned is, by default, 3:

In[87]:=

Out[87]=

You can either reduce or increase this number by setting the option "WolframAlphaQueries" to another number:

In[88]:=

Out[88]=

In[89]:=

Out[89]=

Notice that the queries may be unsuccessful, so this option just sets an upper limit:

In[90]:=

Out[90]=

In[91]:=

Out[91]=