macro to replace \text{Subst} with \operatorname{Subst}?

Question

Some latex that is autogenerated by Mathematica has this in it \text{Subst} as part of much longer latex.

Is there a way to write a macro to replace \text{Subst} with \operatorname{Subst} that I can put in the preamble? I do not know how to use \renewcommand to do this. It will be exactly \text{Subst} and nothing else that I want changed. i.e. no other \text{stuff}.

The reason I want to change it, is that it looks little better as an operator. There are so many of these in many files, so using the editor is not practical.

I can change in in Mathematica itself using string replacements pattern, but I thought it will be better to use Latex macro if possible.

MWE

\documentclass[12pt]{article}
\usepackage{amsmath}
\begin{document}

%\renewcommand{\text{Subst}}{\operatorname{Subst}}%does not work
\begin{align*} 
y &= -2 \text{Subst}\left(\int \frac{1}{(3+x)^2} \, dx,x\right)
\end{align*}

%want the above to become as follows

\begin{align*} 
y &= -2 \operatorname{Subst}\left(\int \frac{1}{(3+x)^2} \, dx,x\right)
\end{align*}

\end{document}

I looked at few questions, but could not figure how to do it.

TL 2020

Answer 1

It would be much better if the code has the proper markup, not relying on fragile post-processing.

However, since \operatorname only accepts “safe” characters (no accents unless a Unicode engine is used) you can get away by redefining \text.

I also use expl3 so the string-switch functions are already available.

\documentclass{article}
\usepackage{amsmath}
\usepackage{xparse}
\usepackage{letltxmacro}

% save the meaning of \text
\LetLtxMacro{\AMStext}{\text}

% now redefine \text
\ExplSyntaxOn

