Could someone explain me of this bit of code below is correct:

  • Is it possible to define a function with a second bracket, see below, i.e. f[x_][y_]? And what does this implement?
  • What does the syntax [C_s] do?



So let me a bit more detailed:

This is the code I want to understand, and that has to implement the function $$ S_{1,2} = \frac{i}{h(x)}\mathbb{P}_{1,2}+\mathbb{I}_{1,2}\,,$$ where $\mathbb{P}_{1,2}$ is the permutation operator and $\mathbb{I}_{1,2}$ is the identity operator, acting on the state 1 and state 2, of a three particle state defined by:


The code is the following:


I do not understand how the last line can work; what is de `Cs' referring to?

  • $\begingroup$ Yes, it is possible, although you may want to use the format carefully. A possible duplicate: How can I overload a function with multiple bracket-slots. See also: (5686494 on StackOverflow), (9741), (544). $\endgroup$
    – MarcoB
    Feb 8, 2016 at 15:39
  • $\begingroup$ In this particular example, I think the s after the C_ is not valid. You could have C_List and then only arguments of type List would work there. But I don't know of a s type $\endgroup$
    – Jason B.
    Feb 8, 2016 at 15:41
  • 2
    $\begingroup$ @Jason It should be clarified that it's only invalid (or, more accurately, not useful) by default -- if the user has implemented, or intends to implement/use the head s, then it's perfectly valid to use C_s in a pattern. It means a single argument with head ('type') s. $\endgroup$
    – jjc385
    Feb 8, 2016 at 15:52
  • $\begingroup$ Is it possible you meant for C_s to actually read C_S? As written, it will match to s[...] but not S[...]. $\endgroup$
    – jjc385
    Feb 8, 2016 at 16:57
  • 2
    $\begingroup$ Don't use C - it's a reserved symbol. $\endgroup$
    – Jens
    Feb 8, 2016 at 18:14

1 Answer 1


First question: See How can I overload a function with multiple bracket-slots so f[a][b] and f[a] can coexist?, and the comments.

Second question: Without the s, C_ is a pattern which we can call C on the right hand side. (It seems like you understand this.)

With the s included, C_s is likewise a pattern that we can call C, but it only matches expressions with head s. (Head might be thought of like 'type' in other languages.) You can test the head of any expressions with

Head/@{ f[x], f[x][y], {x}, x+y, x*y, x }

{f, f[x], List, Plus, Times, Symbol}

The quick answer is that C_s will only match an expression that looks like s[ ... ]. Thus, you get something like this:

f[x_][C_s] := foo[ x, C ]

f[x][ y ]


f[x][ s[y] ]

foo[ x, s[y] ]

Note that C on the right hand side includes both the symbol s and its arguments.

Be careful of

f[x][ s ]


This is because Head[s] evaluates to Symbol. This is true even if you have definitions for things like s[x_], as long as s itself hasn't been given definitions with = or :=.


(I initially misread the question, and thought 'Cs' referred to the individual C's and s's, not the symbol Cs.)

Addressing the last line of the question, Cs is not defined anywhere in the code you've given. As written, the right hand side of the last line will replace literal occurrences of Cs with Block[...].

However, since the left hand side of the := contains A and not A_, the only possible value of A on the right hand side is the literal symbol A. (It is very likely this is a mistake.)


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.