Mryntu

I have defined a command low that adds a subscript to an argument:

newcommandlow[1]#1_l_mathcalA

However, if the argument of low contains subscripts itsself (for example in the case of lowlowSigma) it is not easy to see that the subscripts introduced by the outer low belong to the whole argument and not just to the first subscript. Therefore I would like to automatically introduce parentheses if the argument of low contains a subscript (so lowlowSigma should look like low(lowSigma).

In order to achieve this I tried the following using the xifthen package:

newcommandlow[1]ifthenelseisin_#1(#1)_l_mathcalA#1_l_mathcalA

However to my surprise this command only sometimes inserts the parantheses.
In particular it does not do so in the example given above. Why does this happen and what can I do to fix this?

EDIT: It seems that the problem is that isin does not unroll the definitions of commands. @egreg has already provided an answer that allows me to check for nested calls of low but does not work for arguments that contain other commands with subscripts. Does anyone have a solution that works for arbitrary arguments?

You can use a conditional. If it is true, add parentheses, if it is false, set it to true and don't add parentheses.

documentclassarticle
usepackageamsmath

newififnestedlow
newcommandlow[1]%
 begingroup
 ifnestedlow
 (normallow#1)%
 else
 nestedlowtrue
 normallow#1%
 fi
 endgroup

newcommandnormallow[1]#1_l_mathcalA

begindocument

[
lowSigma qquad lowlowSigma qquad lowSigma
]

enddocument

Doing this in a group ensures the conditional will be false at the next call.

In some cases applying protected@edef and @onelevel@sanitize before checking for a "stringified" _ might work out:

documentclassarticle
usepackageamsmath
usepackagexifthen

newififnownestlownownestlowfalse

makeatletter
DeclareRobustCommandlow[1]%
 begingroup
 begingroup
 protected@edef@tempa#1%
 @onelevel@sanitize@tempa
 expandafterexpandafterexpandafterendgroup
 expandafterexpandafterexpandafterifthenelse
 expandafterexpandafterexpandafter%
 expandafterexpandafterexpandafterisin
 expandafterexpandafterexpandafter%
 expandafterexpandafterstring_%
 expandafter%
 expandafter%
 @tempa%
 ifnownestlow(nownestlowfalsenormallow(#1))elsenownestlowfalsenormallow(#1)fi%
 ifnownestlow(nownestlowtruenormallow#1)elsenownestlowtruenormallow#1fi%
 endgroup

makeatother
newcommandnormallow[1]#1_l_mathcalA

begindocument

[
lowSigma qquad 
lowlowSigma qquad
lowlowlowSigma qquad
]
[
lowSigma_b qquad 
lowlowSigma_b qquad
lowlowlowSigma_b qquad
]
[
lowSigma_b qquad
lowb_lowc_lowSigma_d qquad
(Sigma_b)_l_mathcalA
]

enddocument

expandafter causes that the next but one token —if expandable—gets expanded exactly once before the next token gets expanded if expandable. (La)TeX considers the work of expandafter done when expansion of the next but one token is done. Therefore you can use chains/dequences of expandafter to have (La)TeX "jump" over k tokens for first expanding the (k+1)-th token.

@onelevel@sanitizemacro changes the definition of macro so that macro spits out a sequence of character tokens of category code 12(other) that looks like the token-sequence that would have been "spit out" by macro before applying @onelevel@sanitize. It is almost like redefining macro to what you get by applying string to each token of macro's definition.

protected@edef defines a macro but before doing so, it expands all expandable tokens of the definition-text except those that either are defined via DeclareRobustCommand or are preceded by the token protect. You might say: protected@edef does "unroll" the definitions of the tokens contained in its definition-text before actually performing the assignment.

@tempa is a scratch-macro which gets defined by means of protected@edef to expand to the argument #1 with all definitions in #1 "unrolled".

The ifthenelseisin...-test does not find _ that are nested in curly-braces as curly braces usually have a special function. Therefore @onelevel@sanitize is applied for turning all tokens, and thus also the curly braces, into ordinary harmless character-tokens of category code 12(other) which do not disturb the ifthenelseisin... test.

An idea (not straight forward solution) is to place the argument inside a box and check its height with the height of a character you suppose is not too tall to need parenthesis but not too short to add parenthesis to your Sigma.

And guess what will be our default argument: Sigma... P

The code (containing some tests) is this:

documentclassarticle
defDefLowArg$Sigma$
letoldDefLowArgDefLowArg
newsaveboxmyAbox
newsaveboxmyBbox
newcommandlow[2][DefLowArg]saveboxmyAboxvbox#1saveboxmyBboxvboxensuremath#2
ifdimdimexprhtmyAbox+dpmyAbox<dimexprhtmyBbox+dpmyBboxrelax
left(#2right)_l_mathcalA
else #2_l_mathcalAfi

begindocument

[lowlowSigma]

[lowSigma]
[
lowsum_i=3^5 F(x)
]

[
lowfracF(x)x+5
]

[lowF_x]

[low[1/4]F(x)]

[lowx^2]

[
lowG_x
]

These commands may be should add without parentheses

[
lowg(z)
]
[
lowF(x)
]



[
low[/]g(z)
]
[
low[/]F(x)
]

letDefLowArgoldDefLowArg

xdefDefLowArg/

[
lowg(z)
]
[
lowF(x)
]
letDefLowArgoldDefLowArg


bfseries And back to default

[
lowF(X)
]

enddocument

That produces:

PS:Of course manual solutions should be added in special cases but anyway in your command I am sure you would have exceptions for many cases.