\RenewDocumentCommand{\text}{m}
 {
  \str_case:nnF { #1 }
   {
    {Subst}{\operatorname{Subst}}
    {Foo}{\operatorname{\mathbf{Foo}}}
    % ...
   }
   {\AMStext{#1}}
 }
\ExplSyntaxOff

\begin{document}

\itshape

This is an operator $x\text{Subst}(y)$

This is also an operator $y\text{Foo}$

This is text $a\text{baz}$

\end{document}

Answer 2

If you cannot get Mathematica to output \operatorname{Subst} instead of \text{Subst} and if you're free to use LuaLaTeX, the following solution may be of interest to you. It performs pattern matches and replaces all instances of \text{Subst} in the input file with \operatorname{Subst} "on the fly". The substitution operation is assigned to LuaTeX's process_input_buffer callback and therefore operates before TeX starts its usual processing operations (such as macro expansion). Observe that the \text macro is not redefined or modifed in any way.

I would further like to suggest that you load the mleftright package and use \mleft and \mright instead of \left and \right. This will improve (viz., reduce) the amount of whitespace between "Subst" and the large opening parenthesis.

\documentclass[12pt]{article}
\usepackage{amsmath,mleftright}
\usepackage{luacode} % for '\luaexec' macro
\luaexec{
function Subst ( s )
  return (s:gsub ( "\\text{Subst}" , "\\operatorname{Subst}" ))
end
luatexbase.add_to_callback("process_input_buffer", Subst , "Subst" ) 
}

\begin{document}
\begin{align*} 
y &= -2 \text{Subst}\mleft(\int \frac{1}{(3+x)^2} \, dx,x\mright) \\
  &= -2 \operatorname{Subst}\mleft(\int \frac{1}{(3+x)^2} \, dx,x\mright)
\end{align*}
\end{document}

Answer 3

I recommend to have Mathematica not write \text or \operatorname but write some "placeholder-control-sequence" which in LaTeX and in packages used by many usually is not defined. This way you are free to define that placeholder-control-sequence in the preamble/wherever according to your liking without the need of overriding/overloading/redefining control-sequences that are already defined/in use for whatever purposes where they should not be redefined.

Be that as it may:

You can patch the \text-command to check whether its argument consists exactly of the token-sequence S11, u11, b11, s11, t11.

As \text is defined "robust" you actually need to patch the command whose name is \text⟨space⟩.

In the example below the check is implemented by means of a macro which processes delimited arguments rather than by defining temporary macros and doing \ifx-comparison. This way you don't have LaTeX (re)define temporary macros whenever \text is carried out. This in turn might save some of LaTeX's memory when \text is used more often.

With the delimited argument the phrase passed in as argument by the user is nested between exclamation-marks (!)/between something that does not occur within the phrase Subst. Then checking is done on the phrase !Subst!. This way you can crank out the case of the phrase passed in as argument by the user containing ! (and thus differing from the phrase Subst) before doing the checking by means of a !Subst!-delimited argument. Cranking out this case is needed in order to ensure that the phrase passed in as argument by the user does not consist of a set of tokens differing from the delimiter !Subst! but nevertheless containing and therefore matching that delimiter.

\documentclass[12pt]{article}
\usepackage{amsmath}
\makeatletter
%%-----------------------------------------------------------------------------
%% Check whether argument is empty:
%%.............................................................................
%% \UD@CheckWhetherNull{<Argument which is to be checked>}%
%%                     {<Tokens to be delivered in case that argument
%%                       which is to be checked is empty>}%
%%                     {<Tokens to be delivered in case that argument
%%                       which is to be checked is not empty>}%
%%
%% This macro is explained in detail in:
%% <https://tex.stackexchange.com/a/522506/118714>
%% (The name given to it in that explanation is \CheckWhetherEmpty.)
%%
%% The gist of this macro comes from Robert R. Schneck's \ifempty-macro:
%% <https://groups.google.com/forum/#!original/comp.text.tex/kuOEIQIrElc/lUg37FmhA74J>
\newcommand\UD@CheckWhetherNull[1]{%
  \romannumeral0\expandafter\@secondoftwo\string{\expandafter
  \@secondoftwo\expandafter{\expandafter{\string#1}\expandafter
  \@secondoftwo\string}\expandafter\@firstoftwo\expandafter{\expandafter
  \@secondoftwo\string}\@firstoftwo\expandafter{} \@secondoftwo}%
  {\@firstoftwo\expandafter{} \@firstoftwo}%
}%
%%-----------------------------------------------------------------------------
\@ifdefinable\UD@GobbleToExclam{\long\def\UD@GobbleToExclam#1!{}}%
%%-----------------------------------------------------------------------------
\@ifdefinable\UD@SubstFork{%
  \long\def\UD@SubstFork#1!Subst!#2#3!!!!{#2}%
}%
\newcommand\UD@CheckWhetherSubst[3]{%
  \romannumeral0%
  \expandafter\UD@CheckWhetherNull\expandafter{\UD@GobbleToExclam#1!}{%
    \UD@SubstFork
    !#1!{ #2}% Case: #1 = Subst
    !Subst!{ #3}% Case: #1 is empty or something else without ! 
    !!!!%
  }{ #3}% Case: #1 is something else with ! 
}%
%%-----------------------------------------------------------------------------
%% Patch the command \text:
%% \text is robust, so actually the command \text<space> needs to be patched.
%%-----------------------------------------------------------------------------
\@ifdefinable\UD@Saved@Command@text{%
  \expandafter\let\expandafter\UD@Saved@Command@text\expandafter=\csname text \endcsname
}%
\long\@namedef{text }#1{%
  \UD@CheckWhetherSubst{#1}{\operatorname}{\UD@Saved@Command@text}{#1}%
}%
\makeatother

\begin{document}

\begin{align*} 
y &= -2 \text{Subst}\left(\int \frac{1}{(3+x)^2} \, dx,x\right)\\
  &= -2 \operatorname{Subst}\left(\int \frac{1}{(3+x)^2} \, dx,x\right)\\
  &\operatorname{Subst}&(\text{produced by {\tt\string\operatorname\{Subst\}}})\\
  &\text{Subst}&(\text{{\tt\string\operatorname}-variant produced by {\tt\string\text\{Subst\}}})\\
  &\text{Subst\empty}&(\text{{\tt\string\text}-variant produced by {\tt\string\text\{Subst\string\empty\}}})\\
  &\text{!Subst!}\\
  &\text{SubstSubst}\\
  &\text{Some bla bla}
\end{align*}


\end{document}

Answer 4

You can save the original meaning of \text to \origtext and then define \text as a macro which tests its argument if it is the "Subst":

\let\origtext=\text
\def\Subst{Subst}
\protected\def\text#1{\def\tmp{#1}\ifx\tmp\Subst 
   \expandafter \operatorname \else \expandafter \origtext \fi{#1}}