# What (..) in variables and parameters means in ModelingToolkit

Transcribing part of a Slack conversation here (slackhole, Slack threads suck, etc):

[airpmb:]
Could you help me understand what the `(..)` syntax for variables and parameters declaration means? Docs say

Note that `@parameters` and `@variables` implicitly add `()` to values that are not given a call. The former specifies the values as known, while the latter specifies it as unknown. `(..)` signifies that the value should be left uncalled.

What does ‘uncalled’ mean? The example isn’t helping illuminate this for me:

``````@parameters t α σ(..) β[1:2]
@variables w(..) x(t) y() z(t, α, x)expr = β₁* x + y^α + σ(3) * (z - t) - β₂ * w(t - 1)
``````

[chrisrackauckas:]
`x(t)` is a “known function”, or, `x` means `x(t)`
it matches the shorthand people know and use in math
`σ(..)` is an “open function”
`σ` itself is a function and `σ` only makes sense as something applied to some variables
so if you use `σ` , you then have to state like `σ(t)`
you’d do the latter if you tend to not always use the same call
like `expr = σ(t) + σ(t+3)`
but it would get annoying to have to put `(t)` on every term of a differential equation, so `@variables x(t)` is a short hand

[airpmb:]
Ok… So in the example @parameters σ(…) reads as " σ is a function, of some unspecified number and type of arguments, that I will supply by the time I construct the ODEProblem" (for the moment I’m just concerned with ODEs). In the equations themselves it will always show up looking like a function call, with arguments that can be other parameters, or variables, or constants, or other functions in turn of all these…? Is it just then an alternative to function currying, allowing the definition of this function-call parameter to be deferred until the last minute? Anyway as such is this the right way to introduce forcing terms?

Assuming that’s correct then I’m still not 100% sure how the @variables version (w(…) in the example) should be interpreted. Sorry to be pedantic but I’d really like to know what I’m doing in these simple cases. So e.g. right now in English I read the expr in the example as:
Sum up these things:

1. multiply [a constant valued parameter] β₁ by x(t) [an apriori unknown time-dependent function, i.e. state]
2. raise y(t) to the α-th power [α being another constant valued parameter]
3. the result of σ(3), which is a call to a function supplied by the user with a single constant literal argument (3), multiplied it by z(t, α, x) - t; here z is an unknown state which is a function of t (which is presumably the independent variable, time), the constant parameter α, and the time-dependent state x(t)
4. -β₂ [second component of a length 2 vector of constant valued parameters] multiplied by w(t - 1) [where w is an unknown function dependent on time delayed by 1, so now a system using this equation will be a delayed differential equation so DDEProblem rather than ODEProblem will need to be used (but what about DDESystem vs ODESystem? Will that work in ModelingToolkit, it’s not mentioned in the docs of MTK AFAICT)]

whew, sorry for the wordiness but I hope it might help others too (I should probably ask this on Discourse actually…)

[at this point Chris pointed me to the diffeq Gitter and I was like “oh man I should have just used Discourse…”]