Hello

I have an issue of scalability with registering functions in Julia. I need to register a function of several variables in order to be able to define derivatives of that function, so that Symbolics can stop tracing when arriving at that function. My issue is that registering a function creates a lot of methods for the function whose purpose I don’t really understand. As an example, imagine I register the following function

```
using Symbolics
@register_symbolics f(x::Num, y::Num)
```

If I now run `methods(f)`

, it will return something like

```
f(arg1::SymbolicUtils.Symbolic{<:Num}, arg2::SymbolicUtils.Symbolic{<:Num})
f(arg1::Num, arg2::SymbolicUtils.Symbolic{<:Num})
f(arg1::SymbolicUtils.Symbolic{<:Num}, arg2::Num)
f(arg1::Num, arg2::Num)
```

So, `f`

has 2^2=4 methods, because it needs to cover all the possible combinations of arguments of type `Num`

and of type `SymbolicUtils.Symbolic{<:Num}`

. I don’t really understand what those methods are for, or what `SymbolicUtils.Symbolic{<:Num}`

means. My biggest issue however is that I need to work with a function that receives at least 13 arguments, and I want to define 13 partial derivatives, and this becomes impossible because when registering the function, SymbolicUtils tries (and obviously fails) at defining 2^13 = 8192 methods.

My question then is, is there a way of registering functions with several numbers of arguments?, or does it just become exponentially more expensive?. I’ve tried with vectors (which would be ideal for me), but differentiation with respect to expressions involving arrays is apparently not yet supported. My only chance seems to be to just registering a function with several arguments, but as I’ve shown that is impossible in my case.