Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/sympy/parsing/__init__.py

@@ -0,0 +1,4 @@
+"""Used for translating a string into a SymPy expression. """
+__all__ = ['parse_expr']
+
+from .sympy_parser import parse_expr

llmeval-env/lib/python3.10/site-packages/sympy/parsing/ast_parser.py

@@ -0,0 +1,79 @@
+"""
+This module implements the functionality to take any Python expression as a
+string and fix all numbers and other things before evaluating it,
+thus
+
+1/2
+
+returns
+
+Integer(1)/Integer(2)
+
+We use the ast module for this. It is well documented at docs.python.org.
+
+Some tips to understand how this works: use dump() to get a nice
+representation of any node. Then write a string of what you want to get,
+e.g. "Integer(1)", parse it, dump it and you'll see that you need to do
+"Call(Name('Integer', Load()), [node], [], None, None)". You do not need
+to bother with lineno and col_offset, just call fix_missing_locations()
+before returning the node.
+"""
+
+from sympy.core.basic import Basic
+from sympy.core.sympify import SympifyError
+
+from ast import parse, NodeTransformer, Call, Name, Load, \
+    fix_missing_locations, Str, Tuple
+
+class Transform(NodeTransformer):
+
+    def __init__(self, local_dict, global_dict):
+        NodeTransformer.__init__(self)
+        self.local_dict = local_dict
+        self.global_dict = global_dict
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, int):
+            return fix_missing_locations(Call(func=Name('Integer', Load()),
+                    args=[node], keywords=[]))
+        elif isinstance(node.value, float):
+            return fix_missing_locations(Call(func=Name('Float', Load()),
+                    args=[node], keywords=[]))
+        return node
+
+    def visit_Name(self, node):
+        if node.id in self.local_dict:
+            return node
+        elif node.id in self.global_dict:
+            name_obj = self.global_dict[node.id]
+
+            if isinstance(name_obj, (Basic, type)) or callable(name_obj):
+                return node
+        elif node.id in ['True', 'False']:
+            return node
+        return fix_missing_locations(Call(func=Name('Symbol', Load()),
+                args=[Str(node.id)], keywords=[]))
+
+    def visit_Lambda(self, node):
+        args = [self.visit(arg) for arg in node.args.args]
+        body = self.visit(node.body)
+        n = Call(func=Name('Lambda', Load()),
+            args=[Tuple(args, Load()), body], keywords=[])
+        return fix_missing_locations(n)
+
+def parse_expr(s, local_dict):
+    """
+    Converts the string "s" to a SymPy expression, in local_dict.
+
+    It converts all numbers to Integers before feeding it to Python and
+    automatically creates Symbols.
+    """
+    global_dict = {}
+    exec('from sympy import *', global_dict)
+    try:
+        a = parse(s.strip(), mode="eval")
+    except SyntaxError:
+        raise SympifyError("Cannot parse %s." % repr(s))
+    a = Transform(local_dict, global_dict).visit(a)
+    e = compile(a, "<string>", "eval")
+    return eval(e, global_dict, local_dict)

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/Autolev.g4

@@ -0,0 +1,118 @@
+grammar Autolev;
+
+options {
+        language = Python3;
+}
+
+prog:   stat+;
+
+stat:   varDecl
+    |   functionCall
+    |   codeCommands
+    |   massDecl
+    |   inertiaDecl
+    |   assignment
+    |   settings
+    ;
+
+assignment:   vec equals expr #vecAssign
+          |   ID '[' index ']' equals expr #indexAssign
+          |   ID diff? equals expr #regularAssign;
+
+equals:   ('='|'+='|'-='|':='|'*='|'/='|'^=');
+
+index:   expr (',' expr)* ;
+
+diff:   ('\'')+;
+
+functionCall:   ID '(' (expr (',' expr)*)? ')'
+            |   (Mass|Inertia) '(' (ID (',' ID)*)? ')';
+
+varDecl:   varType varDecl2 (',' varDecl2)*;
+
+varType:   Newtonian|Frames|Bodies|Particles|Points|Constants
+       |   Specifieds|Imaginary|Variables ('\'')*|MotionVariables ('\'')*;
+
+varDecl2:   ID ('{' INT ',' INT '}')? (('{' INT ':' INT (',' INT ':' INT)* '}'))? ('{' INT '}')? ('+'|'-')? ('\'')* ('=' expr)?;
+
+ranges:   ('{' INT ':' INT (',' INT ':' INT)* '}');
+
+massDecl:   Mass massDecl2 (',' massDecl2)*;
+
+massDecl2:   ID '=' expr;
+
+inertiaDecl:   Inertia ID ('(' ID ')')? (',' expr)+;
+
+matrix:   '[' expr ((','|';') expr)* ']';
+matrixInOutput:   (ID (ID '=' (FLOAT|INT)?))|FLOAT|INT;
+
+codeCommands:   units
+            |   inputs
+            |   outputs
+            |   codegen
+            |   commands;
+
+settings:   ID (EXP|ID|FLOAT|INT)?;
+
+units:     UnitSystem ID (',' ID)*;
+inputs:    Input inputs2 (',' inputs2)*;
+id_diff:   ID diff?;
+inputs2:   id_diff '=' expr expr?;
+outputs:   Output outputs2 (',' outputs2)*;
+outputs2:  expr expr?;
+codegen:   ID functionCall ('['matrixInOutput (',' matrixInOutput)*']')? ID'.'ID;
+
+commands:  Save ID'.'ID
+        |  Encode ID (',' ID)*;
+
+vec:  ID ('>')+
+   |  '0>'
+   |  '1>>';
+
+expr:   expr '^'<assoc=right> expr  # Exponent
+    |   expr ('*'|'/') expr         # MulDiv
+    |   expr ('+'|'-') expr         # AddSub
+    |   EXP                         # exp
+    |   '-' expr                    # negativeOne
+    |   FLOAT                       # float
+    |   INT                         # int
+    |   ID('\'')*                   # id
+    |   vec                         # VectorOrDyadic
+    |   ID '['expr (',' expr)* ']'  # Indexing
+    |   functionCall                # function
+    |   matrix                      # matrices
+    |   '(' expr ')'                # parens
+    |   expr '=' expr               # idEqualsExpr
+    |   expr ':' expr               # colon
+    |   ID? ranges ('\'')*          # rangess
+    ;
+
+// These are to take care of the case insensitivity of Autolev.
+Mass: ('M'|'m')('A'|'a')('S'|'s')('S'|'s');
+Inertia: ('I'|'i')('N'|'n')('E'|'e')('R'|'r')('T'|'t')('I'|'i')('A'|'a');
+Input: ('I'|'i')('N'|'n')('P'|'p')('U'|'u')('T'|'t')('S'|'s')?;
+Output: ('O'|'o')('U'|'u')('T'|'t')('P'|'p')('U'|'u')('T'|'t');
+Save: ('S'|'s')('A'|'a')('V'|'v')('E'|'e');
+UnitSystem: ('U'|'u')('N'|'n')('I'|'i')('T'|'t')('S'|'s')('Y'|'y')('S'|'s')('T'|'t')('E'|'e')('M'|'m');
+Encode: ('E'|'e')('N'|'n')('C'|'c')('O'|'o')('D'|'d')('E'|'e');
+Newtonian: ('N'|'n')('E'|'e')('W'|'w')('T'|'t')('O'|'o')('N'|'n')('I'|'i')('A'|'a')('N'|'n');
+Frames: ('F'|'f')('R'|'r')('A'|'a')('M'|'m')('E'|'e')('S'|'s')?;
+Bodies: ('B'|'b')('O'|'o')('D'|'d')('I'|'i')('E'|'e')('S'|'s')?;
+Particles: ('P'|'p')('A'|'a')('R'|'r')('T'|'t')('I'|'i')('C'|'c')('L'|'l')('E'|'e')('S'|'s')?;
+Points: ('P'|'p')('O'|'o')('I'|'i')('N'|'n')('T'|'t')('S'|'s')?;
+Constants: ('C'|'c')('O'|'o')('N'|'n')('S'|'s')('T'|'t')('A'|'a')('N'|'n')('T'|'t')('S'|'s')?;
+Specifieds: ('S'|'s')('P'|'p')('E'|'e')('C'|'c')('I'|'i')('F'|'f')('I'|'i')('E'|'e')('D'|'d')('S'|'s')?;
+Imaginary: ('I'|'i')('M'|'m')('A'|'a')('G'|'g')('I'|'i')('N'|'n')('A'|'a')('R'|'r')('Y'|'y');
+Variables: ('V'|'v')('A'|'a')('R'|'r')('I'|'i')('A'|'a')('B'|'b')('L'|'l')('E'|'e')('S'|'s')?;
+MotionVariables: ('M'|'m')('O'|'o')('T'|'t')('I'|'i')('O'|'o')('N'|'n')('V'|'v')('A'|'a')('R'|'r')('I'|'i')('A'|'a')('B'|'b')('L'|'l')('E'|'e')('S'|'s')?;
+
+fragment DIFF:   ('\'')*;
+fragment DIGIT:  [0-9];
+INT:   [0-9]+ ;         // match integers
+FLOAT:  DIGIT+ '.' DIGIT*
+     |  '.' DIGIT+;
+EXP:   FLOAT 'E' INT
+|      FLOAT 'E' '-' INT;
+LINE_COMMENT : '%' .*? '\r'? '\n' -> skip ;
+ID:   [a-zA-Z][a-zA-Z0-9_]*;
+WS:   [ \t\r\n&]+ -> skip ; // toss out whitespace

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/__init__.py

@@ -0,0 +1,97 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+@doctest_depends_on(modules=('antlr4',))
+def parse_autolev(autolev_code, include_numeric=False):
+    """Parses Autolev code (version 4.1) to SymPy code.
+
+    Parameters
+    =========
+    autolev_code : Can be an str or any object with a readlines() method (such as a file handle or StringIO).
+    include_numeric : boolean, optional
+        If True NumPy, PyDy, or other numeric code is included for numeric evaluation lines in the Autolev code.
+
+    Returns
+    =======
+    sympy_code : str
+        Equivalent SymPy and/or numpy/pydy code as the input code.
+
+
+    Example (Double Pendulum)
+    =========================
+    >>> my_al_text = ("MOTIONVARIABLES' Q{2}', U{2}'",
+    ... "CONSTANTS L,M,G",
+    ... "NEWTONIAN N",
+    ... "FRAMES A,B",
+    ... "SIMPROT(N, A, 3, Q1)",
+    ... "SIMPROT(N, B, 3, Q2)",
+    ... "W_A_N>=U1*N3>",
+    ... "W_B_N>=U2*N3>",
+    ... "POINT O",
+    ... "PARTICLES P,R",
+    ... "P_O_P> = L*A1>",
+    ... "P_P_R> = L*B1>",
+    ... "V_O_N> = 0>",
+    ... "V2PTS(N, A, O, P)",
+    ... "V2PTS(N, B, P, R)",
+    ... "MASS P=M, R=M",
+    ... "Q1' = U1",
+    ... "Q2' = U2",
+    ... "GRAVITY(G*N1>)",
+    ... "ZERO = FR() + FRSTAR()",
+    ... "KANE()",
+    ... "INPUT M=1,G=9.81,L=1",
+    ... "INPUT Q1=.1,Q2=.2,U1=0,U2=0",
+    ... "INPUT TFINAL=10, INTEGSTP=.01",
+    ... "CODE DYNAMICS() some_filename.c")
+    >>> my_al_text = '\\n'.join(my_al_text)
+    >>> from sympy.parsing.autolev import parse_autolev
+    >>> print(parse_autolev(my_al_text, include_numeric=True))
+    import sympy.physics.mechanics as _me
+    import sympy as _sm
+    import math as m
+    import numpy as _np
+    <BLANKLINE>
+    q1, q2, u1, u2 = _me.dynamicsymbols('q1 q2 u1 u2')
+    q1_d, q2_d, u1_d, u2_d = _me.dynamicsymbols('q1_ q2_ u1_ u2_', 1)
+    l, m, g = _sm.symbols('l m g', real=True)
+    frame_n = _me.ReferenceFrame('n')
+    frame_a = _me.ReferenceFrame('a')
+    frame_b = _me.ReferenceFrame('b')
+    frame_a.orient(frame_n, 'Axis', [q1, frame_n.z])
+    frame_b.orient(frame_n, 'Axis', [q2, frame_n.z])
+    frame_a.set_ang_vel(frame_n, u1*frame_n.z)
+    frame_b.set_ang_vel(frame_n, u2*frame_n.z)
+    point_o = _me.Point('o')
+    particle_p = _me.Particle('p', _me.Point('p_pt'), _sm.Symbol('m'))
+    particle_r = _me.Particle('r', _me.Point('r_pt'), _sm.Symbol('m'))
+    particle_p.point.set_pos(point_o, l*frame_a.x)
+    particle_r.point.set_pos(particle_p.point, l*frame_b.x)
+    point_o.set_vel(frame_n, 0)
+    particle_p.point.v2pt_theory(point_o,frame_n,frame_a)
+    particle_r.point.v2pt_theory(particle_p.point,frame_n,frame_b)
+    particle_p.mass = m
+    particle_r.mass = m
+    force_p = particle_p.mass*(g*frame_n.x)
+    force_r = particle_r.mass*(g*frame_n.x)
+    kd_eqs = [q1_d - u1, q2_d - u2]
+    forceList = [(particle_p.point,particle_p.mass*(g*frame_n.x)), (particle_r.point,particle_r.mass*(g*frame_n.x))]
+    kane = _me.KanesMethod(frame_n, q_ind=[q1,q2], u_ind=[u1, u2], kd_eqs = kd_eqs)
+    fr, frstar = kane.kanes_equations([particle_p, particle_r], forceList)
+    zero = fr+frstar
+    from pydy.system import System
+    sys = System(kane, constants = {l:1, m:1, g:9.81},
+    specifieds={},
+    initial_conditions={q1:.1, q2:.2, u1:0, u2:0},
+    times = _np.linspace(0.0, 10, 10/.01))
+    <BLANKLINE>
+    y=sys.integrate()
+    <BLANKLINE>
+    """
+
+    _autolev = import_module(
+        'sympy.parsing.autolev._parse_autolev_antlr',
+        import_kwargs={'fromlist': ['X']})
+
+    if _autolev is not None:
+        return _autolev.parse_autolev(autolev_code, include_numeric)

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/__init__.py

@@ -0,0 +1,5 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/autolevlexer.py

@@ -0,0 +1,253 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,49,393,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,
+        2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+        13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,
+        19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,
+        26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,
+        32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,
+        39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,
+        45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,1,0,1,0,1,1,
+        1,1,1,2,1,2,1,3,1,3,1,3,1,4,1,4,1,4,1,5,1,5,1,5,1,6,1,6,1,6,1,7,
+        1,7,1,7,1,8,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,1,12,1,12,1,13,1,
+        13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,
+        20,1,20,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,23,1,23,1,24,1,24,1,
+        25,1,25,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,
+        27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,184,8,28,1,29,1,29,1,
+        29,1,29,1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,31,1,31,1,31,1,
+        31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,
+        32,1,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,34,1,
+        34,1,34,1,34,1,34,1,34,3,34,232,8,34,1,35,1,35,1,35,1,35,1,35,1,
+        35,3,35,240,8,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,
+        36,251,8,36,1,37,1,37,1,37,1,37,1,37,1,37,3,37,259,8,37,1,38,1,38,
+        1,38,1,38,1,38,1,38,1,38,1,38,1,38,3,38,270,8,38,1,39,1,39,1,39,
+        1,39,1,39,1,39,1,39,1,39,1,39,1,39,3,39,282,8,39,1,40,1,40,1,40,
+        1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,
+        1,41,1,41,1,41,3,41,303,8,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,
+        1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,3,42,320,8,42,1,43,5,43,
+        323,8,43,10,43,12,43,326,9,43,1,44,1,44,1,45,4,45,331,8,45,11,45,
+        12,45,332,1,46,4,46,336,8,46,11,46,12,46,337,1,46,1,46,5,46,342,
+        8,46,10,46,12,46,345,9,46,1,46,1,46,4,46,349,8,46,11,46,12,46,350,
+        3,46,353,8,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,3,47,
+        364,8,47,1,48,1,48,5,48,368,8,48,10,48,12,48,371,9,48,1,48,3,48,
+        374,8,48,1,48,1,48,1,48,1,48,1,49,1,49,5,49,382,8,49,10,49,12,49,
+        385,9,49,1,50,4,50,388,8,50,11,50,12,50,389,1,50,1,50,1,369,0,51,
+        1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,
+        27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,
+        49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,
+        71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,0,89,0,91,44,
+        93,45,95,46,97,47,99,48,101,49,1,0,24,2,0,77,77,109,109,2,0,65,65,
+        97,97,2,0,83,83,115,115,2,0,73,73,105,105,2,0,78,78,110,110,2,0,
+        69,69,101,101,2,0,82,82,114,114,2,0,84,84,116,116,2,0,80,80,112,
+        112,2,0,85,85,117,117,2,0,79,79,111,111,2,0,86,86,118,118,2,0,89,
+        89,121,121,2,0,67,67,99,99,2,0,68,68,100,100,2,0,87,87,119,119,2,
+        0,70,70,102,102,2,0,66,66,98,98,2,0,76,76,108,108,2,0,71,71,103,
+        103,1,0,48,57,2,0,65,90,97,122,4,0,48,57,65,90,95,95,97,122,4,0,
+        9,10,13,13,32,32,38,38,410,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,
+        7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,
+        1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,
+        1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,
+        1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,
+        1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,
+        1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,67,
+        1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,
+        1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,91,
+        1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,
+        1,0,0,0,1,103,1,0,0,0,3,105,1,0,0,0,5,107,1,0,0,0,7,109,1,0,0,0,
+        9,112,1,0,0,0,11,115,1,0,0,0,13,118,1,0,0,0,15,121,1,0,0,0,17,124,
+        1,0,0,0,19,127,1,0,0,0,21,129,1,0,0,0,23,131,1,0,0,0,25,133,1,0,
+        0,0,27,135,1,0,0,0,29,137,1,0,0,0,31,139,1,0,0,0,33,141,1,0,0,0,
+        35,143,1,0,0,0,37,145,1,0,0,0,39,147,1,0,0,0,41,149,1,0,0,0,43,151,
+        1,0,0,0,45,154,1,0,0,0,47,158,1,0,0,0,49,160,1,0,0,0,51,162,1,0,
+        0,0,53,164,1,0,0,0,55,169,1,0,0,0,57,177,1,0,0,0,59,185,1,0,0,0,
+        61,192,1,0,0,0,63,197,1,0,0,0,65,208,1,0,0,0,67,215,1,0,0,0,69,225,
+        1,0,0,0,71,233,1,0,0,0,73,241,1,0,0,0,75,252,1,0,0,0,77,260,1,0,
+        0,0,79,271,1,0,0,0,81,283,1,0,0,0,83,293,1,0,0,0,85,304,1,0,0,0,
+        87,324,1,0,0,0,89,327,1,0,0,0,91,330,1,0,0,0,93,352,1,0,0,0,95,363,
+        1,0,0,0,97,365,1,0,0,0,99,379,1,0,0,0,101,387,1,0,0,0,103,104,5,
+        91,0,0,104,2,1,0,0,0,105,106,5,93,0,0,106,4,1,0,0,0,107,108,5,61,
+        0,0,108,6,1,0,0,0,109,110,5,43,0,0,110,111,5,61,0,0,111,8,1,0,0,
+        0,112,113,5,45,0,0,113,114,5,61,0,0,114,10,1,0,0,0,115,116,5,58,
+        0,0,116,117,5,61,0,0,117,12,1,0,0,0,118,119,5,42,0,0,119,120,5,61,
+        0,0,120,14,1,0,0,0,121,122,5,47,0,0,122,123,5,61,0,0,123,16,1,0,
+        0,0,124,125,5,94,0,0,125,126,5,61,0,0,126,18,1,0,0,0,127,128,5,44,
+        0,0,128,20,1,0,0,0,129,130,5,39,0,0,130,22,1,0,0,0,131,132,5,40,
+        0,0,132,24,1,0,0,0,133,134,5,41,0,0,134,26,1,0,0,0,135,136,5,123,
+        0,0,136,28,1,0,0,0,137,138,5,125,0,0,138,30,1,0,0,0,139,140,5,58,
+        0,0,140,32,1,0,0,0,141,142,5,43,0,0,142,34,1,0,0,0,143,144,5,45,
+        0,0,144,36,1,0,0,0,145,146,5,59,0,0,146,38,1,0,0,0,147,148,5,46,
+        0,0,148,40,1,0,0,0,149,150,5,62,0,0,150,42,1,0,0,0,151,152,5,48,
+        0,0,152,153,5,62,0,0,153,44,1,0,0,0,154,155,5,49,0,0,155,156,5,62,
+        0,0,156,157,5,62,0,0,157,46,1,0,0,0,158,159,5,94,0,0,159,48,1,0,
+        0,0,160,161,5,42,0,0,161,50,1,0,0,0,162,163,5,47,0,0,163,52,1,0,
+        0,0,164,165,7,0,0,0,165,166,7,1,0,0,166,167,7,2,0,0,167,168,7,2,
+        0,0,168,54,1,0,0,0,169,170,7,3,0,0,170,171,7,4,0,0,171,172,7,5,0,
+        0,172,173,7,6,0,0,173,174,7,7,0,0,174,175,7,3,0,0,175,176,7,1,0,
+        0,176,56,1,0,0,0,177,178,7,3,0,0,178,179,7,4,0,0,179,180,7,8,0,0,
+        180,181,7,9,0,0,181,183,7,7,0,0,182,184,7,2,0,0,183,182,1,0,0,0,
+        183,184,1,0,0,0,184,58,1,0,0,0,185,186,7,10,0,0,186,187,7,9,0,0,
+        187,188,7,7,0,0,188,189,7,8,0,0,189,190,7,9,0,0,190,191,7,7,0,0,
+        191,60,1,0,0,0,192,193,7,2,0,0,193,194,7,1,0,0,194,195,7,11,0,0,
+        195,196,7,5,0,0,196,62,1,0,0,0,197,198,7,9,0,0,198,199,7,4,0,0,199,
+        200,7,3,0,0,200,201,7,7,0,0,201,202,7,2,0,0,202,203,7,12,0,0,203,
+        204,7,2,0,0,204,205,7,7,0,0,205,206,7,5,0,0,206,207,7,0,0,0,207,
+        64,1,0,0,0,208,209,7,5,0,0,209,210,7,4,0,0,210,211,7,13,0,0,211,
+        212,7,10,0,0,212,213,7,14,0,0,213,214,7,5,0,0,214,66,1,0,0,0,215,
+        216,7,4,0,0,216,217,7,5,0,0,217,218,7,15,0,0,218,219,7,7,0,0,219,
+        220,7,10,0,0,220,221,7,4,0,0,221,222,7,3,0,0,222,223,7,1,0,0,223,
+        224,7,4,0,0,224,68,1,0,0,0,225,226,7,16,0,0,226,227,7,6,0,0,227,
+        228,7,1,0,0,228,229,7,0,0,0,229,231,7,5,0,0,230,232,7,2,0,0,231,
+        230,1,0,0,0,231,232,1,0,0,0,232,70,1,0,0,0,233,234,7,17,0,0,234,
+        235,7,10,0,0,235,236,7,14,0,0,236,237,7,3,0,0,237,239,7,5,0,0,238,
+        240,7,2,0,0,239,238,1,0,0,0,239,240,1,0,0,0,240,72,1,0,0,0,241,242,
+        7,8,0,0,242,243,7,1,0,0,243,244,7,6,0,0,244,245,7,7,0,0,245,246,
+        7,3,0,0,246,247,7,13,0,0,247,248,7,18,0,0,248,250,7,5,0,0,249,251,
+        7,2,0,0,250,249,1,0,0,0,250,251,1,0,0,0,251,74,1,0,0,0,252,253,7,
+        8,0,0,253,254,7,10,0,0,254,255,7,3,0,0,255,256,7,4,0,0,256,258,7,
+        7,0,0,257,259,7,2,0,0,258,257,1,0,0,0,258,259,1,0,0,0,259,76,1,0,
+        0,0,260,261,7,13,0,0,261,262,7,10,0,0,262,263,7,4,0,0,263,264,7,
+        2,0,0,264,265,7,7,0,0,265,266,7,1,0,0,266,267,7,4,0,0,267,269,7,
+        7,0,0,268,270,7,2,0,0,269,268,1,0,0,0,269,270,1,0,0,0,270,78,1,0,
+        0,0,271,272,7,2,0,0,272,273,7,8,0,0,273,274,7,5,0,0,274,275,7,13,
+        0,0,275,276,7,3,0,0,276,277,7,16,0,0,277,278,7,3,0,0,278,279,7,5,
+        0,0,279,281,7,14,0,0,280,282,7,2,0,0,281,280,1,0,0,0,281,282,1,0,
+        0,0,282,80,1,0,0,0,283,284,7,3,0,0,284,285,7,0,0,0,285,286,7,1,0,
+        0,286,287,7,19,0,0,287,288,7,3,0,0,288,289,7,4,0,0,289,290,7,1,0,
+        0,290,291,7,6,0,0,291,292,7,12,0,0,292,82,1,0,0,0,293,294,7,11,0,
+        0,294,295,7,1,0,0,295,296,7,6,0,0,296,297,7,3,0,0,297,298,7,1,0,
+        0,298,299,7,17,0,0,299,300,7,18,0,0,300,302,7,5,0,0,301,303,7,2,
+        0,0,302,301,1,0,0,0,302,303,1,0,0,0,303,84,1,0,0,0,304,305,7,0,0,
+        0,305,306,7,10,0,0,306,307,7,7,0,0,307,308,7,3,0,0,308,309,7,10,
+        0,0,309,310,7,4,0,0,310,311,7,11,0,0,311,312,7,1,0,0,312,313,7,6,
+        0,0,313,314,7,3,0,0,314,315,7,1,0,0,315,316,7,17,0,0,316,317,7,18,
+        0,0,317,319,7,5,0,0,318,320,7,2,0,0,319,318,1,0,0,0,319,320,1,0,
+        0,0,320,86,1,0,0,0,321,323,5,39,0,0,322,321,1,0,0,0,323,326,1,0,
+        0,0,324,322,1,0,0,0,324,325,1,0,0,0,325,88,1,0,0,0,326,324,1,0,0,
+        0,327,328,7,20,0,0,328,90,1,0,0,0,329,331,7,20,0,0,330,329,1,0,0,
+        0,331,332,1,0,0,0,332,330,1,0,0,0,332,333,1,0,0,0,333,92,1,0,0,0,
+        334,336,3,89,44,0,335,334,1,0,0,0,336,337,1,0,0,0,337,335,1,0,0,
+        0,337,338,1,0,0,0,338,339,1,0,0,0,339,343,5,46,0,0,340,342,3,89,
+        44,0,341,340,1,0,0,0,342,345,1,0,0,0,343,341,1,0,0,0,343,344,1,0,
+        0,0,344,353,1,0,0,0,345,343,1,0,0,0,346,348,5,46,0,0,347,349,3,89,
+        44,0,348,347,1,0,0,0,349,350,1,0,0,0,350,348,1,0,0,0,350,351,1,0,
+        0,0,351,353,1,0,0,0,352,335,1,0,0,0,352,346,1,0,0,0,353,94,1,0,0,
+        0,354,355,3,93,46,0,355,356,5,69,0,0,356,357,3,91,45,0,357,364,1,
+        0,0,0,358,359,3,93,46,0,359,360,5,69,0,0,360,361,5,45,0,0,361,362,
+        3,91,45,0,362,364,1,0,0,0,363,354,1,0,0,0,363,358,1,0,0,0,364,96,
+        1,0,0,0,365,369,5,37,0,0,366,368,9,0,0,0,367,366,1,0,0,0,368,371,
+        1,0,0,0,369,370,1,0,0,0,369,367,1,0,0,0,370,373,1,0,0,0,371,369,
+        1,0,0,0,372,374,5,13,0,0,373,372,1,0,0,0,373,374,1,0,0,0,374,375,
+        1,0,0,0,375,376,5,10,0,0,376,377,1,0,0,0,377,378,6,48,0,0,378,98,
+        1,0,0,0,379,383,7,21,0,0,380,382,7,22,0,0,381,380,1,0,0,0,382,385,
+        1,0,0,0,383,381,1,0,0,0,383,384,1,0,0,0,384,100,1,0,0,0,385,383,
+        1,0,0,0,386,388,7,23,0,0,387,386,1,0,0,0,388,389,1,0,0,0,389,387,
+        1,0,0,0,389,390,1,0,0,0,390,391,1,0,0,0,391,392,6,50,0,0,392,102,
+        1,0,0,0,21,0,183,231,239,250,258,269,281,302,319,324,332,337,343,
+        350,352,363,369,373,383,389,1,6,0,0
+    ]
+
+class AutolevLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    T__2 = 3
+    T__3 = 4
+    T__4 = 5
+    T__5 = 6
+    T__6 = 7
+    T__7 = 8
+    T__8 = 9
+    T__9 = 10
+    T__10 = 11
+    T__11 = 12
+    T__12 = 13
+    T__13 = 14
+    T__14 = 15
+    T__15 = 16
+    T__16 = 17
+    T__17 = 18
+    T__18 = 19
+    T__19 = 20
+    T__20 = 21
+    T__21 = 22
+    T__22 = 23
+    T__23 = 24
+    T__24 = 25
+    T__25 = 26
+    Mass = 27
+    Inertia = 28
+    Input = 29
+    Output = 30
+    Save = 31
+    UnitSystem = 32
+    Encode = 33
+    Newtonian = 34
+    Frames = 35
+    Bodies = 36
+    Particles = 37
+    Points = 38
+    Constants = 39
+    Specifieds = 40
+    Imaginary = 41
+    Variables = 42
+    MotionVariables = 43
+    INT = 44
+    FLOAT = 45
+    EXP = 46
+    LINE_COMMENT = 47
+    ID = 48
+    WS = 49
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'['", "']'", "'='", "'+='", "'-='", "':='", "'*='", "'/='",
+            "'^='", "','", "'''", "'('", "')'", "'{'", "'}'", "':'", "'+'",
+            "'-'", "';'", "'.'", "'>'", "'0>'", "'1>>'", "'^'", "'*'", "'/'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "Mass", "Inertia", "Input", "Output", "Save", "UnitSystem",
+            "Encode", "Newtonian", "Frames", "Bodies", "Particles", "Points",
+            "Constants", "Specifieds", "Imaginary", "Variables", "MotionVariables",
+            "INT", "FLOAT", "EXP", "LINE_COMMENT", "ID", "WS" ]
+
+    ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6",
+                  "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13",
+                  "T__14", "T__15", "T__16", "T__17", "T__18", "T__19",
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25",
+                  "Mass", "Inertia", "Input", "Output", "Save", "UnitSystem",
+                  "Encode", "Newtonian", "Frames", "Bodies", "Particles",
+                  "Points", "Constants", "Specifieds", "Imaginary", "Variables",
+                  "MotionVariables", "DIFF", "DIGIT", "INT", "FLOAT", "EXP",
+                  "LINE_COMMENT", "ID", "WS" ]
+
+    grammarFileName = "Autolev.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/_antlr/autolevlistener.py

@@ -0,0 +1,421 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+if __name__ is not None and "." in __name__:
+    from .autolevparser import AutolevParser
+else:
+    from autolevparser import AutolevParser
+
+# This class defines a complete listener for a parse tree produced by AutolevParser.
+class AutolevListener(ParseTreeListener):
+
+    # Enter a parse tree produced by AutolevParser#prog.
+    def enterProg(self, ctx:AutolevParser.ProgContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#prog.
+    def exitProg(self, ctx:AutolevParser.ProgContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#stat.
+    def enterStat(self, ctx:AutolevParser.StatContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#stat.
+    def exitStat(self, ctx:AutolevParser.StatContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#vecAssign.
+    def enterVecAssign(self, ctx:AutolevParser.VecAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#vecAssign.
+    def exitVecAssign(self, ctx:AutolevParser.VecAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#indexAssign.
+    def enterIndexAssign(self, ctx:AutolevParser.IndexAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#indexAssign.
+    def exitIndexAssign(self, ctx:AutolevParser.IndexAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#regularAssign.
+    def enterRegularAssign(self, ctx:AutolevParser.RegularAssignContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#regularAssign.
+    def exitRegularAssign(self, ctx:AutolevParser.RegularAssignContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#equals.
+    def enterEquals(self, ctx:AutolevParser.EqualsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#equals.
+    def exitEquals(self, ctx:AutolevParser.EqualsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#index.
+    def enterIndex(self, ctx:AutolevParser.IndexContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#index.
+    def exitIndex(self, ctx:AutolevParser.IndexContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#diff.
+    def enterDiff(self, ctx:AutolevParser.DiffContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#diff.
+    def exitDiff(self, ctx:AutolevParser.DiffContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#functionCall.
+    def enterFunctionCall(self, ctx:AutolevParser.FunctionCallContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#functionCall.
+    def exitFunctionCall(self, ctx:AutolevParser.FunctionCallContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varDecl.
+    def enterVarDecl(self, ctx:AutolevParser.VarDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varDecl.
+    def exitVarDecl(self, ctx:AutolevParser.VarDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varType.
+    def enterVarType(self, ctx:AutolevParser.VarTypeContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varType.
+    def exitVarType(self, ctx:AutolevParser.VarTypeContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#varDecl2.
+    def enterVarDecl2(self, ctx:AutolevParser.VarDecl2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#varDecl2.
+    def exitVarDecl2(self, ctx:AutolevParser.VarDecl2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#ranges.
+    def enterRanges(self, ctx:AutolevParser.RangesContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#ranges.
+    def exitRanges(self, ctx:AutolevParser.RangesContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#massDecl.
+    def enterMassDecl(self, ctx:AutolevParser.MassDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#massDecl.
+    def exitMassDecl(self, ctx:AutolevParser.MassDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#massDecl2.
+    def enterMassDecl2(self, ctx:AutolevParser.MassDecl2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#massDecl2.
+    def exitMassDecl2(self, ctx:AutolevParser.MassDecl2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inertiaDecl.
+    def enterInertiaDecl(self, ctx:AutolevParser.InertiaDeclContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inertiaDecl.
+    def exitInertiaDecl(self, ctx:AutolevParser.InertiaDeclContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrix.
+    def enterMatrix(self, ctx:AutolevParser.MatrixContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrix.
+    def exitMatrix(self, ctx:AutolevParser.MatrixContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrixInOutput.
+    def enterMatrixInOutput(self, ctx:AutolevParser.MatrixInOutputContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrixInOutput.
+    def exitMatrixInOutput(self, ctx:AutolevParser.MatrixInOutputContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#codeCommands.
+    def enterCodeCommands(self, ctx:AutolevParser.CodeCommandsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#codeCommands.
+    def exitCodeCommands(self, ctx:AutolevParser.CodeCommandsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#settings.
+    def enterSettings(self, ctx:AutolevParser.SettingsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#settings.
+    def exitSettings(self, ctx:AutolevParser.SettingsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#units.
+    def enterUnits(self, ctx:AutolevParser.UnitsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#units.
+    def exitUnits(self, ctx:AutolevParser.UnitsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inputs.
+    def enterInputs(self, ctx:AutolevParser.InputsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inputs.
+    def exitInputs(self, ctx:AutolevParser.InputsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#id_diff.
+    def enterId_diff(self, ctx:AutolevParser.Id_diffContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#id_diff.
+    def exitId_diff(self, ctx:AutolevParser.Id_diffContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#inputs2.
+    def enterInputs2(self, ctx:AutolevParser.Inputs2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#inputs2.
+    def exitInputs2(self, ctx:AutolevParser.Inputs2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#outputs.
+    def enterOutputs(self, ctx:AutolevParser.OutputsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#outputs.
+    def exitOutputs(self, ctx:AutolevParser.OutputsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#outputs2.
+    def enterOutputs2(self, ctx:AutolevParser.Outputs2Context):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#outputs2.
+    def exitOutputs2(self, ctx:AutolevParser.Outputs2Context):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#codegen.
+    def enterCodegen(self, ctx:AutolevParser.CodegenContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#codegen.
+    def exitCodegen(self, ctx:AutolevParser.CodegenContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#commands.
+    def enterCommands(self, ctx:AutolevParser.CommandsContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#commands.
+    def exitCommands(self, ctx:AutolevParser.CommandsContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#vec.
+    def enterVec(self, ctx:AutolevParser.VecContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#vec.
+    def exitVec(self, ctx:AutolevParser.VecContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#parens.
+    def enterParens(self, ctx:AutolevParser.ParensContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#parens.
+    def exitParens(self, ctx:AutolevParser.ParensContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#VectorOrDyadic.
+    def enterVectorOrDyadic(self, ctx:AutolevParser.VectorOrDyadicContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#VectorOrDyadic.
+    def exitVectorOrDyadic(self, ctx:AutolevParser.VectorOrDyadicContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#Exponent.
+    def enterExponent(self, ctx:AutolevParser.ExponentContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#Exponent.
+    def exitExponent(self, ctx:AutolevParser.ExponentContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#MulDiv.
+    def enterMulDiv(self, ctx:AutolevParser.MulDivContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#MulDiv.
+    def exitMulDiv(self, ctx:AutolevParser.MulDivContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#AddSub.
+    def enterAddSub(self, ctx:AutolevParser.AddSubContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#AddSub.
+    def exitAddSub(self, ctx:AutolevParser.AddSubContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#float.
+    def enterFloat(self, ctx:AutolevParser.FloatContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#float.
+    def exitFloat(self, ctx:AutolevParser.FloatContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#int.
+    def enterInt(self, ctx:AutolevParser.IntContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#int.
+    def exitInt(self, ctx:AutolevParser.IntContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#idEqualsExpr.
+    def enterIdEqualsExpr(self, ctx:AutolevParser.IdEqualsExprContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#idEqualsExpr.
+    def exitIdEqualsExpr(self, ctx:AutolevParser.IdEqualsExprContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#negativeOne.
+    def enterNegativeOne(self, ctx:AutolevParser.NegativeOneContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#negativeOne.
+    def exitNegativeOne(self, ctx:AutolevParser.NegativeOneContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#function.
+    def enterFunction(self, ctx:AutolevParser.FunctionContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#function.
+    def exitFunction(self, ctx:AutolevParser.FunctionContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#rangess.
+    def enterRangess(self, ctx:AutolevParser.RangessContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#rangess.
+    def exitRangess(self, ctx:AutolevParser.RangessContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#colon.
+    def enterColon(self, ctx:AutolevParser.ColonContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#colon.
+    def exitColon(self, ctx:AutolevParser.ColonContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#id.
+    def enterId(self, ctx:AutolevParser.IdContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#id.
+    def exitId(self, ctx:AutolevParser.IdContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#exp.
+    def enterExp(self, ctx:AutolevParser.ExpContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#exp.
+    def exitExp(self, ctx:AutolevParser.ExpContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#matrices.
+    def enterMatrices(self, ctx:AutolevParser.MatricesContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#matrices.
+    def exitMatrices(self, ctx:AutolevParser.MatricesContext):
+        pass
+
+
+    # Enter a parse tree produced by AutolevParser#Indexing.
+    def enterIndexing(self, ctx:AutolevParser.IndexingContext):
+        pass
+
+    # Exit a parse tree produced by AutolevParser#Indexing.
+    def exitIndexing(self, ctx:AutolevParser.IndexingContext):
+        pass
+
+
+
+del AutolevParser

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/_build_autolev_antlr.py

@@ -0,0 +1,86 @@
+import os
+import subprocess
+import glob
+
+from sympy.utilities.misc import debug
+
+here = os.path.dirname(__file__)
+grammar_file = os.path.abspath(os.path.join(here, "Autolev.g4"))
+dir_autolev_antlr = os.path.join(here, "_antlr")
+
+header = '''\
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+'''
+
+
+def check_antlr_version():
+    debug("Checking antlr4 version...")
+
+    try:
+        debug(subprocess.check_output(["antlr4"])
+              .decode('utf-8').split("\n")[0])
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        debug("The 'antlr4' command line tool is not installed, "
+              "or not on your PATH.\n"
+              "> Please refer to the README.md file for more information.")
+        return False
+
+
+def build_parser(output_dir=dir_autolev_antlr):
+    check_antlr_version()
+
+    debug("Updating ANTLR-generated code in {}".format(output_dir))
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(os.path.join(output_dir, "__init__.py"), "w+") as fp:
+        fp.write(header)
+
+    args = [
+        "antlr4",
+        grammar_file,
+        "-o", output_dir,
+        "-no-visitor",
+    ]
+
+    debug("Running code generation...\n\t$ {}".format(" ".join(args)))
+    subprocess.check_output(args, cwd=output_dir)
+
+    debug("Applying headers, removing unnecessary files and renaming...")
+    # Handle case insensitive file systems. If the files are already
+    # generated, they will be written to autolev* but Autolev*.* won't match them.
+    for path in (glob.glob(os.path.join(output_dir, "Autolev*.*")) or
+        glob.glob(os.path.join(output_dir, "autolev*.*"))):
+
+        # Remove files ending in .interp or .tokens as they are not needed.
+        if not path.endswith(".py"):
+            os.unlink(path)
+            continue
+
+        new_path = os.path.join(output_dir, os.path.basename(path).lower())
+        with open(path, 'r') as f:
+            lines = [line.rstrip().replace('AutolevParser import', 'autolevparser import') +'\n'
+                     for line in f.readlines()]
+
+        os.unlink(path)
+
+        with open(new_path, "w") as out_file:
+            offset = 0
+            while lines[offset].startswith('#'):
+                offset += 1
+            out_file.write(header)
+            out_file.writelines(lines[offset:])
+
+        debug("\t{}".format(new_path))
+
+    return True
+
+
+if __name__ == "__main__":
+    build_parser()

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/_parse_autolev_antlr.py

@@ -0,0 +1,38 @@
+from importlib.metadata import version
+from sympy.external import import_module
+
+
+autolevparser = import_module('sympy.parsing.autolev._antlr.autolevparser',
+                              import_kwargs={'fromlist': ['AutolevParser']})
+autolevlexer = import_module('sympy.parsing.autolev._antlr.autolevlexer',
+                             import_kwargs={'fromlist': ['AutolevLexer']})
+autolevlistener = import_module('sympy.parsing.autolev._antlr.autolevlistener',
+                                import_kwargs={'fromlist': ['AutolevListener']})
+
+AutolevParser = getattr(autolevparser, 'AutolevParser', None)
+AutolevLexer = getattr(autolevlexer, 'AutolevLexer', None)
+AutolevListener = getattr(autolevlistener, 'AutolevListener', None)
+
+
+def parse_autolev(autolev_code, include_numeric):
+    antlr4 = import_module('antlr4')
+    if not antlr4 or not version('antlr4-python3-runtime').startswith('4.11'):
+        raise ImportError("Autolev parsing requires the antlr4 Python package,"
+                          " provided by pip (antlr4-python3-runtime)"
+                          " conda (antlr-python-runtime), version 4.11")
+    try:
+        l = autolev_code.readlines()
+        input_stream = antlr4.InputStream("".join(l))
+    except Exception:
+        input_stream = antlr4.InputStream(autolev_code)
+
+    if AutolevListener:
+        from ._listener_autolev_antlr import MyListener
+        lexer = AutolevLexer(input_stream)
+        token_stream = antlr4.CommonTokenStream(lexer)
+        parser = AutolevParser(token_stream)
+        tree = parser.prog()
+        my_listener = MyListener(include_numeric)
+        walker = antlr4.ParseTreeWalker()
+        walker.walk(my_listener, tree)
+        return "".join(my_listener.output_code)

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest1.py

@@ -0,0 +1,15 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+f = _sm.S(3)
+g = _sm.S(9.81)
+a, b = _sm.symbols('a b', real=True)
+s, s1 = _sm.symbols('s s1', real=True)
+s2, s3 = _sm.symbols('s2 s3', real=True, nonnegative=True)
+s4 = _sm.symbols('s4', real=True, nonpositive=True)
+k1, k2, k3, k4, l1, l2, l3, p11, p12, p13, p21, p22, p23 = _sm.symbols('k1 k2 k3 k4 l1 l2 l3 p11 p12 p13 p21 p22 p23', real=True)
+c11, c12, c13, c21, c22, c23 = _sm.symbols('c11 c12 c13 c21 c22 c23', real=True)
+e1 = a*f+s2-g
+e2 = f**2+k3*k2*g

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest10.al

@@ -0,0 +1,58 @@
+% ruletest10.al
+
+VARIABLES X,Y
+COMPLEX ON
+CONSTANTS A,B
+E = A*(B*X+Y)^2
+M = [E;E]
+EXPAND(E)
+EXPAND(M)
+FACTOR(E,X)
+FACTOR(M,X)
+
+EQN[1] = A*X + B*Y
+EQN[2] = 2*A*X - 3*B*Y
+SOLVE(EQN, X, Y)
+RHS_Y = RHS(Y)
+E = (X+Y)^2 + 2*X^2
+ARRANGE(E, 2, X)
+
+CONSTANTS A,B,C
+M = [A,B;C,0]
+M2 = EVALUATE(M,A=1,B=2,C=3)
+EIG(M2, EIGVALUE, EIGVEC)
+
+NEWTONIAN N
+FRAMES A
+SIMPROT(N, A, N1>, X)
+DEGREES OFF
+SIMPROT(N, A, N1>, PI/2)
+
+CONSTANTS C{3}
+V> = C1*A1> + C2*A2> + C3*A3>
+POINTS O, P
+P_P_O> = C1*A1>
+EXPRESS(V>,N)
+EXPRESS(P_P_O>,N)
+W_A_N> = C3*A3>
+ANGVEL(A,N)
+
+V2PTS(N,A,O,P)
+PARTICLES P{2}
+V2PTS(N,A,P1,P2)
+A2PTS(N,A,P1,P)
+
+BODIES B{2}
+CONSTANT G
+GRAVITY(G*N1>)
+
+VARIABLE Z
+V> = X*A1> + Y*A3>
+P_P_O> = X*A1> + Y*A2>
+X = 2*Z
+Y = Z
+EXPLICIT(V>)
+EXPLICIT(P_P_O>)
+
+FORCE(O/P1, X*Y*A1>)
+FORCE(P2, X*Y*A1>)

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest11.al

@@ -0,0 +1,6 @@
+VARIABLES X, Y
+CONSTANTS A{1:2, 1:2}, B{1:2}
+EQN[1] = A11*x + A12*y - B1
+EQN[2] = A21*x + A22*y - B2
+INPUT A11=2, A12=5, A21=3, A22=4, B1=7, B2=6
+CODE ALGEBRAIC(EQN, X, Y) some_filename.c

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest2.al

@@ -0,0 +1,12 @@
+% ruletest2.al
+VARIABLES X1,X2
+SPECIFIED F1 = X1*X2 + 3*X1^2
+SPECIFIED F2=X1*T+X2*T^2
+VARIABLE X', Y''
+MOTIONVARIABLES Q{3}, U{2}
+VARIABLES P{2}'
+VARIABLE W{3}', R{2}''
+VARIABLES C{1:2, 1:2}
+VARIABLES D{1,3}
+VARIABLES J{1:2}
+IMAGINARY N

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest8.al

@@ -0,0 +1,38 @@
+% ruletest8.al
+FRAMES A
+CONSTANTS C{3}
+A>> = EXPRESS(1>>,A)
+PARTICLES P1, P2
+BODIES R
+R_A = [1,1,1;1,1,0;0,0,1]
+POINT O
+MASS P1=M1, P2=M2, R=MR
+INERTIA R, I1, I2, I3
+P_P1_O> = C1*A1>
+P_P2_O> = C2*A2>
+P_RO_O> = C3*A3>
+A>> = EXPRESS(I_P1_O>>, A)
+A>> = EXPRESS(I_P2_O>>, A)
+A>> = EXPRESS(I_R_O>>, A)
+A>> = EXPRESS(INERTIA(O), A)
+A>> = EXPRESS(INERTIA(O, P1, R), A)
+A>> = EXPRESS(I_R_O>>, A)
+A>> = EXPRESS(I_R_RO>>, A)
+
+P_P1_P2> = C1*A1> + C2*A2>
+P_P1_RO> = C3*A1>
+P_P2_RO> = C3*A2>
+
+B> = CM(O)
+B> = CM(O, P1, R)
+B> = CM(P1)
+
+MOTIONVARIABLES U{3}
+V> = U1*A1> + U2*A2> + U3*A3>
+U> = UNITVEC(V> + C1*A1>)
+V_P1_A> = U1*A1>
+A> = PARTIALS(V_P1_A>, U1)
+
+M = MASS(P1,R)
+M = MASS(P2)
+M = MASS()

llmeval-env/lib/python3.10/site-packages/sympy/parsing/autolev/test-examples/ruletest9.py

@@ -0,0 +1,55 @@
+import sympy.physics.mechanics as _me
+import sympy as _sm
+import math as m
+import numpy as _np
+
+frame_n = _me.ReferenceFrame('n')
+frame_a = _me.ReferenceFrame('a')
+a = 0
+d = _me.inertia(frame_a, 1, 1, 1)
+point_po1 = _me.Point('po1')
+point_po2 = _me.Point('po2')
+particle_p1 = _me.Particle('p1', _me.Point('p1_pt'), _sm.Symbol('m'))
+particle_p2 = _me.Particle('p2', _me.Point('p2_pt'), _sm.Symbol('m'))
+c1, c2, c3 = _me.dynamicsymbols('c1 c2 c3')
+c1_d, c2_d, c3_d = _me.dynamicsymbols('c1_ c2_ c3_', 1)
+body_r_cm = _me.Point('r_cm')
+body_r_cm.set_vel(frame_n, 0)
+body_r_f = _me.ReferenceFrame('r_f')
+body_r = _me.RigidBody('r', body_r_cm, body_r_f, _sm.symbols('m'), (_me.outer(body_r_f.x,body_r_f.x),body_r_cm))
+point_po2.set_pos(particle_p1.point, c1*frame_a.x)
+v = 2*point_po2.pos_from(particle_p1.point)+c2*frame_a.y
+frame_a.set_ang_vel(frame_n, c3*frame_a.z)
+v = 2*frame_a.ang_vel_in(frame_n)+c2*frame_a.y
+body_r_f.set_ang_vel(frame_n, c3*frame_a.z)
+v = 2*body_r_f.ang_vel_in(frame_n)+c2*frame_a.y
+frame_a.set_ang_acc(frame_n, (frame_a.ang_vel_in(frame_n)).dt(frame_a))
+v = 2*frame_a.ang_acc_in(frame_n)+c2*frame_a.y
+particle_p1.point.set_vel(frame_a, c1*frame_a.x+c3*frame_a.y)
+body_r_cm.set_acc(frame_n, c2*frame_a.y)
+v_a = _me.cross(body_r_cm.acc(frame_n), particle_p1.point.vel(frame_a))
+x_b_c = v_a
+x_b_d = 2*x_b_c
+a_b_c_d_e = x_b_d*2
+a_b_c = 2*c1*c2*c3
+a_b_c += 2*c1
+a_b_c  =  3*c1
+q1, q2, u1, u2 = _me.dynamicsymbols('q1 q2 u1 u2')
+q1_d, q2_d, u1_d, u2_d = _me.dynamicsymbols('q1_ q2_ u1_ u2_', 1)
+x, y = _me.dynamicsymbols('x y')
+x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
+x_dd, y_dd = _me.dynamicsymbols('x_ y_', 2)
+yy = _me.dynamicsymbols('yy')
+yy = x*x_d**2+1
+m = _sm.Matrix([[0]])
+m[0] = 2*x
+m = m.row_insert(m.shape[0], _sm.Matrix([[0]]))
+m[m.shape[0]-1] = 2*y
+a = 2*m[0]
+m = _sm.Matrix([1,2,3,4,5,6,7,8,9]).reshape(3, 3)
+m[0,1] = 5
+a = m[0, 1]*2
+force_ro = q1*frame_n.x
+torque_a = q2*frame_n.z
+force_ro = q1*frame_n.x + q2*frame_n.y
+f = force_ro*2

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright 2016, latex2sympy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/LaTeX.g4

@@ -0,0 +1,312 @@
+/*
+ ANTLR4 LaTeX Math Grammar
+
+ Ported from latex2sympy by @augustt198 https://github.com/augustt198/latex2sympy See license in
+ LICENSE.txt
+ */
+
+/*
+ After changing this file, it is necessary to run `python setup.py antlr` in the root directory of
+ the repository. This will regenerate the code in `sympy/parsing/latex/_antlr/*.py`.
+ */
+
+grammar LaTeX;
+
+options {
+	language = Python3;
+}
+
+WS: [ \t\r\n]+ -> skip;
+THINSPACE: ('\\,' | '\\thinspace') -> skip;
+MEDSPACE: ('\\:' | '\\medspace') -> skip;
+THICKSPACE: ('\\;' | '\\thickspace') -> skip;
+QUAD: '\\quad' -> skip;
+QQUAD: '\\qquad' -> skip;
+NEGTHINSPACE: ('\\!' | '\\negthinspace') -> skip;
+NEGMEDSPACE: '\\negmedspace' -> skip;
+NEGTHICKSPACE: '\\negthickspace' -> skip;
+CMD_LEFT: '\\left' -> skip;
+CMD_RIGHT: '\\right' -> skip;
+
+IGNORE:
+	(
+		'\\vrule'
+		| '\\vcenter'
+		| '\\vbox'
+		| '\\vskip'
+		| '\\vspace'
+		| '\\hfil'
+		| '\\*'
+		| '\\-'
+		| '\\.'
+		| '\\/'
+		| '\\"'
+		| '\\('
+		| '\\='
+	) -> skip;
+
+ADD: '+';
+SUB: '-';
+MUL: '*';
+DIV: '/';
+
+L_PAREN: '(';
+R_PAREN: ')';
+L_BRACE: '{';
+R_BRACE: '}';
+L_BRACE_LITERAL: '\\{';
+R_BRACE_LITERAL: '\\}';
+L_BRACKET: '[';
+R_BRACKET: ']';
+
+BAR: '|';
+
+R_BAR: '\\right|';
+L_BAR: '\\left|';
+
+L_ANGLE: '\\langle';
+R_ANGLE: '\\rangle';
+FUNC_LIM: '\\lim';
+LIM_APPROACH_SYM:
+	'\\to'
+	| '\\rightarrow'
+	| '\\Rightarrow'
+	| '\\longrightarrow'
+	| '\\Longrightarrow';
+FUNC_INT:
+    '\\int'
+    | '\\int\\limits';
+FUNC_SUM: '\\sum';
+FUNC_PROD: '\\prod';
+
+FUNC_EXP: '\\exp';
+FUNC_LOG: '\\log';
+FUNC_LG: '\\lg';
+FUNC_LN: '\\ln';
+FUNC_SIN: '\\sin';
+FUNC_COS: '\\cos';
+FUNC_TAN: '\\tan';
+FUNC_CSC: '\\csc';
+FUNC_SEC: '\\sec';
+FUNC_COT: '\\cot';
+
+FUNC_ARCSIN: '\\arcsin';
+FUNC_ARCCOS: '\\arccos';
+FUNC_ARCTAN: '\\arctan';
+FUNC_ARCCSC: '\\arccsc';
+FUNC_ARCSEC: '\\arcsec';
+FUNC_ARCCOT: '\\arccot';
+
+FUNC_SINH: '\\sinh';
+FUNC_COSH: '\\cosh';
+FUNC_TANH: '\\tanh';
+FUNC_ARSINH: '\\arsinh';
+FUNC_ARCOSH: '\\arcosh';
+FUNC_ARTANH: '\\artanh';
+
+L_FLOOR: '\\lfloor';
+R_FLOOR: '\\rfloor';
+L_CEIL: '\\lceil';
+R_CEIL: '\\rceil';
+
+FUNC_SQRT: '\\sqrt';
+FUNC_OVERLINE: '\\overline';
+
+CMD_TIMES: '\\times';
+CMD_CDOT: '\\cdot';
+CMD_DIV: '\\div';
+CMD_FRAC:
+    '\\frac'
+    | '\\dfrac'
+    | '\\tfrac';
+CMD_BINOM: '\\binom';
+CMD_DBINOM: '\\dbinom';
+CMD_TBINOM: '\\tbinom';
+
+CMD_MATHIT: '\\mathit';
+
+UNDERSCORE: '_';
+CARET: '^';
+COLON: ':';
+
+fragment WS_CHAR: [ \t\r\n];
+DIFFERENTIAL: 'd' WS_CHAR*? ([a-zA-Z] | '\\' [a-zA-Z]+);
+
+LETTER: [a-zA-Z];
+DIGIT: [0-9];
+
+EQUAL: (('&' WS_CHAR*?)? '=') | ('=' (WS_CHAR*? '&')?);
+NEQ: '\\neq';
+
+LT: '<';
+LTE: ('\\leq' | '\\le' | LTE_Q | LTE_S);
+LTE_Q: '\\leqq';
+LTE_S: '\\leqslant';
+
+GT: '>';
+GTE: ('\\geq' | '\\ge' | GTE_Q | GTE_S);
+GTE_Q: '\\geqq';
+GTE_S: '\\geqslant';
+
+BANG: '!';
+
+SINGLE_QUOTES: '\''+;
+
+SYMBOL: '\\' [a-zA-Z]+;
+
+math: relation;
+
+relation:
+	relation (EQUAL | LT | LTE | GT | GTE | NEQ) relation
+	| expr;
+
+equality: expr EQUAL expr;
+
+expr: additive;
+
+additive: additive (ADD | SUB) additive | mp;
+
+// mult part
+mp:
+	mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp
+	| unary;
+
+mp_nofunc:
+	mp_nofunc (
+		MUL
+		| CMD_TIMES
+		| CMD_CDOT
+		| DIV
+		| CMD_DIV
+		| COLON
+	) mp_nofunc
+	| unary_nofunc;
+
+unary: (ADD | SUB) unary | postfix+;
+
+unary_nofunc:
+	(ADD | SUB) unary_nofunc
+	| postfix postfix_nofunc*;
+
+postfix: exp postfix_op*;
+postfix_nofunc: exp_nofunc postfix_op*;
+postfix_op: BANG | eval_at;
+
+eval_at:
+	BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
+
+eval_at_sub: UNDERSCORE L_BRACE (expr | equality) R_BRACE;
+
+eval_at_sup: CARET L_BRACE (expr | equality) R_BRACE;
+
+exp: exp CARET (atom | L_BRACE expr R_BRACE) subexpr? | comp;
+
+exp_nofunc:
+	exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
+	| comp_nofunc;
+
+comp:
+	group
+	| abs_group
+	| func
+	| atom
+	| floor
+	| ceil;
+
+comp_nofunc:
+	group
+	| abs_group
+	| atom
+	| floor
+	| ceil;
+
+group:
+	L_PAREN expr R_PAREN
+	| L_BRACKET expr R_BRACKET
+	| L_BRACE expr R_BRACE
+	| L_BRACE_LITERAL expr R_BRACE_LITERAL;
+
+abs_group: BAR expr BAR;
+
+number: DIGIT+ (',' DIGIT DIGIT DIGIT)* ('.' DIGIT+)?;
+
+atom: (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?)
+	| number
+	| DIFFERENTIAL
+	| mathit
+	| frac
+	| binom
+	| bra
+	| ket;
+
+bra: L_ANGLE expr (R_BAR | BAR);
+ket: (L_BAR | BAR) expr R_ANGLE;
+
+mathit: CMD_MATHIT L_BRACE mathit_text R_BRACE;
+mathit_text: LETTER*;
+
+frac: CMD_FRAC (upperd = DIGIT | L_BRACE upper = expr R_BRACE)
+    (lowerd = DIGIT | L_BRACE lower = expr R_BRACE);
+
+binom:
+	(CMD_BINOM | CMD_DBINOM | CMD_TBINOM) L_BRACE n = expr R_BRACE L_BRACE k = expr R_BRACE;
+
+floor: L_FLOOR val = expr R_FLOOR;
+ceil: L_CEIL val = expr R_CEIL;
+
+func_normal:
+	FUNC_EXP
+	| FUNC_LOG
+	| FUNC_LG
+	| FUNC_LN
+	| FUNC_SIN
+	| FUNC_COS
+	| FUNC_TAN
+	| FUNC_CSC
+	| FUNC_SEC
+	| FUNC_COT
+	| FUNC_ARCSIN
+	| FUNC_ARCCOS
+	| FUNC_ARCTAN
+	| FUNC_ARCCSC
+	| FUNC_ARCSEC
+	| FUNC_ARCCOT
+	| FUNC_SINH
+	| FUNC_COSH
+	| FUNC_TANH
+	| FUNC_ARSINH
+	| FUNC_ARCOSH
+	| FUNC_ARTANH;
+
+func:
+	func_normal (subexpr? supexpr? | supexpr? subexpr?) (
+		L_PAREN func_arg R_PAREN
+		| func_arg_noparens
+	)
+	| (LETTER | SYMBOL) (subexpr? SINGLE_QUOTES? | SINGLE_QUOTES? subexpr?) // e.g. f(x), f_1'(x)
+	L_PAREN args R_PAREN
+	| FUNC_INT (subexpr supexpr | supexpr subexpr)? (
+		additive? DIFFERENTIAL
+		| frac
+		| additive
+	)
+	| FUNC_SQRT (L_BRACKET root = expr R_BRACKET)? L_BRACE base = expr R_BRACE
+	| FUNC_OVERLINE L_BRACE base = expr R_BRACE
+	| (FUNC_SUM | FUNC_PROD) (subeq supexpr | supexpr subeq) mp
+	| FUNC_LIM limit_sub mp;
+
+args: (expr ',' args) | expr;
+
+limit_sub:
+	UNDERSCORE L_BRACE (LETTER | SYMBOL) LIM_APPROACH_SYM expr (
+		CARET ((L_BRACE (ADD | SUB) R_BRACE) | ADD | SUB)
+	)? R_BRACE;
+
+func_arg: expr | (expr ',' func_arg);
+func_arg_noparens: mp_nofunc;
+
+subexpr: UNDERSCORE (atom | L_BRACE expr R_BRACE);
+supexpr: CARET (atom | L_BRACE expr R_BRACE);
+
+subeq: UNDERSCORE L_BRACE equality R_BRACE;
+supeq: UNDERSCORE L_BRACE equality R_BRACE;

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/__init__.py

@@ -0,0 +1,35 @@
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+from .errors import LaTeXParsingError  # noqa
+
+@doctest_depends_on(modules=('antlr4',))
+def parse_latex(s):
+    r"""Converts the string ``s`` to a SymPy ``Expr``
+
+    Parameters
+    ==========
+
+    s : str
+        The LaTeX string to parse. In Python source containing LaTeX,
+        *raw strings* (denoted with ``r"``, like this one) are preferred,
+        as LaTeX makes liberal use of the ``\`` character, which would
+        trigger escaping in normal Python strings.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.latex import parse_latex
+    >>> expr = parse_latex(r"\frac {1 + \sqrt {\a}} {\b}")
+    >>> expr
+    (sqrt(a) + 1)/b
+    >>> expr.evalf(4, subs=dict(a=5, b=2))
+    1.618
+    """
+
+    _latex = import_module(
+        'sympy.parsing.latex._parse_latex_antlr',
+        import_kwargs={'fromlist': ['X']})
+
+    if _latex is not None:
+        return _latex.parse_latex(s)

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/__init__.py

@@ -0,0 +1,9 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/_antlr/latexlexer.py

@@ -0,0 +1,512 @@
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+from antlr4 import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,91,911,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,
+        2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,
+        13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,
+        19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,
+        26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,
+        32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,
+        39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,
+        45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,
+        52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,
+        58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,
+        65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,
+        71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,
+        78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,
+        84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,
+        91,7,91,1,0,1,0,1,1,1,1,1,2,4,2,191,8,2,11,2,12,2,192,1,2,1,2,1,
+        3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,209,8,3,1,3,1,
+        3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,224,8,4,1,4,1,
+        4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,241,8,
+        5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,
+        7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,
+        8,1,8,1,8,3,8,277,8,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,
+        9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
+        1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,
+        1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,1,12,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,
+        1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,
+        381,8,13,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,
+        1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,22,1,23,1,23,1,23,
+        1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,
+        1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,
+        1,29,1,29,1,29,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,1,31,1,31,
+        1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32,
+        1,32,1,32,1,32,1,32,1,32,1,32,3,32,504,8,32,1,33,1,33,1,33,1,33,
+        1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,521,
+        8,33,1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,36,
+        1,36,1,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,
+        1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,
+        1,41,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,44,1,44,
+        1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,
+        1,46,1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,
+        1,48,1,48,1,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,49,1,49,
+        1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,51,1,51,1,51,1,51,
+        1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,
+        1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55,
+        1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,57,
+        1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,58,
+        1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,
+        1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,
+        1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,
+        1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65,
+        1,65,1,66,1,66,1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,67,1,67,
+        1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,3,67,753,8,67,
+        1,68,1,68,1,68,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,69,
+        1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,71,1,71,1,71,
+        1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,73,1,73,1,74,1,74,1,75,1,75,
+        1,76,1,76,5,76,796,8,76,10,76,12,76,799,9,76,1,76,1,76,1,76,4,76,
+        804,8,76,11,76,12,76,805,3,76,808,8,76,1,77,1,77,1,78,1,78,1,79,
+        1,79,5,79,816,8,79,10,79,12,79,819,9,79,3,79,821,8,79,1,79,1,79,
+        1,79,5,79,826,8,79,10,79,12,79,829,9,79,1,79,3,79,832,8,79,3,79,
+        834,8,79,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,82,1,82,1,82,1,82,
+        1,82,1,82,1,82,1,82,1,82,3,82,852,8,82,1,83,1,83,1,83,1,83,1,83,
+        1,83,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,
+        1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,3,86,881,8,86,1,87,
+        1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,
+        1,88,1,88,1,89,1,89,1,90,4,90,902,8,90,11,90,12,90,903,1,91,1,91,
+        4,91,908,8,91,11,91,12,91,909,3,797,817,827,0,92,1,1,3,2,5,3,7,4,
+        9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,
+        33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,49,25,51,26,53,27,
+        55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,71,36,73,37,75,38,
+        77,39,79,40,81,41,83,42,85,43,87,44,89,45,91,46,93,47,95,48,97,49,
+        99,50,101,51,103,52,105,53,107,54,109,55,111,56,113,57,115,58,117,
+        59,119,60,121,61,123,62,125,63,127,64,129,65,131,66,133,67,135,68,
+        137,69,139,70,141,71,143,72,145,73,147,74,149,75,151,0,153,76,155,
+        77,157,78,159,79,161,80,163,81,165,82,167,83,169,84,171,85,173,86,
+        175,87,177,88,179,89,181,90,183,91,1,0,3,3,0,9,10,13,13,32,32,2,
+        0,65,90,97,122,1,0,48,57,949,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,
+        0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,
+        17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,
+        27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,
+        37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,
+        47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,
+        57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,
+        67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,
+        77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0,0,0,0,
+        87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0,0,
+        97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1,0,0,
+        0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0,115,
+        1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0,0,0,
+        0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133,1,
+        0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,
+        143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,0,0,0,0,153,1,0,
+        0,0,0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,
+        1,0,0,0,0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,
+        0,173,1,0,0,0,0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,
+        0,0,0,0,183,1,0,0,0,1,185,1,0,0,0,3,187,1,0,0,0,5,190,1,0,0,0,7,
+        208,1,0,0,0,9,223,1,0,0,0,11,240,1,0,0,0,13,244,1,0,0,0,15,252,1,
+        0,0,0,17,276,1,0,0,0,19,280,1,0,0,0,21,295,1,0,0,0,23,312,1,0,0,
+        0,25,320,1,0,0,0,27,380,1,0,0,0,29,384,1,0,0,0,31,386,1,0,0,0,33,
+        388,1,0,0,0,35,390,1,0,0,0,37,392,1,0,0,0,39,394,1,0,0,0,41,396,
+        1,0,0,0,43,398,1,0,0,0,45,400,1,0,0,0,47,403,1,0,0,0,49,406,1,0,
+        0,0,51,408,1,0,0,0,53,410,1,0,0,0,55,412,1,0,0,0,57,420,1,0,0,0,
+        59,427,1,0,0,0,61,435,1,0,0,0,63,443,1,0,0,0,65,503,1,0,0,0,67,520,
+        1,0,0,0,69,522,1,0,0,0,71,527,1,0,0,0,73,533,1,0,0,0,75,538,1,0,
+        0,0,77,543,1,0,0,0,79,547,1,0,0,0,81,551,1,0,0,0,83,556,1,0,0,0,
+        85,561,1,0,0,0,87,566,1,0,0,0,89,571,1,0,0,0,91,576,1,0,0,0,93,581,
+        1,0,0,0,95,589,1,0,0,0,97,597,1,0,0,0,99,605,1,0,0,0,101,613,1,0,
+        0,0,103,621,1,0,0,0,105,629,1,0,0,0,107,635,1,0,0,0,109,641,1,0,
+        0,0,111,647,1,0,0,0,113,655,1,0,0,0,115,663,1,0,0,0,117,671,1,0,
+        0,0,119,679,1,0,0,0,121,687,1,0,0,0,123,694,1,0,0,0,125,701,1,0,
+        0,0,127,707,1,0,0,0,129,717,1,0,0,0,131,724,1,0,0,0,133,730,1,0,
+        0,0,135,752,1,0,0,0,137,754,1,0,0,0,139,761,1,0,0,0,141,769,1,0,
+        0,0,143,777,1,0,0,0,145,785,1,0,0,0,147,787,1,0,0,0,149,789,1,0,
+        0,0,151,791,1,0,0,0,153,793,1,0,0,0,155,809,1,0,0,0,157,811,1,0,
+        0,0,159,833,1,0,0,0,161,835,1,0,0,0,163,840,1,0,0,0,165,851,1,0,
+        0,0,167,853,1,0,0,0,169,859,1,0,0,0,171,869,1,0,0,0,173,880,1,0,
+        0,0,175,882,1,0,0,0,177,888,1,0,0,0,179,898,1,0,0,0,181,901,1,0,
+        0,0,183,905,1,0,0,0,185,186,5,44,0,0,186,2,1,0,0,0,187,188,5,46,
+        0,0,188,4,1,0,0,0,189,191,7,0,0,0,190,189,1,0,0,0,191,192,1,0,0,
+        0,192,190,1,0,0,0,192,193,1,0,0,0,193,194,1,0,0,0,194,195,6,2,0,
+        0,195,6,1,0,0,0,196,197,5,92,0,0,197,209,5,44,0,0,198,199,5,92,0,
+        0,199,200,5,116,0,0,200,201,5,104,0,0,201,202,5,105,0,0,202,203,
+        5,110,0,0,203,204,5,115,0,0,204,205,5,112,0,0,205,206,5,97,0,0,206,
+        207,5,99,0,0,207,209,5,101,0,0,208,196,1,0,0,0,208,198,1,0,0,0,209,
+        210,1,0,0,0,210,211,6,3,0,0,211,8,1,0,0,0,212,213,5,92,0,0,213,224,
+        5,58,0,0,214,215,5,92,0,0,215,216,5,109,0,0,216,217,5,101,0,0,217,
+        218,5,100,0,0,218,219,5,115,0,0,219,220,5,112,0,0,220,221,5,97,0,
+        0,221,222,5,99,0,0,222,224,5,101,0,0,223,212,1,0,0,0,223,214,1,0,
+        0,0,224,225,1,0,0,0,225,226,6,4,0,0,226,10,1,0,0,0,227,228,5,92,
+        0,0,228,241,5,59,0,0,229,230,5,92,0,0,230,231,5,116,0,0,231,232,
+        5,104,0,0,232,233,5,105,0,0,233,234,5,99,0,0,234,235,5,107,0,0,235,
+        236,5,115,0,0,236,237,5,112,0,0,237,238,5,97,0,0,238,239,5,99,0,
+        0,239,241,5,101,0,0,240,227,1,0,0,0,240,229,1,0,0,0,241,242,1,0,
+        0,0,242,243,6,5,0,0,243,12,1,0,0,0,244,245,5,92,0,0,245,246,5,113,
+        0,0,246,247,5,117,0,0,247,248,5,97,0,0,248,249,5,100,0,0,249,250,
+        1,0,0,0,250,251,6,6,0,0,251,14,1,0,0,0,252,253,5,92,0,0,253,254,
+        5,113,0,0,254,255,5,113,0,0,255,256,5,117,0,0,256,257,5,97,0,0,257,
+        258,5,100,0,0,258,259,1,0,0,0,259,260,6,7,0,0,260,16,1,0,0,0,261,
+        262,5,92,0,0,262,277,5,33,0,0,263,264,5,92,0,0,264,265,5,110,0,0,
+        265,266,5,101,0,0,266,267,5,103,0,0,267,268,5,116,0,0,268,269,5,
+        104,0,0,269,270,5,105,0,0,270,271,5,110,0,0,271,272,5,115,0,0,272,
+        273,5,112,0,0,273,274,5,97,0,0,274,275,5,99,0,0,275,277,5,101,0,
+        0,276,261,1,0,0,0,276,263,1,0,0,0,277,278,1,0,0,0,278,279,6,8,0,
+        0,279,18,1,0,0,0,280,281,5,92,0,0,281,282,5,110,0,0,282,283,5,101,
+        0,0,283,284,5,103,0,0,284,285,5,109,0,0,285,286,5,101,0,0,286,287,
+        5,100,0,0,287,288,5,115,0,0,288,289,5,112,0,0,289,290,5,97,0,0,290,
+        291,5,99,0,0,291,292,5,101,0,0,292,293,1,0,0,0,293,294,6,9,0,0,294,
+        20,1,0,0,0,295,296,5,92,0,0,296,297,5,110,0,0,297,298,5,101,0,0,
+        298,299,5,103,0,0,299,300,5,116,0,0,300,301,5,104,0,0,301,302,5,
+        105,0,0,302,303,5,99,0,0,303,304,5,107,0,0,304,305,5,115,0,0,305,
+        306,5,112,0,0,306,307,5,97,0,0,307,308,5,99,0,0,308,309,5,101,0,
+        0,309,310,1,0,0,0,310,311,6,10,0,0,311,22,1,0,0,0,312,313,5,92,0,
+        0,313,314,5,108,0,0,314,315,5,101,0,0,315,316,5,102,0,0,316,317,
+        5,116,0,0,317,318,1,0,0,0,318,319,6,11,0,0,319,24,1,0,0,0,320,321,
+        5,92,0,0,321,322,5,114,0,0,322,323,5,105,0,0,323,324,5,103,0,0,324,
+        325,5,104,0,0,325,326,5,116,0,0,326,327,1,0,0,0,327,328,6,12,0,0,
+        328,26,1,0,0,0,329,330,5,92,0,0,330,331,5,118,0,0,331,332,5,114,
+        0,0,332,333,5,117,0,0,333,334,5,108,0,0,334,381,5,101,0,0,335,336,
+        5,92,0,0,336,337,5,118,0,0,337,338,5,99,0,0,338,339,5,101,0,0,339,
+        340,5,110,0,0,340,341,5,116,0,0,341,342,5,101,0,0,342,381,5,114,
+        0,0,343,344,5,92,0,0,344,345,5,118,0,0,345,346,5,98,0,0,346,347,
+        5,111,0,0,347,381,5,120,0,0,348,349,5,92,0,0,349,350,5,118,0,0,350,
+        351,5,115,0,0,351,352,5,107,0,0,352,353,5,105,0,0,353,381,5,112,
+        0,0,354,355,5,92,0,0,355,356,5,118,0,0,356,357,5,115,0,0,357,358,
+        5,112,0,0,358,359,5,97,0,0,359,360,5,99,0,0,360,381,5,101,0,0,361,
+        362,5,92,0,0,362,363,5,104,0,0,363,364,5,102,0,0,364,365,5,105,0,
+        0,365,381,5,108,0,0,366,367,5,92,0,0,367,381,5,42,0,0,368,369,5,
+        92,0,0,369,381,5,45,0,0,370,371,5,92,0,0,371,381,5,46,0,0,372,373,
+        5,92,0,0,373,381,5,47,0,0,374,375,5,92,0,0,375,381,5,34,0,0,376,
+        377,5,92,0,0,377,381,5,40,0,0,378,379,5,92,0,0,379,381,5,61,0,0,
+        380,329,1,0,0,0,380,335,1,0,0,0,380,343,1,0,0,0,380,348,1,0,0,0,
+        380,354,1,0,0,0,380,361,1,0,0,0,380,366,1,0,0,0,380,368,1,0,0,0,
+        380,370,1,0,0,0,380,372,1,0,0,0,380,374,1,0,0,0,380,376,1,0,0,0,
+        380,378,1,0,0,0,381,382,1,0,0,0,382,383,6,13,0,0,383,28,1,0,0,0,
+        384,385,5,43,0,0,385,30,1,0,0,0,386,387,5,45,0,0,387,32,1,0,0,0,
+        388,389,5,42,0,0,389,34,1,0,0,0,390,391,5,47,0,0,391,36,1,0,0,0,
+        392,393,5,40,0,0,393,38,1,0,0,0,394,395,5,41,0,0,395,40,1,0,0,0,
+        396,397,5,123,0,0,397,42,1,0,0,0,398,399,5,125,0,0,399,44,1,0,0,
+        0,400,401,5,92,0,0,401,402,5,123,0,0,402,46,1,0,0,0,403,404,5,92,
+        0,0,404,405,5,125,0,0,405,48,1,0,0,0,406,407,5,91,0,0,407,50,1,0,
+        0,0,408,409,5,93,0,0,409,52,1,0,0,0,410,411,5,124,0,0,411,54,1,0,
+        0,0,412,413,5,92,0,0,413,414,5,114,0,0,414,415,5,105,0,0,415,416,
+        5,103,0,0,416,417,5,104,0,0,417,418,5,116,0,0,418,419,5,124,0,0,
+        419,56,1,0,0,0,420,421,5,92,0,0,421,422,5,108,0,0,422,423,5,101,
+        0,0,423,424,5,102,0,0,424,425,5,116,0,0,425,426,5,124,0,0,426,58,
+        1,0,0,0,427,428,5,92,0,0,428,429,5,108,0,0,429,430,5,97,0,0,430,
+        431,5,110,0,0,431,432,5,103,0,0,432,433,5,108,0,0,433,434,5,101,
+        0,0,434,60,1,0,0,0,435,436,5,92,0,0,436,437,5,114,0,0,437,438,5,
+        97,0,0,438,439,5,110,0,0,439,440,5,103,0,0,440,441,5,108,0,0,441,
+        442,5,101,0,0,442,62,1,0,0,0,443,444,5,92,0,0,444,445,5,108,0,0,
+        445,446,5,105,0,0,446,447,5,109,0,0,447,64,1,0,0,0,448,449,5,92,
+        0,0,449,450,5,116,0,0,450,504,5,111,0,0,451,452,5,92,0,0,452,453,
+        5,114,0,0,453,454,5,105,0,0,454,455,5,103,0,0,455,456,5,104,0,0,
+        456,457,5,116,0,0,457,458,5,97,0,0,458,459,5,114,0,0,459,460,5,114,
+        0,0,460,461,5,111,0,0,461,504,5,119,0,0,462,463,5,92,0,0,463,464,
+        5,82,0,0,464,465,5,105,0,0,465,466,5,103,0,0,466,467,5,104,0,0,467,
+        468,5,116,0,0,468,469,5,97,0,0,469,470,5,114,0,0,470,471,5,114,0,
+        0,471,472,5,111,0,0,472,504,5,119,0,0,473,474,5,92,0,0,474,475,5,
+        108,0,0,475,476,5,111,0,0,476,477,5,110,0,0,477,478,5,103,0,0,478,
+        479,5,114,0,0,479,480,5,105,0,0,480,481,5,103,0,0,481,482,5,104,
+        0,0,482,483,5,116,0,0,483,484,5,97,0,0,484,485,5,114,0,0,485,486,
+        5,114,0,0,486,487,5,111,0,0,487,504,5,119,0,0,488,489,5,92,0,0,489,
+        490,5,76,0,0,490,491,5,111,0,0,491,492,5,110,0,0,492,493,5,103,0,
+        0,493,494,5,114,0,0,494,495,5,105,0,0,495,496,5,103,0,0,496,497,
+        5,104,0,0,497,498,5,116,0,0,498,499,5,97,0,0,499,500,5,114,0,0,500,
+        501,5,114,0,0,501,502,5,111,0,0,502,504,5,119,0,0,503,448,1,0,0,
+        0,503,451,1,0,0,0,503,462,1,0,0,0,503,473,1,0,0,0,503,488,1,0,0,
+        0,504,66,1,0,0,0,505,506,5,92,0,0,506,507,5,105,0,0,507,508,5,110,
+        0,0,508,521,5,116,0,0,509,510,5,92,0,0,510,511,5,105,0,0,511,512,
+        5,110,0,0,512,513,5,116,0,0,513,514,5,92,0,0,514,515,5,108,0,0,515,
+        516,5,105,0,0,516,517,5,109,0,0,517,518,5,105,0,0,518,519,5,116,
+        0,0,519,521,5,115,0,0,520,505,1,0,0,0,520,509,1,0,0,0,521,68,1,0,
+        0,0,522,523,5,92,0,0,523,524,5,115,0,0,524,525,5,117,0,0,525,526,
+        5,109,0,0,526,70,1,0,0,0,527,528,5,92,0,0,528,529,5,112,0,0,529,
+        530,5,114,0,0,530,531,5,111,0,0,531,532,5,100,0,0,532,72,1,0,0,0,
+        533,534,5,92,0,0,534,535,5,101,0,0,535,536,5,120,0,0,536,537,5,112,
+        0,0,537,74,1,0,0,0,538,539,5,92,0,0,539,540,5,108,0,0,540,541,5,
+        111,0,0,541,542,5,103,0,0,542,76,1,0,0,0,543,544,5,92,0,0,544,545,
+        5,108,0,0,545,546,5,103,0,0,546,78,1,0,0,0,547,548,5,92,0,0,548,
+        549,5,108,0,0,549,550,5,110,0,0,550,80,1,0,0,0,551,552,5,92,0,0,
+        552,553,5,115,0,0,553,554,5,105,0,0,554,555,5,110,0,0,555,82,1,0,
+        0,0,556,557,5,92,0,0,557,558,5,99,0,0,558,559,5,111,0,0,559,560,
+        5,115,0,0,560,84,1,0,0,0,561,562,5,92,0,0,562,563,5,116,0,0,563,
+        564,5,97,0,0,564,565,5,110,0,0,565,86,1,0,0,0,566,567,5,92,0,0,567,
+        568,5,99,0,0,568,569,5,115,0,0,569,570,5,99,0,0,570,88,1,0,0,0,571,
+        572,5,92,0,0,572,573,5,115,0,0,573,574,5,101,0,0,574,575,5,99,0,
+        0,575,90,1,0,0,0,576,577,5,92,0,0,577,578,5,99,0,0,578,579,5,111,
+        0,0,579,580,5,116,0,0,580,92,1,0,0,0,581,582,5,92,0,0,582,583,5,
+        97,0,0,583,584,5,114,0,0,584,585,5,99,0,0,585,586,5,115,0,0,586,
+        587,5,105,0,0,587,588,5,110,0,0,588,94,1,0,0,0,589,590,5,92,0,0,
+        590,591,5,97,0,0,591,592,5,114,0,0,592,593,5,99,0,0,593,594,5,99,
+        0,0,594,595,5,111,0,0,595,596,5,115,0,0,596,96,1,0,0,0,597,598,5,
+        92,0,0,598,599,5,97,0,0,599,600,5,114,0,0,600,601,5,99,0,0,601,602,
+        5,116,0,0,602,603,5,97,0,0,603,604,5,110,0,0,604,98,1,0,0,0,605,
+        606,5,92,0,0,606,607,5,97,0,0,607,608,5,114,0,0,608,609,5,99,0,0,
+        609,610,5,99,0,0,610,611,5,115,0,0,611,612,5,99,0,0,612,100,1,0,
+        0,0,613,614,5,92,0,0,614,615,5,97,0,0,615,616,5,114,0,0,616,617,
+        5,99,0,0,617,618,5,115,0,0,618,619,5,101,0,0,619,620,5,99,0,0,620,
+        102,1,0,0,0,621,622,5,92,0,0,622,623,5,97,0,0,623,624,5,114,0,0,
+        624,625,5,99,0,0,625,626,5,99,0,0,626,627,5,111,0,0,627,628,5,116,
+        0,0,628,104,1,0,0,0,629,630,5,92,0,0,630,631,5,115,0,0,631,632,5,
+        105,0,0,632,633,5,110,0,0,633,634,5,104,0,0,634,106,1,0,0,0,635,
+        636,5,92,0,0,636,637,5,99,0,0,637,638,5,111,0,0,638,639,5,115,0,
+        0,639,640,5,104,0,0,640,108,1,0,0,0,641,642,5,92,0,0,642,643,5,116,
+        0,0,643,644,5,97,0,0,644,645,5,110,0,0,645,646,5,104,0,0,646,110,
+        1,0,0,0,647,648,5,92,0,0,648,649,5,97,0,0,649,650,5,114,0,0,650,
+        651,5,115,0,0,651,652,5,105,0,0,652,653,5,110,0,0,653,654,5,104,
+        0,0,654,112,1,0,0,0,655,656,5,92,0,0,656,657,5,97,0,0,657,658,5,
+        114,0,0,658,659,5,99,0,0,659,660,5,111,0,0,660,661,5,115,0,0,661,
+        662,5,104,0,0,662,114,1,0,0,0,663,664,5,92,0,0,664,665,5,97,0,0,
+        665,666,5,114,0,0,666,667,5,116,0,0,667,668,5,97,0,0,668,669,5,110,
+        0,0,669,670,5,104,0,0,670,116,1,0,0,0,671,672,5,92,0,0,672,673,5,
+        108,0,0,673,674,5,102,0,0,674,675,5,108,0,0,675,676,5,111,0,0,676,
+        677,5,111,0,0,677,678,5,114,0,0,678,118,1,0,0,0,679,680,5,92,0,0,
+        680,681,5,114,0,0,681,682,5,102,0,0,682,683,5,108,0,0,683,684,5,
+        111,0,0,684,685,5,111,0,0,685,686,5,114,0,0,686,120,1,0,0,0,687,
+        688,5,92,0,0,688,689,5,108,0,0,689,690,5,99,0,0,690,691,5,101,0,
+        0,691,692,5,105,0,0,692,693,5,108,0,0,693,122,1,0,0,0,694,695,5,
+        92,0,0,695,696,5,114,0,0,696,697,5,99,0,0,697,698,5,101,0,0,698,
+        699,5,105,0,0,699,700,5,108,0,0,700,124,1,0,0,0,701,702,5,92,0,0,
+        702,703,5,115,0,0,703,704,5,113,0,0,704,705,5,114,0,0,705,706,5,
+        116,0,0,706,126,1,0,0,0,707,708,5,92,0,0,708,709,5,111,0,0,709,710,
+        5,118,0,0,710,711,5,101,0,0,711,712,5,114,0,0,712,713,5,108,0,0,
+        713,714,5,105,0,0,714,715,5,110,0,0,715,716,5,101,0,0,716,128,1,
+        0,0,0,717,718,5,92,0,0,718,719,5,116,0,0,719,720,5,105,0,0,720,721,
+        5,109,0,0,721,722,5,101,0,0,722,723,5,115,0,0,723,130,1,0,0,0,724,
+        725,5,92,0,0,725,726,5,99,0,0,726,727,5,100,0,0,727,728,5,111,0,
+        0,728,729,5,116,0,0,729,132,1,0,0,0,730,731,5,92,0,0,731,732,5,100,
+        0,0,732,733,5,105,0,0,733,734,5,118,0,0,734,134,1,0,0,0,735,736,
+        5,92,0,0,736,737,5,102,0,0,737,738,5,114,0,0,738,739,5,97,0,0,739,
+        753,5,99,0,0,740,741,5,92,0,0,741,742,5,100,0,0,742,743,5,102,0,
+        0,743,744,5,114,0,0,744,745,5,97,0,0,745,753,5,99,0,0,746,747,5,
+        92,0,0,747,748,5,116,0,0,748,749,5,102,0,0,749,750,5,114,0,0,750,
+        751,5,97,0,0,751,753,5,99,0,0,752,735,1,0,0,0,752,740,1,0,0,0,752,
+        746,1,0,0,0,753,136,1,0,0,0,754,755,5,92,0,0,755,756,5,98,0,0,756,
+        757,5,105,0,0,757,758,5,110,0,0,758,759,5,111,0,0,759,760,5,109,
+        0,0,760,138,1,0,0,0,761,762,5,92,0,0,762,763,5,100,0,0,763,764,5,
+        98,0,0,764,765,5,105,0,0,765,766,5,110,0,0,766,767,5,111,0,0,767,
+        768,5,109,0,0,768,140,1,0,0,0,769,770,5,92,0,0,770,771,5,116,0,0,
+        771,772,5,98,0,0,772,773,5,105,0,0,773,774,5,110,0,0,774,775,5,111,
+        0,0,775,776,5,109,0,0,776,142,1,0,0,0,777,778,5,92,0,0,778,779,5,
+        109,0,0,779,780,5,97,0,0,780,781,5,116,0,0,781,782,5,104,0,0,782,
+        783,5,105,0,0,783,784,5,116,0,0,784,144,1,0,0,0,785,786,5,95,0,0,
+        786,146,1,0,0,0,787,788,5,94,0,0,788,148,1,0,0,0,789,790,5,58,0,
+        0,790,150,1,0,0,0,791,792,7,0,0,0,792,152,1,0,0,0,793,797,5,100,
+        0,0,794,796,3,151,75,0,795,794,1,0,0,0,796,799,1,0,0,0,797,798,1,
+        0,0,0,797,795,1,0,0,0,798,807,1,0,0,0,799,797,1,0,0,0,800,808,7,
+        1,0,0,801,803,5,92,0,0,802,804,7,1,0,0,803,802,1,0,0,0,804,805,1,
+        0,0,0,805,803,1,0,0,0,805,806,1,0,0,0,806,808,1,0,0,0,807,800,1,
+        0,0,0,807,801,1,0,0,0,808,154,1,0,0,0,809,810,7,1,0,0,810,156,1,
+        0,0,0,811,812,7,2,0,0,812,158,1,0,0,0,813,817,5,38,0,0,814,816,3,
+        151,75,0,815,814,1,0,0,0,816,819,1,0,0,0,817,818,1,0,0,0,817,815,
+        1,0,0,0,818,821,1,0,0,0,819,817,1,0,0,0,820,813,1,0,0,0,820,821,
+        1,0,0,0,821,822,1,0,0,0,822,834,5,61,0,0,823,831,5,61,0,0,824,826,
+        3,151,75,0,825,824,1,0,0,0,826,829,1,0,0,0,827,828,1,0,0,0,827,825,
+        1,0,0,0,828,830,1,0,0,0,829,827,1,0,0,0,830,832,5,38,0,0,831,827,
+        1,0,0,0,831,832,1,0,0,0,832,834,1,0,0,0,833,820,1,0,0,0,833,823,
+        1,0,0,0,834,160,1,0,0,0,835,836,5,92,0,0,836,837,5,110,0,0,837,838,
+        5,101,0,0,838,839,5,113,0,0,839,162,1,0,0,0,840,841,5,60,0,0,841,
+        164,1,0,0,0,842,843,5,92,0,0,843,844,5,108,0,0,844,845,5,101,0,0,
+        845,852,5,113,0,0,846,847,5,92,0,0,847,848,5,108,0,0,848,852,5,101,
+        0,0,849,852,3,167,83,0,850,852,3,169,84,0,851,842,1,0,0,0,851,846,
+        1,0,0,0,851,849,1,0,0,0,851,850,1,0,0,0,852,166,1,0,0,0,853,854,
+        5,92,0,0,854,855,5,108,0,0,855,856,5,101,0,0,856,857,5,113,0,0,857,
+        858,5,113,0,0,858,168,1,0,0,0,859,860,5,92,0,0,860,861,5,108,0,0,
+        861,862,5,101,0,0,862,863,5,113,0,0,863,864,5,115,0,0,864,865,5,
+        108,0,0,865,866,5,97,0,0,866,867,5,110,0,0,867,868,5,116,0,0,868,
+        170,1,0,0,0,869,870,5,62,0,0,870,172,1,0,0,0,871,872,5,92,0,0,872,
+        873,5,103,0,0,873,874,5,101,0,0,874,881,5,113,0,0,875,876,5,92,0,
+        0,876,877,5,103,0,0,877,881,5,101,0,0,878,881,3,175,87,0,879,881,
+        3,177,88,0,880,871,1,0,0,0,880,875,1,0,0,0,880,878,1,0,0,0,880,879,
+        1,0,0,0,881,174,1,0,0,0,882,883,5,92,0,0,883,884,5,103,0,0,884,885,
+        5,101,0,0,885,886,5,113,0,0,886,887,5,113,0,0,887,176,1,0,0,0,888,
+        889,5,92,0,0,889,890,5,103,0,0,890,891,5,101,0,0,891,892,5,113,0,
+        0,892,893,5,115,0,0,893,894,5,108,0,0,894,895,5,97,0,0,895,896,5,
+        110,0,0,896,897,5,116,0,0,897,178,1,0,0,0,898,899,5,33,0,0,899,180,
+        1,0,0,0,900,902,5,39,0,0,901,900,1,0,0,0,902,903,1,0,0,0,903,901,
+        1,0,0,0,903,904,1,0,0,0,904,182,1,0,0,0,905,907,5,92,0,0,906,908,
+        7,1,0,0,907,906,1,0,0,0,908,909,1,0,0,0,909,907,1,0,0,0,909,910,
+        1,0,0,0,910,184,1,0,0,0,22,0,192,208,223,240,276,380,503,520,752,
+        797,805,807,817,820,827,831,833,851,880,903,909,1,6,0,0
+    ]
+
+class LaTeXLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    T__0 = 1
+    T__1 = 2
+    WS = 3
+    THINSPACE = 4
+    MEDSPACE = 5
+    THICKSPACE = 6
+    QUAD = 7
+    QQUAD = 8
+    NEGTHINSPACE = 9
+    NEGMEDSPACE = 10
+    NEGTHICKSPACE = 11
+    CMD_LEFT = 12
+    CMD_RIGHT = 13
+    IGNORE = 14
+    ADD = 15
+    SUB = 16
+    MUL = 17
+    DIV = 18
+    L_PAREN = 19
+    R_PAREN = 20
+    L_BRACE = 21
+    R_BRACE = 22
+    L_BRACE_LITERAL = 23
+    R_BRACE_LITERAL = 24
+    L_BRACKET = 25
+    R_BRACKET = 26
+    BAR = 27
+    R_BAR = 28
+    L_BAR = 29
+    L_ANGLE = 30
+    R_ANGLE = 31
+    FUNC_LIM = 32
+    LIM_APPROACH_SYM = 33
+    FUNC_INT = 34
+    FUNC_SUM = 35
+    FUNC_PROD = 36
+    FUNC_EXP = 37
+    FUNC_LOG = 38
+    FUNC_LG = 39
+    FUNC_LN = 40
+    FUNC_SIN = 41
+    FUNC_COS = 42
+    FUNC_TAN = 43
+    FUNC_CSC = 44
+    FUNC_SEC = 45
+    FUNC_COT = 46
+    FUNC_ARCSIN = 47
+    FUNC_ARCCOS = 48
+    FUNC_ARCTAN = 49
+    FUNC_ARCCSC = 50
+    FUNC_ARCSEC = 51
+    FUNC_ARCCOT = 52
+    FUNC_SINH = 53
+    FUNC_COSH = 54
+    FUNC_TANH = 55
+    FUNC_ARSINH = 56
+    FUNC_ARCOSH = 57
+    FUNC_ARTANH = 58
+    L_FLOOR = 59
+    R_FLOOR = 60
+    L_CEIL = 61
+    R_CEIL = 62
+    FUNC_SQRT = 63
+    FUNC_OVERLINE = 64
+    CMD_TIMES = 65
+    CMD_CDOT = 66
+    CMD_DIV = 67
+    CMD_FRAC = 68
+    CMD_BINOM = 69
+    CMD_DBINOM = 70
+    CMD_TBINOM = 71
+    CMD_MATHIT = 72
+    UNDERSCORE = 73
+    CARET = 74
+    COLON = 75
+    DIFFERENTIAL = 76
+    LETTER = 77
+    DIGIT = 78
+    EQUAL = 79
+    NEQ = 80
+    LT = 81
+    LTE = 82
+    LTE_Q = 83
+    LTE_S = 84
+    GT = 85
+    GTE = 86
+    GTE_Q = 87
+    GTE_S = 88
+    BANG = 89
+    SINGLE_QUOTES = 90
+    SYMBOL = 91
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "','", "'.'", "'\\quad'", "'\\qquad'", "'\\negmedspace'", "'\\negthickspace'",
+            "'\\left'", "'\\right'", "'+'", "'-'", "'*'", "'/'", "'('",
+            "')'", "'{'", "'}'", "'\\{'", "'\\}'", "'['", "']'", "'|'",
+            "'\\right|'", "'\\left|'", "'\\langle'", "'\\rangle'", "'\\lim'",
+            "'\\sum'", "'\\prod'", "'\\exp'", "'\\log'", "'\\lg'", "'\\ln'",
+            "'\\sin'", "'\\cos'", "'\\tan'", "'\\csc'", "'\\sec'", "'\\cot'",
+            "'\\arcsin'", "'\\arccos'", "'\\arctan'", "'\\arccsc'", "'\\arcsec'",
+            "'\\arccot'", "'\\sinh'", "'\\cosh'", "'\\tanh'", "'\\arsinh'",
+            "'\\arcosh'", "'\\artanh'", "'\\lfloor'", "'\\rfloor'", "'\\lceil'",
+            "'\\rceil'", "'\\sqrt'", "'\\overline'", "'\\times'", "'\\cdot'",
+            "'\\div'", "'\\binom'", "'\\dbinom'", "'\\tbinom'", "'\\mathit'",
+            "'_'", "'^'", "':'", "'\\neq'", "'<'", "'\\leqq'", "'\\leqslant'",
+            "'>'", "'\\geqq'", "'\\geqslant'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "WS", "THINSPACE", "MEDSPACE", "THICKSPACE", "QUAD", "QQUAD",
+            "NEGTHINSPACE", "NEGMEDSPACE", "NEGTHICKSPACE", "CMD_LEFT",
+            "CMD_RIGHT", "IGNORE", "ADD", "SUB", "MUL", "DIV", "L_PAREN",
+            "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACE_LITERAL", "R_BRACE_LITERAL",
+            "L_BRACKET", "R_BRACKET", "BAR", "R_BAR", "L_BAR", "L_ANGLE",
+            "R_ANGLE", "FUNC_LIM", "LIM_APPROACH_SYM", "FUNC_INT", "FUNC_SUM",
+            "FUNC_PROD", "FUNC_EXP", "FUNC_LOG", "FUNC_LG", "FUNC_LN", "FUNC_SIN",
+            "FUNC_COS", "FUNC_TAN", "FUNC_CSC", "FUNC_SEC", "FUNC_COT",
+            "FUNC_ARCSIN", "FUNC_ARCCOS", "FUNC_ARCTAN", "FUNC_ARCCSC",
+            "FUNC_ARCSEC", "FUNC_ARCCOT", "FUNC_SINH", "FUNC_COSH", "FUNC_TANH",
+            "FUNC_ARSINH", "FUNC_ARCOSH", "FUNC_ARTANH", "L_FLOOR", "R_FLOOR",
+            "L_CEIL", "R_CEIL", "FUNC_SQRT", "FUNC_OVERLINE", "CMD_TIMES",
+            "CMD_CDOT", "CMD_DIV", "CMD_FRAC", "CMD_BINOM", "CMD_DBINOM",
+            "CMD_TBINOM", "CMD_MATHIT", "UNDERSCORE", "CARET", "COLON",
+            "DIFFERENTIAL", "LETTER", "DIGIT", "EQUAL", "NEQ", "LT", "LTE",
+            "LTE_Q", "LTE_S", "GT", "GTE", "GTE_Q", "GTE_S", "BANG", "SINGLE_QUOTES",
+            "SYMBOL" ]
+
+    ruleNames = [ "T__0", "T__1", "WS", "THINSPACE", "MEDSPACE", "THICKSPACE",
+                  "QUAD", "QQUAD", "NEGTHINSPACE", "NEGMEDSPACE", "NEGTHICKSPACE",
+                  "CMD_LEFT", "CMD_RIGHT", "IGNORE", "ADD", "SUB", "MUL",
+                  "DIV", "L_PAREN", "R_PAREN", "L_BRACE", "R_BRACE", "L_BRACE_LITERAL",
+                  "R_BRACE_LITERAL", "L_BRACKET", "R_BRACKET", "BAR", "R_BAR",
+                  "L_BAR", "L_ANGLE", "R_ANGLE", "FUNC_LIM", "LIM_APPROACH_SYM",
+                  "FUNC_INT", "FUNC_SUM", "FUNC_PROD", "FUNC_EXP", "FUNC_LOG",
+                  "FUNC_LG", "FUNC_LN", "FUNC_SIN", "FUNC_COS", "FUNC_TAN",
+                  "FUNC_CSC", "FUNC_SEC", "FUNC_COT", "FUNC_ARCSIN", "FUNC_ARCCOS",
+                  "FUNC_ARCTAN", "FUNC_ARCCSC", "FUNC_ARCSEC", "FUNC_ARCCOT",
+                  "FUNC_SINH", "FUNC_COSH", "FUNC_TANH", "FUNC_ARSINH",
+                  "FUNC_ARCOSH", "FUNC_ARTANH", "L_FLOOR", "R_FLOOR", "L_CEIL",
+                  "R_CEIL", "FUNC_SQRT", "FUNC_OVERLINE", "CMD_TIMES", "CMD_CDOT",
+                  "CMD_DIV", "CMD_FRAC", "CMD_BINOM", "CMD_DBINOM", "CMD_TBINOM",
+                  "CMD_MATHIT", "UNDERSCORE", "CARET", "COLON", "WS_CHAR",
+                  "DIFFERENTIAL", "LETTER", "DIGIT", "EQUAL", "NEQ", "LT",
+                  "LTE", "LTE_Q", "LTE_S", "GT", "GTE", "GTE_Q", "GTE_S",
+                  "BANG", "SINGLE_QUOTES", "SYMBOL" ]
+
+    grammarFileName = "LaTeX.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/_build_latex_antlr.py

@@ -0,0 +1,91 @@
+import os
+import subprocess
+import glob
+
+from sympy.utilities.misc import debug
+
+here = os.path.dirname(__file__)
+grammar_file = os.path.abspath(os.path.join(here, "LaTeX.g4"))
+dir_latex_antlr = os.path.join(here, "_antlr")
+
+header = '''\
+# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND ***
+#
+# Generated from ../LaTeX.g4, derived from latex2sympy
+#     latex2sympy is licensed under the MIT license
+#     https://github.com/augustt198/latex2sympy/blob/master/LICENSE.txt
+#
+# Generated with antlr4
+#    antlr4 is licensed under the BSD-3-Clause License
+#    https://github.com/antlr/antlr4/blob/master/LICENSE.txt
+'''
+
+
+def check_antlr_version():
+    debug("Checking antlr4 version...")
+
+    try:
+        debug(subprocess.check_output(["antlr4"])
+              .decode('utf-8').split("\n")[0])
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        debug("The 'antlr4' command line tool is not installed, "
+              "or not on your PATH.\n"
+              "> Please refer to the README.md file for more information.")
+        return False
+
+
+def build_parser(output_dir=dir_latex_antlr):
+    check_antlr_version()
+
+    debug("Updating ANTLR-generated code in {}".format(output_dir))
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with open(os.path.join(output_dir, "__init__.py"), "w+") as fp:
+        fp.write(header)
+
+    args = [
+        "antlr4",
+        grammar_file,
+        "-o", output_dir,
+        # for now, not generating these as latex2sympy did not use them
+        "-no-visitor",
+        "-no-listener",
+    ]
+
+    debug("Running code generation...\n\t$ {}".format(" ".join(args)))
+    subprocess.check_output(args, cwd=output_dir)
+
+    debug("Applying headers, removing unnecessary files and renaming...")
+    # Handle case insensitive file systems. If the files are already
+    # generated, they will be written to latex* but LaTeX*.* won't match them.
+    for path in (glob.glob(os.path.join(output_dir, "LaTeX*.*")) or
+        glob.glob(os.path.join(output_dir, "latex*.*"))):
+
+        # Remove files ending in .interp or .tokens as they are not needed.
+        if not path.endswith(".py"):
+            os.unlink(path)
+            continue
+
+        new_path = os.path.join(output_dir, os.path.basename(path).lower())
+        with open(path, 'r') as f:
+            lines = [line.rstrip() + '\n' for line in f.readlines()]
+
+        os.unlink(path)
+
+        with open(new_path, "w") as out_file:
+            offset = 0
+            while lines[offset].startswith('#'):
+                offset += 1
+            out_file.write(header)
+            out_file.writelines(lines[offset:])
+
+        debug("\t{}".format(new_path))
+
+    return True
+
+
+if __name__ == "__main__":
+    build_parser()

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/_parse_latex_antlr.py

@@ -0,0 +1,604 @@
+# Ported from latex2sympy by @augustt198
+# https://github.com/augustt198/latex2sympy
+# See license in LICENSE.txt
+from importlib.metadata import version
+import sympy
+from sympy.external import import_module
+from sympy.printing.str import StrPrinter
+from sympy.physics.quantum.state import Bra, Ket
+
+from .errors import LaTeXParsingError
+
+
+LaTeXParser = LaTeXLexer = MathErrorListener = None
+
+try:
+    LaTeXParser = import_module('sympy.parsing.latex._antlr.latexparser',
+                                import_kwargs={'fromlist': ['LaTeXParser']}).LaTeXParser
+    LaTeXLexer = import_module('sympy.parsing.latex._antlr.latexlexer',
+                               import_kwargs={'fromlist': ['LaTeXLexer']}).LaTeXLexer
+except Exception:
+    pass
+
+ErrorListener = import_module('antlr4.error.ErrorListener',
+                              warn_not_installed=True,
+                              import_kwargs={'fromlist': ['ErrorListener']}
+                              )
+
+
+
+if ErrorListener:
+    class MathErrorListener(ErrorListener.ErrorListener):  # type: ignore
+        def __init__(self, src):
+            super(ErrorListener.ErrorListener, self).__init__()
+            self.src = src
+
+        def syntaxError(self, recog, symbol, line, col, msg, e):
+            fmt = "%s\n%s\n%s"
+            marker = "~" * col + "^"
+
+            if msg.startswith("missing"):
+                err = fmt % (msg, self.src, marker)
+            elif msg.startswith("no viable"):
+                err = fmt % ("I expected something else here", self.src, marker)
+            elif msg.startswith("mismatched"):
+                names = LaTeXParser.literalNames
+                expected = [
+                    names[i] for i in e.getExpectedTokens() if i < len(names)
+                ]
+                if len(expected) < 10:
+                    expected = " ".join(expected)
+                    err = (fmt % ("I expected one of these: " + expected, self.src,
+                                  marker))
+                else:
+                    err = (fmt % ("I expected something else here", self.src,
+                                  marker))
+            else:
+                err = fmt % ("I don't understand this", self.src, marker)
+            raise LaTeXParsingError(err)
+
+
+def parse_latex(sympy):
+    antlr4 = import_module('antlr4')
+
+    if None in [antlr4, MathErrorListener] or \
+            not version('antlr4-python3-runtime').startswith('4.11'):
+        raise ImportError("LaTeX parsing requires the antlr4 Python package,"
+                          " provided by pip (antlr4-python3-runtime) or"
+                          " conda (antlr-python-runtime), version 4.11")
+
+    matherror = MathErrorListener(sympy)
+
+    stream = antlr4.InputStream(sympy)
+    lex = LaTeXLexer(stream)
+    lex.removeErrorListeners()
+    lex.addErrorListener(matherror)
+
+    tokens = antlr4.CommonTokenStream(lex)
+    parser = LaTeXParser(tokens)
+
+    # remove default console error listener
+    parser.removeErrorListeners()
+    parser.addErrorListener(matherror)
+
+    relation = parser.math().relation()
+    expr = convert_relation(relation)
+
+    return expr
+
+
+def convert_relation(rel):
+    if rel.expr():
+        return convert_expr(rel.expr())
+
+    lh = convert_relation(rel.relation(0))
+    rh = convert_relation(rel.relation(1))
+    if rel.LT():
+        return sympy.StrictLessThan(lh, rh)
+    elif rel.LTE():
+        return sympy.LessThan(lh, rh)
+    elif rel.GT():
+        return sympy.StrictGreaterThan(lh, rh)
+    elif rel.GTE():
+        return sympy.GreaterThan(lh, rh)
+    elif rel.EQUAL():
+        return sympy.Eq(lh, rh)
+    elif rel.NEQ():
+        return sympy.Ne(lh, rh)
+
+
+def convert_expr(expr):
+    return convert_add(expr.additive())
+
+
+def convert_add(add):
+    if add.ADD():
+        lh = convert_add(add.additive(0))
+        rh = convert_add(add.additive(1))
+        return sympy.Add(lh, rh, evaluate=False)
+    elif add.SUB():
+        lh = convert_add(add.additive(0))
+        rh = convert_add(add.additive(1))
+        if hasattr(rh, "is_Atom") and rh.is_Atom:
+            return sympy.Add(lh, -1 * rh, evaluate=False)
+        return sympy.Add(lh, sympy.Mul(-1, rh, evaluate=False), evaluate=False)
+    else:
+        return convert_mp(add.mp())
+
+
+def convert_mp(mp):
+    if hasattr(mp, 'mp'):
+        mp_left = mp.mp(0)
+        mp_right = mp.mp(1)
+    else:
+        mp_left = mp.mp_nofunc(0)
+        mp_right = mp.mp_nofunc(1)
+
+    if mp.MUL() or mp.CMD_TIMES() or mp.CMD_CDOT():
+        lh = convert_mp(mp_left)
+        rh = convert_mp(mp_right)
+        return sympy.Mul(lh, rh, evaluate=False)
+    elif mp.DIV() or mp.CMD_DIV() or mp.COLON():
+        lh = convert_mp(mp_left)
+        rh = convert_mp(mp_right)
+        return sympy.Mul(lh, sympy.Pow(rh, -1, evaluate=False), evaluate=False)
+    else:
+        if hasattr(mp, 'unary'):
+            return convert_unary(mp.unary())
+        else:
+            return convert_unary(mp.unary_nofunc())
+
+
+def convert_unary(unary):
+    if hasattr(unary, 'unary'):
+        nested_unary = unary.unary()
+    else:
+        nested_unary = unary.unary_nofunc()
+    if hasattr(unary, 'postfix_nofunc'):
+        first = unary.postfix()
+        tail = unary.postfix_nofunc()
+        postfix = [first] + tail
+    else:
+        postfix = unary.postfix()
+
+    if unary.ADD():
+        return convert_unary(nested_unary)
+    elif unary.SUB():
+        numabs = convert_unary(nested_unary)
+        # Use Integer(-n) instead of Mul(-1, n)
+        return -numabs
+    elif postfix:
+        return convert_postfix_list(postfix)
+
+
+def convert_postfix_list(arr, i=0):
+    if i >= len(arr):
+        raise LaTeXParsingError("Index out of bounds")
+
+    res = convert_postfix(arr[i])
+    if isinstance(res, sympy.Expr):
+        if i == len(arr) - 1:
+            return res  # nothing to multiply by
+        else:
+            if i > 0:
+                left = convert_postfix(arr[i - 1])
+                right = convert_postfix(arr[i + 1])
+                if isinstance(left, sympy.Expr) and isinstance(
+                        right, sympy.Expr):
+                    left_syms = convert_postfix(arr[i - 1]).atoms(sympy.Symbol)
+                    right_syms = convert_postfix(arr[i + 1]).atoms(
+                        sympy.Symbol)
+                    # if the left and right sides contain no variables and the
+                    # symbol in between is 'x', treat as multiplication.
+                    if not (left_syms or right_syms) and str(res) == 'x':
+                        return convert_postfix_list(arr, i + 1)
+            # multiply by next
+            return sympy.Mul(
+                res, convert_postfix_list(arr, i + 1), evaluate=False)
+    else:  # must be derivative
+        wrt = res[0]
+        if i == len(arr) - 1:
+            raise LaTeXParsingError("Expected expression for derivative")
+        else:
+            expr = convert_postfix_list(arr, i + 1)
+            return sympy.Derivative(expr, wrt)
+
+
+def do_subs(expr, at):
+    if at.expr():
+        at_expr = convert_expr(at.expr())
+        syms = at_expr.atoms(sympy.Symbol)
+        if len(syms) == 0:
+            return expr
+        elif len(syms) > 0:
+            sym = next(iter(syms))
+            return expr.subs(sym, at_expr)
+    elif at.equality():
+        lh = convert_expr(at.equality().expr(0))
+        rh = convert_expr(at.equality().expr(1))
+        return expr.subs(lh, rh)
+
+
+def convert_postfix(postfix):
+    if hasattr(postfix, 'exp'):
+        exp_nested = postfix.exp()
+    else:
+        exp_nested = postfix.exp_nofunc()
+
+    exp = convert_exp(exp_nested)
+    for op in postfix.postfix_op():
+        if op.BANG():
+            if isinstance(exp, list):
+                raise LaTeXParsingError("Cannot apply postfix to derivative")
+            exp = sympy.factorial(exp, evaluate=False)
+        elif op.eval_at():
+            ev = op.eval_at()
+            at_b = None
+            at_a = None
+            if ev.eval_at_sup():
+                at_b = do_subs(exp, ev.eval_at_sup())
+            if ev.eval_at_sub():
+                at_a = do_subs(exp, ev.eval_at_sub())
+            if at_b is not None and at_a is not None:
+                exp = sympy.Add(at_b, -1 * at_a, evaluate=False)
+            elif at_b is not None:
+                exp = at_b
+            elif at_a is not None:
+                exp = at_a
+
+    return exp
+
+
+def convert_exp(exp):
+    if hasattr(exp, 'exp'):
+        exp_nested = exp.exp()
+    else:
+        exp_nested = exp.exp_nofunc()
+
+    if exp_nested:
+        base = convert_exp(exp_nested)
+        if isinstance(base, list):
+            raise LaTeXParsingError("Cannot raise derivative to power")
+        if exp.atom():
+            exponent = convert_atom(exp.atom())
+        elif exp.expr():
+            exponent = convert_expr(exp.expr())
+        return sympy.Pow(base, exponent, evaluate=False)
+    else:
+        if hasattr(exp, 'comp'):
+            return convert_comp(exp.comp())
+        else:
+            return convert_comp(exp.comp_nofunc())
+
+
+def convert_comp(comp):
+    if comp.group():
+        return convert_expr(comp.group().expr())
+    elif comp.abs_group():
+        return sympy.Abs(convert_expr(comp.abs_group().expr()), evaluate=False)
+    elif comp.atom():
+        return convert_atom(comp.atom())
+    elif comp.floor():
+        return convert_floor(comp.floor())
+    elif comp.ceil():
+        return convert_ceil(comp.ceil())
+    elif comp.func():
+        return convert_func(comp.func())
+
+
+def convert_atom(atom):
+    if atom.LETTER():
+        sname = atom.LETTER().getText()
+        if atom.subexpr():
+            if atom.subexpr().expr():  # subscript is expr
+                subscript = convert_expr(atom.subexpr().expr())
+            else:  # subscript is atom
+                subscript = convert_atom(atom.subexpr().atom())
+            sname += '_{' + StrPrinter().doprint(subscript) + '}'
+        if atom.SINGLE_QUOTES():
+            sname += atom.SINGLE_QUOTES().getText()  # put after subscript for easy identify
+        return sympy.Symbol(sname)
+    elif atom.SYMBOL():
+        s = atom.SYMBOL().getText()[1:]
+        if s == "infty":
+            return sympy.oo
+        else:
+            if atom.subexpr():
+                subscript = None
+                if atom.subexpr().expr():  # subscript is expr
+                    subscript = convert_expr(atom.subexpr().expr())
+                else:  # subscript is atom
+                    subscript = convert_atom(atom.subexpr().atom())
+                subscriptName = StrPrinter().doprint(subscript)
+                s += '_{' + subscriptName + '}'
+            return sympy.Symbol(s)
+    elif atom.number():
+        s = atom.number().getText().replace(",", "")
+        return sympy.Number(s)
+    elif atom.DIFFERENTIAL():
+        var = get_differential_var(atom.DIFFERENTIAL())
+        return sympy.Symbol('d' + var.name)
+    elif atom.mathit():
+        text = rule2text(atom.mathit().mathit_text())
+        return sympy.Symbol(text)
+    elif atom.frac():
+        return convert_frac(atom.frac())
+    elif atom.binom():
+        return convert_binom(atom.binom())
+    elif atom.bra():
+        val = convert_expr(atom.bra().expr())
+        return Bra(val)
+    elif atom.ket():
+        val = convert_expr(atom.ket().expr())
+        return Ket(val)
+
+
+def rule2text(ctx):
+    stream = ctx.start.getInputStream()
+    # starting index of starting token
+    startIdx = ctx.start.start
+    # stopping index of stopping token
+    stopIdx = ctx.stop.stop
+
+    return stream.getText(startIdx, stopIdx)
+
+
+def convert_frac(frac):
+    diff_op = False
+    partial_op = False
+    if frac.lower and frac.upper:
+        lower_itv = frac.lower.getSourceInterval()
+        lower_itv_len = lower_itv[1] - lower_itv[0] + 1
+        if (frac.lower.start == frac.lower.stop
+                and frac.lower.start.type == LaTeXLexer.DIFFERENTIAL):
+            wrt = get_differential_var_str(frac.lower.start.text)
+            diff_op = True
+        elif (lower_itv_len == 2 and frac.lower.start.type == LaTeXLexer.SYMBOL
+              and frac.lower.start.text == '\\partial'
+              and (frac.lower.stop.type == LaTeXLexer.LETTER
+                   or frac.lower.stop.type == LaTeXLexer.SYMBOL)):
+            partial_op = True
+            wrt = frac.lower.stop.text
+            if frac.lower.stop.type == LaTeXLexer.SYMBOL:
+                wrt = wrt[1:]
+
+        if diff_op or partial_op:
+            wrt = sympy.Symbol(wrt)
+            if (diff_op and frac.upper.start == frac.upper.stop
+                    and frac.upper.start.type == LaTeXLexer.LETTER
+                    and frac.upper.start.text == 'd'):
+                return [wrt]
+            elif (partial_op and frac.upper.start == frac.upper.stop
+                  and frac.upper.start.type == LaTeXLexer.SYMBOL
+                  and frac.upper.start.text == '\\partial'):
+                return [wrt]
+            upper_text = rule2text(frac.upper)
+
+            expr_top = None
+            if diff_op and upper_text.startswith('d'):
+                expr_top = parse_latex(upper_text[1:])
+            elif partial_op and frac.upper.start.text == '\\partial':
+                expr_top = parse_latex(upper_text[len('\\partial'):])
+            if expr_top:
+                return sympy.Derivative(expr_top, wrt)
+    if frac.upper:
+        expr_top = convert_expr(frac.upper)
+    else:
+        expr_top = sympy.Number(frac.upperd.text)
+    if frac.lower:
+        expr_bot = convert_expr(frac.lower)
+    else:
+        expr_bot = sympy.Number(frac.lowerd.text)
+    inverse_denom = sympy.Pow(expr_bot, -1, evaluate=False)
+    if expr_top == 1:
+        return inverse_denom
+    else:
+        return sympy.Mul(expr_top, inverse_denom, evaluate=False)
+
+def convert_binom(binom):
+    expr_n = convert_expr(binom.n)
+    expr_k = convert_expr(binom.k)
+    return sympy.binomial(expr_n, expr_k, evaluate=False)
+
+def convert_floor(floor):
+    val = convert_expr(floor.val)
+    return sympy.floor(val, evaluate=False)
+
+def convert_ceil(ceil):
+    val = convert_expr(ceil.val)
+    return sympy.ceiling(val, evaluate=False)
+
+def convert_func(func):
+    if func.func_normal():
+        if func.L_PAREN():  # function called with parenthesis
+            arg = convert_func_arg(func.func_arg())
+        else:
+            arg = convert_func_arg(func.func_arg_noparens())
+
+        name = func.func_normal().start.text[1:]
+
+        # change arc<trig> -> a<trig>
+        if name in [
+                "arcsin", "arccos", "arctan", "arccsc", "arcsec", "arccot"
+        ]:
+            name = "a" + name[3:]
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+        if name in ["arsinh", "arcosh", "artanh"]:
+            name = "a" + name[2:]
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+
+        if name == "exp":
+            expr = sympy.exp(arg, evaluate=False)
+
+        if name in ("log", "lg", "ln"):
+            if func.subexpr():
+                if func.subexpr().expr():
+                    base = convert_expr(func.subexpr().expr())
+                else:
+                    base = convert_atom(func.subexpr().atom())
+            elif name == "lg":  # ISO 80000-2:2019
+                base = 10
+            elif name in ("ln", "log"):  # SymPy's latex printer prints ln as log by default
+                base = sympy.E
+            expr = sympy.log(arg, base, evaluate=False)
+
+        func_pow = None
+        should_pow = True
+        if func.supexpr():
+            if func.supexpr().expr():
+                func_pow = convert_expr(func.supexpr().expr())
+            else:
+                func_pow = convert_atom(func.supexpr().atom())
+
+        if name in [
+                "sin", "cos", "tan", "csc", "sec", "cot", "sinh", "cosh",
+                "tanh"
+        ]:
+            if func_pow == -1:
+                name = "a" + name
+                should_pow = False
+            expr = getattr(sympy.functions, name)(arg, evaluate=False)
+
+        if func_pow and should_pow:
+            expr = sympy.Pow(expr, func_pow, evaluate=False)
+
+        return expr
+    elif func.LETTER() or func.SYMBOL():
+        if func.LETTER():
+            fname = func.LETTER().getText()
+        elif func.SYMBOL():
+            fname = func.SYMBOL().getText()[1:]
+        fname = str(fname)  # can't be unicode
+        if func.subexpr():
+            if func.subexpr().expr():  # subscript is expr
+                subscript = convert_expr(func.subexpr().expr())
+            else:  # subscript is atom
+                subscript = convert_atom(func.subexpr().atom())
+            subscriptName = StrPrinter().doprint(subscript)
+            fname += '_{' + subscriptName + '}'
+        if func.SINGLE_QUOTES():
+            fname += func.SINGLE_QUOTES().getText()
+        input_args = func.args()
+        output_args = []
+        while input_args.args():  # handle multiple arguments to function
+            output_args.append(convert_expr(input_args.expr()))
+            input_args = input_args.args()
+        output_args.append(convert_expr(input_args.expr()))
+        return sympy.Function(fname)(*output_args)
+    elif func.FUNC_INT():
+        return handle_integral(func)
+    elif func.FUNC_SQRT():
+        expr = convert_expr(func.base)
+        if func.root:
+            r = convert_expr(func.root)
+            return sympy.root(expr, r, evaluate=False)
+        else:
+            return sympy.sqrt(expr, evaluate=False)
+    elif func.FUNC_OVERLINE():
+        expr = convert_expr(func.base)
+        return sympy.conjugate(expr, evaluate=False)
+    elif func.FUNC_SUM():
+        return handle_sum_or_prod(func, "summation")
+    elif func.FUNC_PROD():
+        return handle_sum_or_prod(func, "product")
+    elif func.FUNC_LIM():
+        return handle_limit(func)
+
+
+def convert_func_arg(arg):
+    if hasattr(arg, 'expr'):
+        return convert_expr(arg.expr())
+    else:
+        return convert_mp(arg.mp_nofunc())
+
+
+def handle_integral(func):
+    if func.additive():
+        integrand = convert_add(func.additive())
+    elif func.frac():
+        integrand = convert_frac(func.frac())
+    else:
+        integrand = 1
+
+    int_var = None
+    if func.DIFFERENTIAL():
+        int_var = get_differential_var(func.DIFFERENTIAL())
+    else:
+        for sym in integrand.atoms(sympy.Symbol):
+            s = str(sym)
+            if len(s) > 1 and s[0] == 'd':
+                if s[1] == '\\':
+                    int_var = sympy.Symbol(s[2:])
+                else:
+                    int_var = sympy.Symbol(s[1:])
+                int_sym = sym
+        if int_var:
+            integrand = integrand.subs(int_sym, 1)
+        else:
+            # Assume dx by default
+            int_var = sympy.Symbol('x')
+
+    if func.subexpr():
+        if func.subexpr().atom():
+            lower = convert_atom(func.subexpr().atom())
+        else:
+            lower = convert_expr(func.subexpr().expr())
+        if func.supexpr().atom():
+            upper = convert_atom(func.supexpr().atom())
+        else:
+            upper = convert_expr(func.supexpr().expr())
+        return sympy.Integral(integrand, (int_var, lower, upper))
+    else:
+        return sympy.Integral(integrand, int_var)
+
+
+def handle_sum_or_prod(func, name):
+    val = convert_mp(func.mp())
+    iter_var = convert_expr(func.subeq().equality().expr(0))
+    start = convert_expr(func.subeq().equality().expr(1))
+    if func.supexpr().expr():  # ^{expr}
+        end = convert_expr(func.supexpr().expr())
+    else:  # ^atom
+        end = convert_atom(func.supexpr().atom())
+
+    if name == "summation":
+        return sympy.Sum(val, (iter_var, start, end))
+    elif name == "product":
+        return sympy.Product(val, (iter_var, start, end))
+
+
+def handle_limit(func):
+    sub = func.limit_sub()
+    if sub.LETTER():
+        var = sympy.Symbol(sub.LETTER().getText())
+    elif sub.SYMBOL():
+        var = sympy.Symbol(sub.SYMBOL().getText()[1:])
+    else:
+        var = sympy.Symbol('x')
+    if sub.SUB():
+        direction = "-"
+    elif sub.ADD():
+        direction = "+"
+    else:
+        direction = "+-"
+    approaching = convert_expr(sub.expr())
+    content = convert_mp(func.mp())
+
+    return sympy.Limit(content, var, approaching, direction)
+
+
+def get_differential_var(d):
+    text = get_differential_var_str(d.getText())
+    return sympy.Symbol(text)
+
+
+def get_differential_var_str(text):
+    for i in range(1, len(text)):
+        c = text[i]
+        if not (c == " " or c == "\r" or c == "\n" or c == "\t"):
+            idx = i
+            break
+    text = text[idx:]
+    if text[0] == "\\":
+        text = text[1:]
+    return text

llmeval-env/lib/python3.10/site-packages/sympy/parsing/latex/errors.py

@@ -0,0 +1,2 @@
+class LaTeXParsingError(Exception):
+    pass

llmeval-env/lib/python3.10/site-packages/sympy/parsing/mathematica.py

@@ -0,0 +1,1080 @@
+from __future__ import annotations
+import re
+import typing
+from itertools import product
+from typing import Any, Callable
+
+import sympy
+from sympy import Mul, Add, Pow, log, exp, sqrt, cos, sin, tan, asin, acos, acot, asec, acsc, sinh, cosh, tanh, asinh, \
+    acosh, atanh, acoth, asech, acsch, expand, im, flatten, polylog, cancel, expand_trig, sign, simplify, \
+    UnevaluatedExpr, S, atan, atan2, Mod, Max, Min, rf, Ei, Si, Ci, airyai, airyaiprime, airybi, primepi, prime, \
+    isprime, cot, sec, csc, csch, sech, coth, Function, I, pi, Tuple, GreaterThan, StrictGreaterThan, StrictLessThan, \
+    LessThan, Equality, Or, And, Lambda, Integer, Dummy, symbols
+from sympy.core.sympify import sympify, _sympify
+from sympy.functions.special.bessel import airybiprime
+from sympy.functions.special.error_functions import li
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+def mathematica(s, additional_translations=None):
+    sympy_deprecation_warning(
+        """The ``mathematica`` function for the Mathematica parser is now
+deprecated. Use ``parse_mathematica`` instead.
+The parameter ``additional_translation`` can be replaced by SymPy's
+.replace( ) or .subs( ) methods on the output expression instead.""",
+        deprecated_since_version="1.11",
+        active_deprecations_target="mathematica-parser-new",
+    )
+    parser = MathematicaParser(additional_translations)
+    return sympify(parser._parse_old(s))
+
+
+def parse_mathematica(s):
+    """
+    Translate a string containing a Wolfram Mathematica expression to a SymPy
+    expression.
+
+    If the translator is unable to find a suitable SymPy expression, the
+    ``FullForm`` of the Mathematica expression will be output, using SymPy
+    ``Function`` objects as nodes of the syntax tree.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.mathematica import parse_mathematica
+    >>> parse_mathematica("Sin[x]^2 Tan[y]")
+    sin(x)**2*tan(y)
+    >>> e = parse_mathematica("F[7,5,3]")
+    >>> e
+    F(7, 5, 3)
+    >>> from sympy import Function, Max, Min
+    >>> e.replace(Function("F"), lambda *x: Max(*x)*Min(*x))
+    21
+
+    Both standard input form and Mathematica full form are supported:
+
+    >>> parse_mathematica("x*(a + b)")
+    x*(a + b)
+    >>> parse_mathematica("Times[x, Plus[a, b]]")
+    x*(a + b)
+
+    To get a matrix from Wolfram's code:
+
+    >>> m = parse_mathematica("{{a, b}, {c, d}}")
+    >>> m
+    ((a, b), (c, d))
+    >>> from sympy import Matrix
+    >>> Matrix(m)
+    Matrix([
+    [a, b],
+    [c, d]])
+
+    If the translation into equivalent SymPy expressions fails, an SymPy
+    expression equivalent to Wolfram Mathematica's "FullForm" will be created:
+
+    >>> parse_mathematica("x_.")
+    Optional(Pattern(x, Blank()))
+    >>> parse_mathematica("Plus @@ {x, y, z}")
+    Apply(Plus, (x, y, z))
+    >>> parse_mathematica("f[x_, 3] := x^3 /; x > 0")
+    SetDelayed(f(Pattern(x, Blank()), 3), Condition(x**3, x > 0))
+    """
+    parser = MathematicaParser()
+    return parser.parse(s)
+
+
+def _parse_Function(*args):
+    if len(args) == 1:
+        arg = args[0]
+        Slot = Function("Slot")
+        slots = arg.atoms(Slot)
+        numbers = [a.args[0] for a in slots]
+        number_of_arguments = max(numbers)
+        if isinstance(number_of_arguments, Integer):
+            variables = symbols(f"dummy0:{number_of_arguments}", cls=Dummy)
+            return Lambda(variables, arg.xreplace({Slot(i+1): v for i, v in enumerate(variables)}))
+        return Lambda((), arg)
+    elif len(args) == 2:
+        variables = args[0]
+        body = args[1]
+        return Lambda(variables, body)
+    else:
+        raise SyntaxError("Function node expects 1 or 2 arguments")
+
+
+def _deco(cls):
+    cls._initialize_class()
+    return cls
+
+
+@_deco
+class MathematicaParser:
+    """
+    An instance of this class converts a string of a Wolfram Mathematica
+    expression to a SymPy expression.
+
+    The main parser acts internally in three stages:
+
+    1. tokenizer: tokenizes the Mathematica expression and adds the missing *
+        operators. Handled by ``_from_mathematica_to_tokens(...)``
+    2. full form list: sort the list of strings output by the tokenizer into a
+        syntax tree of nested lists and strings, equivalent to Mathematica's
+        ``FullForm`` expression output. This is handled by the function
+        ``_from_tokens_to_fullformlist(...)``.
+    3. SymPy expression: the syntax tree expressed as full form list is visited
+        and the nodes with equivalent classes in SymPy are replaced. Unknown
+        syntax tree nodes are cast to SymPy ``Function`` objects. This is
+        handled by ``_from_fullformlist_to_sympy(...)``.
+
+    """
+
+    # left: Mathematica, right: SymPy
+    CORRESPONDENCES = {
+        'Sqrt[x]': 'sqrt(x)',
+        'Exp[x]': 'exp(x)',
+        'Log[x]': 'log(x)',
+        'Log[x,y]': 'log(y,x)',
+        'Log2[x]': 'log(x,2)',
+        'Log10[x]': 'log(x,10)',
+        'Mod[x,y]': 'Mod(x,y)',
+        'Max[*x]': 'Max(*x)',
+        'Min[*x]': 'Min(*x)',
+        'Pochhammer[x,y]':'rf(x,y)',
+        'ArcTan[x,y]':'atan2(y,x)',
+        'ExpIntegralEi[x]': 'Ei(x)',
+        'SinIntegral[x]': 'Si(x)',
+        'CosIntegral[x]': 'Ci(x)',
+        'AiryAi[x]': 'airyai(x)',
+        'AiryAiPrime[x]': 'airyaiprime(x)',
+        'AiryBi[x]' :'airybi(x)',
+        'AiryBiPrime[x]' :'airybiprime(x)',
+        'LogIntegral[x]':' li(x)',
+        'PrimePi[x]': 'primepi(x)',
+        'Prime[x]': 'prime(x)',
+        'PrimeQ[x]': 'isprime(x)'
+    }
+
+    # trigonometric, e.t.c.
+    for arc, tri, h in product(('', 'Arc'), (
+            'Sin', 'Cos', 'Tan', 'Cot', 'Sec', 'Csc'), ('', 'h')):
+        fm = arc + tri + h + '[x]'
+        if arc:  # arc func
+            fs = 'a' + tri.lower() + h + '(x)'
+        else:    # non-arc func
+            fs = tri.lower() + h + '(x)'
+        CORRESPONDENCES.update({fm: fs})
+
+    REPLACEMENTS = {
+        ' ': '',
+        '^': '**',
+        '{': '[',
+        '}': ']',
+    }
+
+    RULES = {
+        # a single whitespace to '*'
+        'whitespace': (
+            re.compile(r'''
+                (?:(?<=[a-zA-Z\d])|(?<=\d\.))     # a letter or a number
+                \s+                               # any number of whitespaces
+                (?:(?=[a-zA-Z\d])|(?=\.\d))       # a letter or a number
+                ''', re.VERBOSE),
+            '*'),
+
+        # add omitted '*' character
+        'add*_1': (
+            re.compile(r'''
+                (?:(?<=[])\d])|(?<=\d\.))       # ], ) or a number
+                                                # ''
+                (?=[(a-zA-Z])                   # ( or a single letter
+                ''', re.VERBOSE),
+            '*'),
+
+        # add omitted '*' character (variable letter preceding)
+        'add*_2': (
+            re.compile(r'''
+                (?<=[a-zA-Z])       # a letter
+                \(                  # ( as a character
+                (?=.)               # any characters
+                ''', re.VERBOSE),
+            '*('),
+
+        # convert 'Pi' to 'pi'
+        'Pi': (
+            re.compile(r'''
+                (?:
+                \A|(?<=[^a-zA-Z])
+                )
+                Pi                  # 'Pi' is 3.14159... in Mathematica
+                (?=[^a-zA-Z])
+                ''', re.VERBOSE),
+            'pi'),
+    }
+
+    # Mathematica function name pattern
+    FM_PATTERN = re.compile(r'''
+                (?:
+                \A|(?<=[^a-zA-Z])   # at the top or a non-letter
+                )
+                [A-Z][a-zA-Z\d]*    # Function
+                (?=\[)              # [ as a character
+                ''', re.VERBOSE)
+
+    # list or matrix pattern (for future usage)
+    ARG_MTRX_PATTERN = re.compile(r'''
+                \{.*\}
+                ''', re.VERBOSE)
+
+    # regex string for function argument pattern
+    ARGS_PATTERN_TEMPLATE = r'''
+                (?:
+                \A|(?<=[^a-zA-Z])
+                )
+                {arguments}         # model argument like x, y,...
+                (?=[^a-zA-Z])
+                '''
+
+    # will contain transformed CORRESPONDENCES dictionary
+    TRANSLATIONS: dict[tuple[str, int], dict[str, Any]] = {}
+
+    # cache for a raw users' translation dictionary
+    cache_original: dict[tuple[str, int], dict[str, Any]] = {}
+
+    # cache for a compiled users' translation dictionary
+    cache_compiled: dict[tuple[str, int], dict[str, Any]] = {}
+
+    @classmethod
+    def _initialize_class(cls):
+        # get a transformed CORRESPONDENCES dictionary
+        d = cls._compile_dictionary(cls.CORRESPONDENCES)
+        cls.TRANSLATIONS.update(d)
+
+    def __init__(self, additional_translations=None):
+        self.translations = {}
+
+        # update with TRANSLATIONS (class constant)
+        self.translations.update(self.TRANSLATIONS)
+
+        if additional_translations is None:
+            additional_translations = {}
+
+        # check the latest added translations
+        if self.__class__.cache_original != additional_translations:
+            if not isinstance(additional_translations, dict):
+                raise ValueError('The argument must be dict type')
+
+            # get a transformed additional_translations dictionary
+            d = self._compile_dictionary(additional_translations)
+
+            # update cache
+            self.__class__.cache_original = additional_translations
+            self.__class__.cache_compiled = d
+
+        # merge user's own translations
+        self.translations.update(self.__class__.cache_compiled)
+
+    @classmethod
+    def _compile_dictionary(cls, dic):
+        # for return
+        d = {}
+
+        for fm, fs in dic.items():
+            # check function form
+            cls._check_input(fm)
+            cls._check_input(fs)
+
+            # uncover '*' hiding behind a whitespace
+            fm = cls._apply_rules(fm, 'whitespace')
+            fs = cls._apply_rules(fs, 'whitespace')
+
+            # remove whitespace(s)
+            fm = cls._replace(fm, ' ')
+            fs = cls._replace(fs, ' ')
+
+            # search Mathematica function name
+            m = cls.FM_PATTERN.search(fm)
+
+            # if no-hit
+            if m is None:
+                err = "'{f}' function form is invalid.".format(f=fm)
+                raise ValueError(err)
+
+            # get Mathematica function name like 'Log'
+            fm_name = m.group()
+
+            # get arguments of Mathematica function
+            args, end = cls._get_args(m)
+
+            # function side check. (e.g.) '2*Func[x]' is invalid.
+            if m.start() != 0 or end != len(fm):
+                err = "'{f}' function form is invalid.".format(f=fm)
+                raise ValueError(err)
+
+            # check the last argument's 1st character
+            if args[-1][0] == '*':
+                key_arg = '*'
+            else:
+                key_arg = len(args)
+
+            key = (fm_name, key_arg)
+
+            # convert '*x' to '\\*x' for regex
+            re_args = [x if x[0] != '*' else '\\' + x for x in args]
+
+            # for regex. Example: (?:(x|y|z))
+            xyz = '(?:(' + '|'.join(re_args) + '))'
+
+            # string for regex compile
+            patStr = cls.ARGS_PATTERN_TEMPLATE.format(arguments=xyz)
+
+            pat = re.compile(patStr, re.VERBOSE)
+
+            # update dictionary
+            d[key] = {}
+            d[key]['fs'] = fs  # SymPy function template
+            d[key]['args'] = args  # args are ['x', 'y'] for example
+            d[key]['pat'] = pat
+
+        return d
+
+    def _convert_function(self, s):
+        '''Parse Mathematica function to SymPy one'''
+
+        # compiled regex object
+        pat = self.FM_PATTERN
+
+        scanned = ''                # converted string
+        cur = 0                     # position cursor
+        while True:
+            m = pat.search(s)
+
+            if m is None:
+                # append the rest of string
+                scanned += s
+                break
+
+            # get Mathematica function name
+            fm = m.group()
+
+            # get arguments, and the end position of fm function
+            args, end = self._get_args(m)
+
+            # the start position of fm function
+            bgn = m.start()
+
+            # convert Mathematica function to SymPy one
+            s = self._convert_one_function(s, fm, args, bgn, end)
+
+            # update cursor
+            cur = bgn
+
+            # append converted part
+            scanned += s[:cur]
+
+            # shrink s
+            s = s[cur:]
+
+        return scanned
+
+    def _convert_one_function(self, s, fm, args, bgn, end):
+        # no variable-length argument
+        if (fm, len(args)) in self.translations:
+            key = (fm, len(args))
+
+            # x, y,... model arguments
+            x_args = self.translations[key]['args']
+
+            # make CORRESPONDENCES between model arguments and actual ones
+            d = {k: v for k, v in zip(x_args, args)}
+
+        # with variable-length argument
+        elif (fm, '*') in self.translations:
+            key = (fm, '*')
+
+            # x, y,..*args (model arguments)
+            x_args = self.translations[key]['args']
+
+            # make CORRESPONDENCES between model arguments and actual ones
+            d = {}
+            for i, x in enumerate(x_args):
+                if x[0] == '*':
+                    d[x] = ','.join(args[i:])
+                    break
+                d[x] = args[i]
+
+        # out of self.translations
+        else:
+            err = "'{f}' is out of the whitelist.".format(f=fm)
+            raise ValueError(err)
+
+        # template string of converted function
+        template = self.translations[key]['fs']
+
+        # regex pattern for x_args
+        pat = self.translations[key]['pat']
+
+        scanned = ''
+        cur = 0
+        while True:
+            m = pat.search(template)
+
+            if m is None:
+                scanned += template
+                break
+
+            # get model argument
+            x = m.group()
+
+            # get a start position of the model argument
+            xbgn = m.start()
+
+            # add the corresponding actual argument
+            scanned += template[:xbgn] + d[x]
+
+            # update cursor to the end of the model argument
+            cur = m.end()
+
+            # shrink template
+            template = template[cur:]
+
+        # update to swapped string
+        s = s[:bgn] + scanned + s[end:]
+
+        return s
+
+    @classmethod
+    def _get_args(cls, m):
+        '''Get arguments of a Mathematica function'''
+
+        s = m.string                # whole string
+        anc = m.end() + 1           # pointing the first letter of arguments
+        square, curly = [], []      # stack for brakets
+        args = []
+
+        # current cursor
+        cur = anc
+        for i, c in enumerate(s[anc:], anc):
+            # extract one argument
+            if c == ',' and (not square) and (not curly):
+                args.append(s[cur:i])       # add an argument
+                cur = i + 1                 # move cursor
+
+            # handle list or matrix (for future usage)
+            if c == '{':
+                curly.append(c)
+            elif c == '}':
+                curly.pop()
+
+            # seek corresponding ']' with skipping irrevant ones
+            if c == '[':
+                square.append(c)
+            elif c == ']':
+                if square:
+                    square.pop()
+                else:   # empty stack
+                    args.append(s[cur:i])
+                    break
+
+        # the next position to ']' bracket (the function end)
+        func_end = i + 1
+
+        return args, func_end
+
+    @classmethod
+    def _replace(cls, s, bef):
+        aft = cls.REPLACEMENTS[bef]
+        s = s.replace(bef, aft)
+        return s
+
+    @classmethod
+    def _apply_rules(cls, s, bef):
+        pat, aft = cls.RULES[bef]
+        return pat.sub(aft, s)
+
+    @classmethod
+    def _check_input(cls, s):
+        for bracket in (('[', ']'), ('{', '}'), ('(', ')')):
+            if s.count(bracket[0]) != s.count(bracket[1]):
+                err = "'{f}' function form is invalid.".format(f=s)
+                raise ValueError(err)
+
+        if '{' in s:
+            err = "Currently list is not supported."
+            raise ValueError(err)
+
+    def _parse_old(self, s):
+        # input check
+        self._check_input(s)
+
+        # uncover '*' hiding behind a whitespace
+        s = self._apply_rules(s, 'whitespace')
+
+        # remove whitespace(s)
+        s = self._replace(s, ' ')
+
+        # add omitted '*' character
+        s = self._apply_rules(s, 'add*_1')
+        s = self._apply_rules(s, 'add*_2')
+
+        # translate function
+        s = self._convert_function(s)
+
+        # '^' to '**'
+        s = self._replace(s, '^')
+
+        # 'Pi' to 'pi'
+        s = self._apply_rules(s, 'Pi')
+
+        # '{', '}' to '[', ']', respectively
+#        s = cls._replace(s, '{')   # currently list is not taken into account
+#        s = cls._replace(s, '}')
+
+        return s
+
+    def parse(self, s):
+        s2 = self._from_mathematica_to_tokens(s)
+        s3 = self._from_tokens_to_fullformlist(s2)
+        s4 = self._from_fullformlist_to_sympy(s3)
+        return s4
+
+    INFIX = "Infix"
+    PREFIX = "Prefix"
+    POSTFIX = "Postfix"
+    FLAT = "Flat"
+    RIGHT = "Right"
+    LEFT = "Left"
+
+    _mathematica_op_precedence: list[tuple[str, str | None, dict[str, str | Callable]]] = [
+        (POSTFIX, None, {";": lambda x: x + ["Null"] if isinstance(x, list) and x and x[0] == "CompoundExpression" else ["CompoundExpression", x, "Null"]}),
+        (INFIX, FLAT, {";": "CompoundExpression"}),
+        (INFIX, RIGHT, {"=": "Set", ":=": "SetDelayed", "+=": "AddTo", "-=": "SubtractFrom", "*=": "TimesBy", "/=": "DivideBy"}),
+        (INFIX, LEFT, {"//": lambda x, y: [x, y]}),
+        (POSTFIX, None, {"&": "Function"}),
+        (INFIX, LEFT, {"/.": "ReplaceAll"}),
+        (INFIX, RIGHT, {"->": "Rule", ":>": "RuleDelayed"}),
+        (INFIX, LEFT, {"/;": "Condition"}),
+        (INFIX, FLAT, {"|": "Alternatives"}),
+        (POSTFIX, None, {"..": "Repeated", "...": "RepeatedNull"}),
+        (INFIX, FLAT, {"||": "Or"}),
+        (INFIX, FLAT, {"&&": "And"}),
+        (PREFIX, None, {"!": "Not"}),
+        (INFIX, FLAT, {"===": "SameQ", "=!=": "UnsameQ"}),
+        (INFIX, FLAT, {"==": "Equal", "!=": "Unequal", "<=": "LessEqual", "<": "Less", ">=": "GreaterEqual", ">": "Greater"}),
+        (INFIX, None, {";;": "Span"}),
+        (INFIX, FLAT, {"+": "Plus", "-": "Plus"}),
+        (INFIX, FLAT, {"*": "Times", "/": "Times"}),
+        (INFIX, FLAT, {".": "Dot"}),
+        (PREFIX, None, {"-": lambda x: MathematicaParser._get_neg(x),
+                        "+": lambda x: x}),
+        (INFIX, RIGHT, {"^": "Power"}),
+        (INFIX, RIGHT, {"@@": "Apply", "/@": "Map", "//@": "MapAll", "@@@": lambda x, y: ["Apply", x, y, ["List", "1"]]}),
+        (POSTFIX, None, {"'": "Derivative", "!": "Factorial", "!!": "Factorial2", "--": "Decrement"}),
+        (INFIX, None, {"[": lambda x, y: [x, *y], "[[": lambda x, y: ["Part", x, *y]}),
+        (PREFIX, None, {"{": lambda x: ["List", *x], "(": lambda x: x[0]}),
+        (INFIX, None, {"?": "PatternTest"}),
+        (POSTFIX, None, {
+            "_": lambda x: ["Pattern", x, ["Blank"]],
+            "_.": lambda x: ["Optional", ["Pattern", x, ["Blank"]]],
+            "__": lambda x: ["Pattern", x, ["BlankSequence"]],
+            "___": lambda x: ["Pattern", x, ["BlankNullSequence"]],
+        }),
+        (INFIX, None, {"_": lambda x, y: ["Pattern", x, ["Blank", y]]}),
+        (PREFIX, None, {"#": "Slot", "##": "SlotSequence"}),
+    ]
+
+    _missing_arguments_default = {
+        "#": lambda: ["Slot", "1"],
+        "##": lambda: ["SlotSequence", "1"],
+    }
+
+    _literal = r"[A-Za-z][A-Za-z0-9]*"
+    _number = r"(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)"
+
+    _enclosure_open = ["(", "[", "[[", "{"]
+    _enclosure_close = [")", "]", "]]", "}"]
+
+    @classmethod
+    def _get_neg(cls, x):
+        return f"-{x}" if isinstance(x, str) and re.match(MathematicaParser._number, x) else ["Times", "-1", x]
+
+    @classmethod
+    def _get_inv(cls, x):
+        return ["Power", x, "-1"]
+
+    _regex_tokenizer = None
+
+    def _get_tokenizer(self):
+        if self._regex_tokenizer is not None:
+            # Check if the regular expression has already been compiled:
+            return self._regex_tokenizer
+        tokens = [self._literal, self._number]
+        tokens_escape = self._enclosure_open[:] + self._enclosure_close[:]
+        for typ, strat, symdict in self._mathematica_op_precedence:
+            for k in symdict:
+                tokens_escape.append(k)
+        tokens_escape.sort(key=lambda x: -len(x))
+        tokens.extend(map(re.escape, tokens_escape))
+        tokens.append(",")
+        tokens.append("\n")
+        tokenizer = re.compile("(" + "|".join(tokens) + ")")
+        self._regex_tokenizer = tokenizer
+        return self._regex_tokenizer
+
+    def _from_mathematica_to_tokens(self, code: str):
+        tokenizer = self._get_tokenizer()
+
+        # Find strings:
+        code_splits: list[str | list] = []
+        while True:
+            string_start = code.find("\"")
+            if string_start == -1:
+                if len(code) > 0:
+                    code_splits.append(code)
+                break
+            match_end = re.search(r'(?<!\\)"', code[string_start+1:])
+            if match_end is None:
+                raise SyntaxError('mismatch in string "  " expression')
+            string_end = string_start + match_end.start() + 1
+            if string_start > 0:
+                code_splits.append(code[:string_start])
+            code_splits.append(["_Str", code[string_start+1:string_end].replace('\\"', '"')])
+            code = code[string_end+1:]
+
+        # Remove comments:
+        for i, code_split in enumerate(code_splits):
+            if isinstance(code_split, list):
+                continue
+            while True:
+                pos_comment_start = code_split.find("(*")
+                if pos_comment_start == -1:
+                    break
+                pos_comment_end = code_split.find("*)")
+                if pos_comment_end == -1 or pos_comment_end < pos_comment_start:
+                    raise SyntaxError("mismatch in comment (*  *) code")
+                code_split = code_split[:pos_comment_start] + code_split[pos_comment_end+2:]
+            code_splits[i] = code_split
+
+        # Tokenize the input strings with a regular expression:
+        token_lists = [tokenizer.findall(i) if isinstance(i, str) and i.isascii() else [i] for i in code_splits]
+        tokens = [j for i in token_lists for j in i]
+
+        # Remove newlines at the beginning
+        while tokens and tokens[0] == "\n":
+            tokens.pop(0)
+        # Remove newlines at the end
+        while tokens and tokens[-1] == "\n":
+            tokens.pop(-1)
+
+        return tokens
+
+    def _is_op(self, token: str | list) -> bool:
+        if isinstance(token, list):
+            return False
+        if re.match(self._literal, token):
+            return False
+        if re.match("-?" + self._number, token):
+            return False
+        return True
+
+    def _is_valid_star1(self, token: str | list) -> bool:
+        if token in (")", "}"):
+            return True
+        return not self._is_op(token)
+
+    def _is_valid_star2(self, token: str | list) -> bool:
+        if token in ("(", "{"):
+            return True
+        return not self._is_op(token)
+
+    def _from_tokens_to_fullformlist(self, tokens: list):
+        stack: list[list] = [[]]
+        open_seq = []
+        pointer: int = 0
+        while pointer < len(tokens):
+            token = tokens[pointer]
+            if token in self._enclosure_open:
+                stack[-1].append(token)
+                open_seq.append(token)
+                stack.append([])
+            elif token == ",":
+                if len(stack[-1]) == 0 and stack[-2][-1] == open_seq[-1]:
+                    raise SyntaxError("%s cannot be followed by comma ," % open_seq[-1])
+                stack[-1] = self._parse_after_braces(stack[-1])
+                stack.append([])
+            elif token in self._enclosure_close:
+                ind = self._enclosure_close.index(token)
+                if self._enclosure_open[ind] != open_seq[-1]:
+                    unmatched_enclosure = SyntaxError("unmatched enclosure")
+                    if token == "]]" and open_seq[-1] == "[":
+                        if open_seq[-2] == "[":
+                            # These two lines would be logically correct, but are
+                            # unnecessary:
+                            # token = "]"
+                            # tokens[pointer] = "]"
+                            tokens.insert(pointer+1, "]")
+                        elif open_seq[-2] == "[[":
+                            if tokens[pointer+1] == "]":
+                                tokens[pointer+1] = "]]"
+                            elif tokens[pointer+1] == "]]":
+                                tokens[pointer+1] = "]]"
+                                tokens.insert(pointer+2, "]")
+                            else:
+                                raise unmatched_enclosure
+                    else:
+                        raise unmatched_enclosure
+                if len(stack[-1]) == 0 and stack[-2][-1] == "(":
+                    raise SyntaxError("( ) not valid syntax")
+                last_stack = self._parse_after_braces(stack[-1], True)
+                stack[-1] = last_stack
+                new_stack_element = []
+                while stack[-1][-1] != open_seq[-1]:
+                    new_stack_element.append(stack.pop())
+                new_stack_element.reverse()
+                if open_seq[-1] == "(" and len(new_stack_element) != 1:
+                    raise SyntaxError("( must be followed by one expression, %i detected" % len(new_stack_element))
+                stack[-1].append(new_stack_element)
+                open_seq.pop(-1)
+            else:
+                stack[-1].append(token)
+            pointer += 1
+        assert len(stack) == 1
+        return self._parse_after_braces(stack[0])
+
+    def _util_remove_newlines(self, lines: list, tokens: list, inside_enclosure: bool):
+        pointer = 0
+        size = len(tokens)
+        while pointer < size:
+            token = tokens[pointer]
+            if token == "\n":
+                if inside_enclosure:
+                    # Ignore newlines inside enclosures
+                    tokens.pop(pointer)
+                    size -= 1
+                    continue
+                if pointer == 0:
+                    tokens.pop(0)
+                    size -= 1
+                    continue
+                if pointer > 1:
+                    try:
+                        prev_expr = self._parse_after_braces(tokens[:pointer], inside_enclosure)
+                    except SyntaxError:
+                        tokens.pop(pointer)
+                        size -= 1
+                        continue
+                else:
+                    prev_expr = tokens[0]
+                if len(prev_expr) > 0 and prev_expr[0] == "CompoundExpression":
+                    lines.extend(prev_expr[1:])
+                else:
+                    lines.append(prev_expr)
+                for i in range(pointer):
+                    tokens.pop(0)
+                size -= pointer
+                pointer = 0
+                continue
+            pointer += 1
+
+    def _util_add_missing_asterisks(self, tokens: list):
+        size: int = len(tokens)
+        pointer: int = 0
+        while pointer < size:
+            if (pointer > 0 and
+                    self._is_valid_star1(tokens[pointer - 1]) and
+                    self._is_valid_star2(tokens[pointer])):
+                # This is a trick to add missing * operators in the expression,
+                # `"*" in op_dict` makes sure the precedence level is the same as "*",
+                # while `not self._is_op( ... )` makes sure this and the previous
+                # expression are not operators.
+                if tokens[pointer] == "(":
+                    # ( has already been processed by now, replace:
+                    tokens[pointer] = "*"
+                    tokens[pointer + 1] = tokens[pointer + 1][0]
+                else:
+                    tokens.insert(pointer, "*")
+                    pointer += 1
+                    size += 1
+            pointer += 1
+
+    def _parse_after_braces(self, tokens: list, inside_enclosure: bool = False):
+        op_dict: dict
+        changed: bool = False
+        lines: list = []
+
+        self._util_remove_newlines(lines, tokens, inside_enclosure)
+
+        for op_type, grouping_strat, op_dict in reversed(self._mathematica_op_precedence):
+            if "*" in op_dict:
+                self._util_add_missing_asterisks(tokens)
+            size: int = len(tokens)
+            pointer: int = 0
+            while pointer < size:
+                token = tokens[pointer]
+                if isinstance(token, str) and token in op_dict:
+                    op_name: str | Callable = op_dict[token]
+                    node: list
+                    first_index: int
+                    if isinstance(op_name, str):
+                        node = [op_name]
+                        first_index = 1
+                    else:
+                        node = []
+                        first_index = 0
+                    if token in ("+", "-") and op_type == self.PREFIX and pointer > 0 and not self._is_op(tokens[pointer - 1]):
+                        # Make sure that PREFIX + - don't match expressions like a + b or a - b,
+                        # the INFIX + - are supposed to match that expression:
+                        pointer += 1
+                        continue
+                    if op_type == self.INFIX:
+                        if pointer == 0 or pointer == size - 1 or self._is_op(tokens[pointer - 1]) or self._is_op(tokens[pointer + 1]):
+                            pointer += 1
+                            continue
+                    changed = True
+                    tokens[pointer] = node
+                    if op_type == self.INFIX:
+                        arg1 = tokens.pop(pointer-1)
+                        arg2 = tokens.pop(pointer)
+                        if token == "/":
+                            arg2 = self._get_inv(arg2)
+                        elif token == "-":
+                            arg2 = self._get_neg(arg2)
+                        pointer -= 1
+                        size -= 2
+                        node.append(arg1)
+                        node_p = node
+                        if grouping_strat == self.FLAT:
+                            while pointer + 2 < size and self._check_op_compatible(tokens[pointer+1], token):
+                                node_p.append(arg2)
+                                other_op = tokens.pop(pointer+1)
+                                arg2 = tokens.pop(pointer+1)
+                                if other_op == "/":
+                                    arg2 = self._get_inv(arg2)
+                                elif other_op == "-":
+                                    arg2 = self._get_neg(arg2)
+                                size -= 2
+                            node_p.append(arg2)
+                        elif grouping_strat == self.RIGHT:
+                            while pointer + 2 < size and tokens[pointer+1] == token:
+                                node_p.append([op_name, arg2])
+                                node_p = node_p[-1]
+                                tokens.pop(pointer+1)
+                                arg2 = tokens.pop(pointer+1)
+                                size -= 2
+                            node_p.append(arg2)
+                        elif grouping_strat == self.LEFT:
+                            while pointer + 1 < size and tokens[pointer+1] == token:
+                                if isinstance(op_name, str):
+                                    node_p[first_index] = [op_name, node_p[first_index], arg2]
+                                else:
+                                    node_p[first_index] = op_name(node_p[first_index], arg2)
+                                tokens.pop(pointer+1)
+                                arg2 = tokens.pop(pointer+1)
+                                size -= 2
+                            node_p.append(arg2)
+                        else:
+                            node.append(arg2)
+                    elif op_type == self.PREFIX:
+                        assert grouping_strat is None
+                        if pointer == size - 1 or self._is_op(tokens[pointer + 1]):
+                            tokens[pointer] = self._missing_arguments_default[token]()
+                        else:
+                            node.append(tokens.pop(pointer+1))
+                            size -= 1
+                    elif op_type == self.POSTFIX:
+                        assert grouping_strat is None
+                        if pointer == 0 or self._is_op(tokens[pointer - 1]):
+                            tokens[pointer] = self._missing_arguments_default[token]()
+                        else:
+                            node.append(tokens.pop(pointer-1))
+                            pointer -= 1
+                            size -= 1
+                    if isinstance(op_name, Callable):  # type: ignore
+                        op_call: Callable = typing.cast(Callable, op_name)
+                        new_node = op_call(*node)
+                        node.clear()
+                        if isinstance(new_node, list):
+                            node.extend(new_node)
+                        else:
+                            tokens[pointer] = new_node
+                pointer += 1
+        if len(tokens) > 1 or (len(lines) == 0 and len(tokens) == 0):
+            if changed:
+                # Trick to deal with cases in which an operator with lower
+                # precedence should be transformed before an operator of higher
+                # precedence. Such as in the case of `#&[x]` (that is
+                # equivalent to `Lambda(d_, d_)(x)` in SymPy). In this case the
+                # operator `&` has lower precedence than `[`, but needs to be
+                # evaluated first because otherwise `# (&[x])` is not a valid
+                # expression:
+                return self._parse_after_braces(tokens, inside_enclosure)
+            raise SyntaxError("unable to create a single AST for the expression")
+        if len(lines) > 0:
+            if tokens[0] and tokens[0][0] == "CompoundExpression":
+                tokens = tokens[0][1:]
+            compound_expression = ["CompoundExpression", *lines, *tokens]
+            return compound_expression
+        return tokens[0]
+
+    def _check_op_compatible(self, op1: str, op2: str):
+        if op1 == op2:
+            return True
+        muldiv = {"*", "/"}
+        addsub = {"+", "-"}
+        if op1 in muldiv and op2 in muldiv:
+            return True
+        if op1 in addsub and op2 in addsub:
+            return True
+        return False
+
+    def _from_fullform_to_fullformlist(self, wmexpr: str):
+        """
+        Parses FullForm[Downvalues[]] generated by Mathematica
+        """
+        out: list = []
+        stack = [out]
+        generator = re.finditer(r'[\[\],]', wmexpr)
+        last_pos = 0
+        for match in generator:
+            if match is None:
+                break
+            position = match.start()
+            last_expr = wmexpr[last_pos:position].replace(',', '').replace(']', '').replace('[', '').strip()
+
+            if match.group() == ',':
+                if last_expr != '':
+                    stack[-1].append(last_expr)
+            elif match.group() == ']':
+                if last_expr != '':
+                    stack[-1].append(last_expr)
+                stack.pop()
+            elif match.group() == '[':
+                stack[-1].append([last_expr])
+                stack.append(stack[-1][-1])
+            last_pos = match.end()
+        return out[0]
+
+    def _from_fullformlist_to_fullformsympy(self, pylist: list):
+        from sympy import Function, Symbol
+
+        def converter(expr):
+            if isinstance(expr, list):
+                if len(expr) > 0:
+                    head = expr[0]
+                    args = [converter(arg) for arg in expr[1:]]
+                    return Function(head)(*args)
+                else:
+                    raise ValueError("Empty list of expressions")
+            elif isinstance(expr, str):
+                return Symbol(expr)
+            else:
+                return _sympify(expr)
+
+        return converter(pylist)
+
+    _node_conversions = {
+        "Times": Mul,
+        "Plus": Add,
+        "Power": Pow,
+        "Log": lambda *a: log(*reversed(a)),
+        "Log2": lambda x: log(x, 2),
+        "Log10": lambda x: log(x, 10),
+        "Exp": exp,
+        "Sqrt": sqrt,
+
+        "Sin": sin,
+        "Cos": cos,
+        "Tan": tan,
+        "Cot": cot,
+        "Sec": sec,
+        "Csc": csc,
+
+        "ArcSin": asin,
+        "ArcCos": acos,
+        "ArcTan": lambda *a: atan2(*reversed(a)) if len(a) == 2 else atan(*a),
+        "ArcCot": acot,
+        "ArcSec": asec,
+        "ArcCsc": acsc,
+
+        "Sinh": sinh,
+        "Cosh": cosh,
+        "Tanh": tanh,
+        "Coth": coth,
+        "Sech": sech,
+        "Csch": csch,
+
+        "ArcSinh": asinh,
+        "ArcCosh": acosh,
+        "ArcTanh": atanh,
+        "ArcCoth": acoth,
+        "ArcSech": asech,
+        "ArcCsch": acsch,
+
+        "Expand": expand,
+        "Im": im,
+        "Re": sympy.re,
+        "Flatten": flatten,
+        "Polylog": polylog,
+        "Cancel": cancel,
+        # Gamma=gamma,
+        "TrigExpand": expand_trig,
+        "Sign": sign,
+        "Simplify": simplify,
+        "Defer": UnevaluatedExpr,
+        "Identity": S,
+        # Sum=Sum_doit,
+        # Module=With,
+        # Block=With,
+        "Null": lambda *a: S.Zero,
+        "Mod": Mod,
+        "Max": Max,
+        "Min": Min,
+        "Pochhammer": rf,
+        "ExpIntegralEi": Ei,
+        "SinIntegral": Si,
+        "CosIntegral": Ci,
+        "AiryAi": airyai,
+        "AiryAiPrime": airyaiprime,
+        "AiryBi": airybi,
+        "AiryBiPrime": airybiprime,
+        "LogIntegral": li,
+        "PrimePi": primepi,
+        "Prime": prime,
+        "PrimeQ": isprime,
+
+        "List": Tuple,
+        "Greater": StrictGreaterThan,
+        "GreaterEqual": GreaterThan,
+        "Less": StrictLessThan,
+        "LessEqual": LessThan,
+        "Equal": Equality,
+        "Or": Or,
+        "And": And,
+
+        "Function": _parse_Function,
+    }
+
+    _atom_conversions = {
+        "I": I,
+        "Pi": pi,
+    }
+
+    def _from_fullformlist_to_sympy(self, full_form_list):
+
+        def recurse(expr):
+            if isinstance(expr, list):
+                if isinstance(expr[0], list):
+                    head = recurse(expr[0])
+                else:
+                    head = self._node_conversions.get(expr[0], Function(expr[0]))
+                return head(*[recurse(arg) for arg in expr[1:]])
+            else:
+                return self._atom_conversions.get(expr, sympify(expr))
+
+        return recurse(full_form_list)
+
+    def _from_fullformsympy_to_sympy(self, mform):
+
+        expr = mform
+        for mma_form, sympy_node in self._node_conversions.items():
+            expr = expr.replace(Function(mma_form), sympy_node)
+        return expr

llmeval-env/lib/python3.10/site-packages/sympy/parsing/maxima.py

@@ -0,0 +1,71 @@
+import re
+from sympy.concrete.products import product
+from sympy.concrete.summations import Sum
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.trigonometric import (cos, sin)
+
+
+class MaximaHelpers:
+    def maxima_expand(expr):
+        return expr.expand()
+
+    def maxima_float(expr):
+        return expr.evalf()
+
+    def maxima_trigexpand(expr):
+        return expr.expand(trig=True)
+
+    def maxima_sum(a1, a2, a3, a4):
+        return Sum(a1, (a2, a3, a4)).doit()
+
+    def maxima_product(a1, a2, a3, a4):
+        return product(a1, (a2, a3, a4))
+
+    def maxima_csc(expr):
+        return 1/sin(expr)
+
+    def maxima_sec(expr):
+        return 1/cos(expr)
+
+sub_dict = {
+    'pi': re.compile(r'%pi'),
+    'E': re.compile(r'%e'),
+    'I': re.compile(r'%i'),
+    '**': re.compile(r'\^'),
+    'oo': re.compile(r'\binf\b'),
+    '-oo': re.compile(r'\bminf\b'),
+    "'-'": re.compile(r'\bminus\b'),
+    'maxima_expand': re.compile(r'\bexpand\b'),
+    'maxima_float': re.compile(r'\bfloat\b'),
+    'maxima_trigexpand': re.compile(r'\btrigexpand'),
+    'maxima_sum': re.compile(r'\bsum\b'),
+    'maxima_product': re.compile(r'\bproduct\b'),
+    'cancel': re.compile(r'\bratsimp\b'),
+    'maxima_csc': re.compile(r'\bcsc\b'),
+    'maxima_sec': re.compile(r'\bsec\b')
+}
+
+var_name = re.compile(r'^\s*(\w+)\s*:')
+
+
+def parse_maxima(str, globals=None, name_dict={}):
+    str = str.strip()
+    str = str.rstrip('; ')
+
+    for k, v in sub_dict.items():
+        str = v.sub(k, str)
+
+    assign_var = None
+    var_match = var_name.search(str)
+    if var_match:
+        assign_var = var_match.group(1)
+        str = str[var_match.end():].strip()
+
+    dct = MaximaHelpers.__dict__.copy()
+    dct.update(name_dict)
+    obj = sympify(str, locals=dct)
+
+    if assign_var and globals:
+        globals[assign_var] = obj
+
+    return obj

llmeval-env/lib/python3.10/site-packages/sympy/parsing/sym_expr.py

@@ -0,0 +1,279 @@
+from sympy.printing import pycode, ccode, fcode
+from sympy.external import import_module
+from sympy.utilities.decorator import doctest_depends_on
+
+lfortran = import_module('lfortran')
+cin = import_module('clang.cindex', import_kwargs = {'fromlist': ['cindex']})
+
+if lfortran:
+    from sympy.parsing.fortran.fortran_parser import src_to_sympy
+if cin:
+    from sympy.parsing.c.c_parser import parse_c
+
+@doctest_depends_on(modules=['lfortran', 'clang.cindex'])
+class SymPyExpression:  # type: ignore
+    """Class to store and handle SymPy expressions
+
+    This class will hold SymPy Expressions and handle the API for the
+    conversion to and from different languages.
+
+    It works with the C and the Fortran Parser to generate SymPy expressions
+    which are stored here and which can be converted to multiple language's
+    source code.
+
+    Notes
+    =====
+
+    The module and its API are currently under development and experimental
+    and can be changed during development.
+
+    The Fortran parser does not support numeric assignments, so all the
+    variables have been Initialized to zero.
+
+    The module also depends on external dependencies:
+
+    - LFortran which is required to use the Fortran parser
+    - Clang which is required for the C parser
+
+    Examples
+    ========
+
+    Example of parsing C code:
+
+    >>> from sympy.parsing.sym_expr import SymPyExpression
+    >>> src = '''
+    ... int a,b;
+    ... float c = 2, d =4;
+    ... '''
+    >>> a = SymPyExpression(src, 'c')
+    >>> a.return_expr()
+    [Declaration(Variable(a, type=intc)),
+    Declaration(Variable(b, type=intc)),
+    Declaration(Variable(c, type=float32, value=2.0)),
+    Declaration(Variable(d, type=float32, value=4.0))]
+
+    An example of variable definition:
+
+    >>> from sympy.parsing.sym_expr import SymPyExpression
+    >>> src2 = '''
+    ... integer :: a, b, c, d
+    ... real :: p, q, r, s
+    ... '''
+    >>> p = SymPyExpression()
+    >>> p.convert_to_expr(src2, 'f')
+    >>> p.convert_to_c()
+    ['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0']
+
+    An example of Assignment:
+
+    >>> from sympy.parsing.sym_expr import SymPyExpression
+    >>> src3 = '''
+    ... integer :: a, b, c, d, e
+    ... d = a + b - c
+    ... e = b * d + c * e / a
+    ... '''
+    >>> p = SymPyExpression(src3, 'f')
+    >>> p.convert_to_python()
+    ['a = 0', 'b = 0', 'c = 0', 'd = 0', 'e = 0', 'd = a + b - c', 'e = b*d + c*e/a']
+
+    An example of function definition:
+
+    >>> from sympy.parsing.sym_expr import SymPyExpression
+    >>> src = '''
+    ... integer function f(a,b)
+    ... integer, intent(in) :: a, b
+    ... integer :: r
+    ... end function
+    ... '''
+    >>> a = SymPyExpression(src, 'f')
+    >>> a.convert_to_python()
+    ['def f(a, b):\\n   f = 0\\n    r = 0\\n    return f']
+
+    """
+
+    def __init__(self, source_code = None, mode = None):
+        """Constructor for SymPyExpression class"""
+        super().__init__()
+        if not(mode or source_code):
+            self._expr = []
+        elif mode:
+            if source_code:
+                if mode.lower() == 'f':
+                    if lfortran:
+                        self._expr = src_to_sympy(source_code)
+                    else:
+                        raise ImportError("LFortran is not installed, cannot parse Fortran code")
+                elif mode.lower() == 'c':
+                    if cin:
+                        self._expr = parse_c(source_code)
+                    else:
+                        raise ImportError("Clang is not installed, cannot parse C code")
+                else:
+                    raise NotImplementedError(
+                        'Parser for specified language is not implemented'
+                    )
+            else:
+                raise ValueError('Source code not present')
+        else:
+            raise ValueError('Please specify a mode for conversion')
+
+    def convert_to_expr(self, src_code, mode):
+        """Converts the given source code to SymPy Expressions
+
+        Attributes
+        ==========
+
+        src_code : String
+            the source code or filename of the source code that is to be
+            converted
+
+        mode: String
+            the mode to determine which parser is to be used according to
+            the language of the source code
+            f or F for Fortran
+            c or C for C/C++
+
+        Examples
+        ========
+
+        >>> from sympy.parsing.sym_expr import SymPyExpression
+        >>> src3 = '''
+        ... integer function f(a,b) result(r)
+        ... integer, intent(in) :: a, b
+        ... integer :: x
+        ... r = a + b -x
+        ... end function
+        ... '''
+        >>> p = SymPyExpression()
+        >>> p.convert_to_expr(src3, 'f')
+        >>> p.return_expr()
+        [FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
+        Declaration(Variable(r, type=integer, value=0)),
+        Declaration(Variable(x, type=integer, value=0)),
+        Assignment(Variable(r), a + b - x),
+        Return(Variable(r))
+        ))]
+
+
+
+
+        """
+        if mode.lower() == 'f':
+            if lfortran:
+                self._expr = src_to_sympy(src_code)
+            else:
+                raise ImportError("LFortran is not installed, cannot parse Fortran code")
+        elif mode.lower() == 'c':
+            if cin:
+                self._expr = parse_c(src_code)
+            else:
+                raise ImportError("Clang is not installed, cannot parse C code")
+        else:
+            raise NotImplementedError(
+                "Parser for specified language has not been implemented"
+            )
+
+    def convert_to_python(self):
+        """Returns a list with Python code for the SymPy expressions
+
+        Examples
+        ========
+
+        >>> from sympy.parsing.sym_expr import SymPyExpression
+        >>> src2 = '''
+        ... integer :: a, b, c, d
+        ... real :: p, q, r, s
+        ... c = a/b
+        ... d = c/a
+        ... s = p/q
+        ... r = q/p
+        ... '''
+        >>> p = SymPyExpression(src2, 'f')
+        >>> p.convert_to_python()
+        ['a = 0', 'b = 0', 'c = 0', 'd = 0', 'p = 0.0', 'q = 0.0', 'r = 0.0', 's = 0.0', 'c = a/b', 'd = c/a', 's = p/q', 'r = q/p']
+
+        """
+        self._pycode = []
+        for iter in self._expr:
+            self._pycode.append(pycode(iter))
+        return self._pycode
+
+    def convert_to_c(self):
+        """Returns a list with the c source code for the SymPy expressions
+
+
+        Examples
+        ========
+
+        >>> from sympy.parsing.sym_expr import SymPyExpression
+        >>> src2 = '''
+        ... integer :: a, b, c, d
+        ... real :: p, q, r, s
+        ... c = a/b
+        ... d = c/a
+        ... s = p/q
+        ... r = q/p
+        ... '''
+        >>> p = SymPyExpression()
+        >>> p.convert_to_expr(src2, 'f')
+        >>> p.convert_to_c()
+        ['int a = 0', 'int b = 0', 'int c = 0', 'int d = 0', 'double p = 0.0', 'double q = 0.0', 'double r = 0.0', 'double s = 0.0', 'c = a/b;', 'd = c/a;', 's = p/q;', 'r = q/p;']
+
+        """
+        self._ccode = []
+        for iter in self._expr:
+            self._ccode.append(ccode(iter))
+        return self._ccode
+
+    def convert_to_fortran(self):
+        """Returns a list with the fortran source code for the SymPy expressions
+
+        Examples
+        ========
+
+        >>> from sympy.parsing.sym_expr import SymPyExpression
+        >>> src2 = '''
+        ... integer :: a, b, c, d
+        ... real :: p, q, r, s
+        ... c = a/b
+        ... d = c/a
+        ... s = p/q
+        ... r = q/p
+        ... '''
+        >>> p = SymPyExpression(src2, 'f')
+        >>> p.convert_to_fortran()
+        ['      integer*4 a', '      integer*4 b', '      integer*4 c', '      integer*4 d', '      real*8 p', '      real*8 q', '      real*8 r', '      real*8 s', '      c = a/b', '      d = c/a', '      s = p/q', '      r = q/p']
+
+        """
+        self._fcode = []
+        for iter in self._expr:
+            self._fcode.append(fcode(iter))
+        return self._fcode
+
+    def return_expr(self):
+        """Returns the expression list
+
+        Examples
+        ========
+
+        >>> from sympy.parsing.sym_expr import SymPyExpression
+        >>> src3 = '''
+        ... integer function f(a,b)
+        ... integer, intent(in) :: a, b
+        ... integer :: r
+        ... r = a+b
+        ... f = r
+        ... end function
+        ... '''
+        >>> p = SymPyExpression()
+        >>> p.convert_to_expr(src3, 'f')
+        >>> p.return_expr()
+        [FunctionDefinition(integer, name=f, parameters=(Variable(a), Variable(b)), body=CodeBlock(
+        Declaration(Variable(f, type=integer, value=0)),
+        Declaration(Variable(r, type=integer, value=0)),
+        Assignment(Variable(f), Variable(r)),
+        Return(Variable(f))
+        ))]
+
+        """
+        return self._expr

llmeval-env/lib/python3.10/site-packages/sympy/parsing/sympy_parser.py

@@ -0,0 +1,1264 @@
+"""Transform a string with Python-like source code into SymPy expression. """
+
+from tokenize import (generate_tokens, untokenize, TokenError,
+    NUMBER, STRING, NAME, OP, ENDMARKER, ERRORTOKEN, NEWLINE)
+
+from keyword import iskeyword
+
+import ast
+import unicodedata
+from io import StringIO
+import builtins
+import types
+from typing import Tuple as tTuple, Dict as tDict, Any, Callable, \
+    List, Optional, Union as tUnion
+
+from sympy.assumptions.ask import AssumptionKeys
+from sympy.core.basic import Basic
+from sympy.core import Symbol
+from sympy.core.function import Function
+from sympy.utilities.misc import func_name
+from sympy.functions.elementary.miscellaneous import Max, Min
+
+
+null = ''
+
+TOKEN = tTuple[int, str]
+DICT = tDict[str, Any]
+TRANS = Callable[[List[TOKEN], DICT, DICT], List[TOKEN]]
+
+def _token_splittable(token_name: str) -> bool:
+    """
+    Predicate for whether a token name can be split into multiple tokens.
+
+    A token is splittable if it does not contain an underscore character and
+    it is not the name of a Greek letter. This is used to implicitly convert
+    expressions like 'xyz' into 'x*y*z'.
+    """
+    if '_' in token_name:
+        return False
+    try:
+        return not unicodedata.lookup('GREEK SMALL LETTER ' + token_name)
+    except KeyError:
+        return len(token_name) > 1
+
+
+def _token_callable(token: TOKEN, local_dict: DICT, global_dict: DICT, nextToken=None):
+    """
+    Predicate for whether a token name represents a callable function.
+
+    Essentially wraps ``callable``, but looks up the token name in the
+    locals and globals.
+    """
+    func = local_dict.get(token[1])
+    if not func:
+        func = global_dict.get(token[1])
+    return callable(func) and not isinstance(func, Symbol)
+
+
+def _add_factorial_tokens(name: str, result: List[TOKEN]) -> List[TOKEN]:
+    if result == [] or result[-1][1] == '(':
+        raise TokenError()
+
+    beginning = [(NAME, name), (OP, '(')]
+    end = [(OP, ')')]
+
+    diff = 0
+    length = len(result)
+
+    for index, token in enumerate(result[::-1]):
+        toknum, tokval = token
+        i = length - index - 1
+
+        if tokval == ')':
+            diff += 1
+        elif tokval == '(':
+            diff -= 1
+
+        if diff == 0:
+            if i - 1 >= 0 and result[i - 1][0] == NAME:
+                return result[:i - 1] + beginning + result[i - 1:] + end
+            else:
+                return result[:i] + beginning + result[i:] + end
+
+    return result
+
+
+class ParenthesisGroup(List[TOKEN]):
+    """List of tokens representing an expression in parentheses."""
+    pass
+
+
+class AppliedFunction:
+    """
+    A group of tokens representing a function and its arguments.
+
+    `exponent` is for handling the shorthand sin^2, ln^2, etc.
+    """
+    def __init__(self, function: TOKEN, args: ParenthesisGroup, exponent=None):
+        if exponent is None:
+            exponent = []
+        self.function = function
+        self.args = args
+        self.exponent = exponent
+        self.items = ['function', 'args', 'exponent']
+
+    def expand(self) -> List[TOKEN]:
+        """Return a list of tokens representing the function"""
+        return [self.function, *self.args]
+
+    def __getitem__(self, index):
+        return getattr(self, self.items[index])
+
+    def __repr__(self):
+        return "AppliedFunction(%s, %s, %s)" % (self.function, self.args,
+                                                self.exponent)
+
+
+def _flatten(result: List[tUnion[TOKEN, AppliedFunction]]):
+    result2: List[TOKEN] = []
+    for tok in result:
+        if isinstance(tok, AppliedFunction):
+            result2.extend(tok.expand())
+        else:
+            result2.append(tok)
+    return result2
+
+
+def _group_parentheses(recursor: TRANS):
+    def _inner(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+        """Group tokens between parentheses with ParenthesisGroup.
+
+        Also processes those tokens recursively.
+
+        """
+        result: List[tUnion[TOKEN, ParenthesisGroup]] = []
+        stacks: List[ParenthesisGroup] = []
+        stacklevel = 0
+        for token in tokens:
+            if token[0] == OP:
+                if token[1] == '(':
+                    stacks.append(ParenthesisGroup([]))
+                    stacklevel += 1
+                elif token[1] == ')':
+                    stacks[-1].append(token)
+                    stack = stacks.pop()
+
+                    if len(stacks) > 0:
+                        # We don't recurse here since the upper-level stack
+                        # would reprocess these tokens
+                        stacks[-1].extend(stack)
+                    else:
+                        # Recurse here to handle nested parentheses
+                        # Strip off the outer parentheses to avoid an infinite loop
+                        inner = stack[1:-1]
+                        inner = recursor(inner,
+                                         local_dict,
+                                         global_dict)
+                        parenGroup = [stack[0]] + inner + [stack[-1]]
+                        result.append(ParenthesisGroup(parenGroup))
+                    stacklevel -= 1
+                    continue
+            if stacklevel:
+                stacks[-1].append(token)
+            else:
+                result.append(token)
+        if stacklevel:
+            raise TokenError("Mismatched parentheses")
+        return result
+    return _inner
+
+
+def _apply_functions(tokens: List[tUnion[TOKEN, ParenthesisGroup]], local_dict: DICT, global_dict: DICT):
+    """Convert a NAME token + ParenthesisGroup into an AppliedFunction.
+
+    Note that ParenthesisGroups, if not applied to any function, are
+    converted back into lists of tokens.
+
+    """
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    symbol = None
+    for tok in tokens:
+        if isinstance(tok, ParenthesisGroup):
+            if symbol and _token_callable(symbol, local_dict, global_dict):
+                result[-1] = AppliedFunction(symbol, tok)
+                symbol = None
+            else:
+                result.extend(tok)
+        elif tok[0] == NAME:
+            symbol = tok
+            result.append(tok)
+        else:
+            symbol = None
+            result.append(tok)
+    return result
+
+
+def _implicit_multiplication(tokens: List[tUnion[TOKEN, AppliedFunction]], local_dict: DICT, global_dict: DICT):
+    """Implicitly adds '*' tokens.
+
+    Cases:
+
+    - Two AppliedFunctions next to each other ("sin(x)cos(x)")
+
+    - AppliedFunction next to an open parenthesis ("sin x (cos x + 1)")
+
+    - A close parenthesis next to an AppliedFunction ("(x+2)sin x")\
+
+    - A close parenthesis next to an open parenthesis ("(x+2)(x+3)")
+
+    - AppliedFunction next to an implicitly applied function ("sin(x)cos x")
+
+    """
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    skip = False
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        result.append(tok)
+        if skip:
+            skip = False
+            continue
+        if tok[0] == OP and tok[1] == '.' and nextTok[0] == NAME:
+            # Dotted name. Do not do implicit multiplication
+            skip = True
+            continue
+        if isinstance(tok, AppliedFunction):
+            if isinstance(nextTok, AppliedFunction):
+                result.append((OP, '*'))
+            elif nextTok == (OP, '('):
+                # Applied function followed by an open parenthesis
+                if tok.function[1] == "Function":
+                    tok.function = (tok.function[0], 'Symbol')
+                result.append((OP, '*'))
+            elif nextTok[0] == NAME:
+                # Applied function followed by implicitly applied function
+                result.append((OP, '*'))
+        else:
+            if tok == (OP, ')'):
+                if isinstance(nextTok, AppliedFunction):
+                    # Close parenthesis followed by an applied function
+                    result.append((OP, '*'))
+                elif nextTok[0] == NAME:
+                    # Close parenthesis followed by an implicitly applied function
+                    result.append((OP, '*'))
+                elif nextTok == (OP, '('):
+                    # Close parenthesis followed by an open parenthesis
+                    result.append((OP, '*'))
+            elif tok[0] == NAME and not _token_callable(tok, local_dict, global_dict):
+                if isinstance(nextTok, AppliedFunction) or \
+                    (nextTok[0] == NAME and _token_callable(nextTok, local_dict, global_dict)):
+                    # Constant followed by (implicitly applied) function
+                    result.append((OP, '*'))
+                elif nextTok == (OP, '('):
+                    # Constant followed by parenthesis
+                    result.append((OP, '*'))
+                elif nextTok[0] == NAME:
+                    # Constant followed by constant
+                    result.append((OP, '*'))
+    if tokens:
+        result.append(tokens[-1])
+    return result
+
+
+def _implicit_application(tokens: List[tUnion[TOKEN, AppliedFunction]], local_dict: DICT, global_dict: DICT):
+    """Adds parentheses as needed after functions."""
+    result: List[tUnion[TOKEN, AppliedFunction]] = []
+    appendParen = 0  # number of closing parentheses to add
+    skip = 0  # number of tokens to delay before adding a ')' (to
+              # capture **, ^, etc.)
+    exponentSkip = False  # skipping tokens before inserting parentheses to
+                          # work with function exponentiation
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        result.append(tok)
+        if (tok[0] == NAME and nextTok[0] not in [OP, ENDMARKER, NEWLINE]):
+            if _token_callable(tok, local_dict, global_dict, nextTok):  # type: ignore
+                result.append((OP, '('))
+                appendParen += 1
+        # name followed by exponent - function exponentiation
+        elif (tok[0] == NAME and nextTok[0] == OP and nextTok[1] == '**'):
+            if _token_callable(tok, local_dict, global_dict):  # type: ignore
+                exponentSkip = True
+        elif exponentSkip:
+            # if the last token added was an applied function (i.e. the
+            # power of the function exponent) OR a multiplication (as
+            # implicit multiplication would have added an extraneous
+            # multiplication)
+            if (isinstance(tok, AppliedFunction)
+                or (tok[0] == OP and tok[1] == '*')):
+                # don't add anything if the next token is a multiplication
+                # or if there's already a parenthesis (if parenthesis, still
+                # stop skipping tokens)
+                if not (nextTok[0] == OP and nextTok[1] == '*'):
+                    if not(nextTok[0] == OP and nextTok[1] == '('):
+                        result.append((OP, '('))
+                        appendParen += 1
+                    exponentSkip = False
+        elif appendParen:
+            if nextTok[0] == OP and nextTok[1] in ('^', '**', '*'):
+                skip = 1
+                continue
+            if skip:
+                skip -= 1
+                continue
+            result.append((OP, ')'))
+            appendParen -= 1
+
+    if tokens:
+        result.append(tokens[-1])
+
+    if appendParen:
+        result.extend([(OP, ')')] * appendParen)
+    return result
+
+
+def function_exponentiation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Allows functions to be exponentiated, e.g. ``cos**2(x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, function_exponentiation)
+    >>> transformations = standard_transformations + (function_exponentiation,)
+    >>> parse_expr('sin**4(x)', transformations=transformations)
+    sin(x)**4
+    """
+    result: List[TOKEN] = []
+    exponent: List[TOKEN] = []
+    consuming_exponent = False
+    level = 0
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        if tok[0] == NAME and nextTok[0] == OP and nextTok[1] == '**':
+            if _token_callable(tok, local_dict, global_dict):
+                consuming_exponent = True
+        elif consuming_exponent:
+            if tok[0] == NAME and tok[1] == 'Function':
+                tok = (NAME, 'Symbol')
+            exponent.append(tok)
+
+            # only want to stop after hitting )
+            if tok[0] == nextTok[0] == OP and tok[1] == ')' and nextTok[1] == '(':
+                consuming_exponent = False
+            # if implicit multiplication was used, we may have )*( instead
+            if tok[0] == nextTok[0] == OP and tok[1] == '*' and nextTok[1] == '(':
+                consuming_exponent = False
+                del exponent[-1]
+            continue
+        elif exponent and not consuming_exponent:
+            if tok[0] == OP:
+                if tok[1] == '(':
+                    level += 1
+                elif tok[1] == ')':
+                    level -= 1
+            if level == 0:
+                result.append(tok)
+                result.extend(exponent)
+                exponent = []
+                continue
+        result.append(tok)
+    if tokens:
+        result.append(tokens[-1])
+    if exponent:
+        result.extend(exponent)
+    return result
+
+
+def split_symbols_custom(predicate: Callable[[str], bool]):
+    """Creates a transformation that splits symbol names.
+
+    ``predicate`` should return True if the symbol name is to be split.
+
+    For instance, to retain the default behavior but avoid splitting certain
+    symbol names, a predicate like this would work:
+
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr, _token_splittable,
+    ... standard_transformations, implicit_multiplication,
+    ... split_symbols_custom)
+    >>> def can_split(symbol):
+    ...     if symbol not in ('list', 'of', 'unsplittable', 'names'):
+    ...             return _token_splittable(symbol)
+    ...     return False
+    ...
+    >>> transformation = split_symbols_custom(can_split)
+    >>> parse_expr('unsplittable', transformations=standard_transformations +
+    ... (transformation, implicit_multiplication))
+    unsplittable
+    """
+    def _split_symbols(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+        result: List[TOKEN] = []
+        split = False
+        split_previous=False
+
+        for tok in tokens:
+            if split_previous:
+                # throw out closing parenthesis of Symbol that was split
+                split_previous=False
+                continue
+            split_previous=False
+
+            if tok[0] == NAME and tok[1] in ['Symbol', 'Function']:
+                split = True
+
+            elif split and tok[0] == NAME:
+                symbol = tok[1][1:-1]
+
+                if predicate(symbol):
+                    tok_type = result[-2][1]  # Symbol or Function
+                    del result[-2:]  # Get rid of the call to Symbol
+
+                    i = 0
+                    while i < len(symbol):
+                        char = symbol[i]
+                        if char in local_dict or char in global_dict:
+                            result.append((NAME, "%s" % char))
+                        elif char.isdigit():
+                            chars = [char]
+                            for i in range(i + 1, len(symbol)):
+                                if not symbol[i].isdigit():
+                                  i -= 1
+                                  break
+                                chars.append(symbol[i])
+                            char = ''.join(chars)
+                            result.extend([(NAME, 'Number'), (OP, '('),
+                                           (NAME, "'%s'" % char), (OP, ')')])
+                        else:
+                            use = tok_type if i == len(symbol) else 'Symbol'
+                            result.extend([(NAME, use), (OP, '('),
+                                           (NAME, "'%s'" % char), (OP, ')')])
+                        i += 1
+
+                    # Set split_previous=True so will skip
+                    # the closing parenthesis of the original Symbol
+                    split = False
+                    split_previous = True
+                    continue
+
+                else:
+                    split = False
+
+            result.append(tok)
+
+        return result
+
+    return _split_symbols
+
+
+#: Splits symbol names for implicit multiplication.
+#:
+#: Intended to let expressions like ``xyz`` be parsed as ``x*y*z``. Does not
+#: split Greek character names, so ``theta`` will *not* become
+#: ``t*h*e*t*a``. Generally this should be used with
+#: ``implicit_multiplication``.
+split_symbols = split_symbols_custom(_token_splittable)
+
+
+def implicit_multiplication(tokens: List[TOKEN], local_dict: DICT,
+                            global_dict: DICT) -> List[TOKEN]:
+    """Makes the multiplication operator optional in most cases.
+
+    Use this before :func:`implicit_application`, otherwise expressions like
+    ``sin 2x`` will be parsed as ``x * sin(2)`` rather than ``sin(2*x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_multiplication)
+    >>> transformations = standard_transformations + (implicit_multiplication,)
+    >>> parse_expr('3 x y', transformations=transformations)
+    3*x*y
+    """
+    # These are interdependent steps, so we don't expose them separately
+    res1 = _group_parentheses(implicit_multiplication)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _implicit_multiplication(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+def implicit_application(tokens: List[TOKEN], local_dict: DICT,
+                         global_dict: DICT) -> List[TOKEN]:
+    """Makes parentheses optional in some cases for function calls.
+
+    Use this after :func:`implicit_multiplication`, otherwise expressions
+    like ``sin 2x`` will be parsed as ``x * sin(2)`` rather than
+    ``sin(2*x)``.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_application)
+    >>> transformations = standard_transformations + (implicit_application,)
+    >>> parse_expr('cot z + csc z', transformations=transformations)
+    cot(z) + csc(z)
+    """
+    res1 = _group_parentheses(implicit_application)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _implicit_application(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+def implicit_multiplication_application(result: List[TOKEN], local_dict: DICT,
+                                        global_dict: DICT) -> List[TOKEN]:
+    """Allows a slightly relaxed syntax.
+
+    - Parentheses for single-argument method calls are optional.
+
+    - Multiplication is implicit.
+
+    - Symbol names can be split (i.e. spaces are not needed between
+      symbols).
+
+    - Functions can be exponentiated.
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, implicit_multiplication_application)
+    >>> parse_expr("10sin**2 x**2 + 3xyz + tan theta",
+    ... transformations=(standard_transformations +
+    ... (implicit_multiplication_application,)))
+    3*x*y*z + 10*sin(x**2)**2 + tan(theta)
+
+    """
+    for step in (split_symbols, implicit_multiplication,
+                 implicit_application, function_exponentiation):
+        result = step(result, local_dict, global_dict)
+
+    return result
+
+
+def auto_symbol(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Inserts calls to ``Symbol``/``Function`` for undefined variables."""
+    result: List[TOKEN] = []
+    prevTok = (-1, '')
+
+    tokens.append((-1, ''))  # so zip traverses all tokens
+    for tok, nextTok in zip(tokens, tokens[1:]):
+        tokNum, tokVal = tok
+        nextTokNum, nextTokVal = nextTok
+        if tokNum == NAME:
+            name = tokVal
+
+            if (name in ['True', 'False', 'None']
+                    or iskeyword(name)
+                    # Don't convert attribute access
+                    or (prevTok[0] == OP and prevTok[1] == '.')
+                    # Don't convert keyword arguments
+                    or (prevTok[0] == OP and prevTok[1] in ('(', ',')
+                        and nextTokNum == OP and nextTokVal == '=')
+                    # the name has already been defined
+                    or name in local_dict and local_dict[name] is not null):
+                result.append((NAME, name))
+                continue
+            elif name in local_dict:
+                local_dict.setdefault(null, set()).add(name)
+                if nextTokVal == '(':
+                    local_dict[name] = Function(name)
+                else:
+                    local_dict[name] = Symbol(name)
+                result.append((NAME, name))
+                continue
+            elif name in global_dict:
+                obj = global_dict[name]
+                if isinstance(obj, (AssumptionKeys, Basic, type)) or callable(obj):
+                    result.append((NAME, name))
+                    continue
+
+            result.extend([
+                (NAME, 'Symbol' if nextTokVal != '(' else 'Function'),
+                (OP, '('),
+                (NAME, repr(str(name))),
+                (OP, ')'),
+            ])
+        else:
+            result.append((tokNum, tokVal))
+
+        prevTok = (tokNum, tokVal)
+
+    return result
+
+
+def lambda_notation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Substitutes "lambda" with its SymPy equivalent Lambda().
+    However, the conversion does not take place if only "lambda"
+    is passed because that is a syntax error.
+
+    """
+    result: List[TOKEN] = []
+    flag = False
+    toknum, tokval = tokens[0]
+    tokLen = len(tokens)
+
+    if toknum == NAME and tokval == 'lambda':
+        if tokLen == 2 or tokLen == 3 and tokens[1][0] == NEWLINE:
+            # In Python 3.6.7+, inputs without a newline get NEWLINE added to
+            # the tokens
+            result.extend(tokens)
+        elif tokLen > 2:
+            result.extend([
+                (NAME, 'Lambda'),
+                (OP, '('),
+                (OP, '('),
+                (OP, ')'),
+                (OP, ')'),
+            ])
+            for tokNum, tokVal in tokens[1:]:
+                if tokNum == OP and tokVal == ':':
+                    tokVal = ','
+                    flag = True
+                if not flag and tokNum == OP and tokVal in ('*', '**'):
+                    raise TokenError("Starred arguments in lambda not supported")
+                if flag:
+                    result.insert(-1, (tokNum, tokVal))
+                else:
+                    result.insert(-2, (tokNum, tokVal))
+    else:
+        result.extend(tokens)
+
+    return result
+
+
+def factorial_notation(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Allows standard notation for factorial."""
+    result: List[TOKEN] = []
+    nfactorial = 0
+    for toknum, tokval in tokens:
+        if toknum == ERRORTOKEN:
+            op = tokval
+            if op == '!':
+                nfactorial += 1
+            else:
+                nfactorial = 0
+                result.append((OP, op))
+        else:
+            if nfactorial == 1:
+                result = _add_factorial_tokens('factorial', result)
+            elif nfactorial == 2:
+                result = _add_factorial_tokens('factorial2', result)
+            elif nfactorial > 2:
+                raise TokenError
+            nfactorial = 0
+            result.append((toknum, tokval))
+    return result
+
+
+def convert_xor(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Treats XOR, ``^``, as exponentiation, ``**``."""
+    result: List[TOKEN] = []
+    for toknum, tokval in tokens:
+        if toknum == OP:
+            if tokval == '^':
+                result.append((OP, '**'))
+            else:
+                result.append((toknum, tokval))
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def repeated_decimals(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """
+    Allows 0.2[1] notation to represent the repeated decimal 0.2111... (19/90)
+
+    Run this before auto_number.
+
+    """
+    result: List[TOKEN] = []
+
+    def is_digit(s):
+        return all(i in '0123456789_' for i in s)
+
+    # num will running match any DECIMAL [ INTEGER ]
+    num: List[TOKEN] = []
+    for toknum, tokval in tokens:
+        if toknum == NUMBER:
+            if (not num and '.' in tokval and 'e' not in tokval.lower() and
+                'j' not in tokval.lower()):
+                num.append((toknum, tokval))
+            elif is_digit(tokval)and  len(num) == 2:
+                num.append((toknum, tokval))
+            elif is_digit(tokval) and len(num) == 3 and is_digit(num[-1][1]):
+                # Python 2 tokenizes 00123 as '00', '123'
+                # Python 3 tokenizes 01289 as '012', '89'
+                num.append((toknum, tokval))
+            else:
+                num = []
+        elif toknum == OP:
+            if tokval == '[' and len(num) == 1:
+                num.append((OP, tokval))
+            elif tokval == ']' and len(num) >= 3:
+                num.append((OP, tokval))
+            elif tokval == '.' and not num:
+                # handle .[1]
+                num.append((NUMBER, '0.'))
+            else:
+                num = []
+        else:
+            num = []
+
+        result.append((toknum, tokval))
+
+        if num and num[-1][1] == ']':
+            # pre.post[repetend] = a + b/c + d/e where a = pre, b/c = post,
+            # and d/e = repetend
+            result = result[:-len(num)]
+            pre, post = num[0][1].split('.')
+            repetend = num[2][1]
+            if len(num) == 5:
+                repetend += num[3][1]
+
+            pre = pre.replace('_', '')
+            post = post.replace('_', '')
+            repetend = repetend.replace('_', '')
+
+            zeros = '0'*len(post)
+            post, repetends = [w.lstrip('0') for w in [post, repetend]]
+                                        # or else interpreted as octal
+
+            a = pre or '0'
+            b, c = post or '0', '1' + zeros
+            d, e = repetends, ('9'*len(repetend)) + zeros
+
+            seq = [
+                (OP, '('),
+                    (NAME, 'Integer'),
+                    (OP, '('),
+                        (NUMBER, a),
+                    (OP, ')'),
+                    (OP, '+'),
+                    (NAME, 'Rational'),
+                    (OP, '('),
+                        (NUMBER, b),
+                        (OP, ','),
+                        (NUMBER, c),
+                    (OP, ')'),
+                    (OP, '+'),
+                    (NAME, 'Rational'),
+                    (OP, '('),
+                        (NUMBER, d),
+                        (OP, ','),
+                        (NUMBER, e),
+                    (OP, ')'),
+                (OP, ')'),
+            ]
+            result.extend(seq)
+            num = []
+
+    return result
+
+
+def auto_number(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """
+    Converts numeric literals to use SymPy equivalents.
+
+    Complex numbers use ``I``, integer literals use ``Integer``, and float
+    literals use ``Float``.
+
+    """
+    result: List[TOKEN] = []
+
+    for toknum, tokval in tokens:
+        if toknum == NUMBER:
+            number = tokval
+            postfix = []
+
+            if number.endswith('j') or number.endswith('J'):
+                number = number[:-1]
+                postfix = [(OP, '*'), (NAME, 'I')]
+
+            if '.' in number or (('e' in number or 'E' in number) and
+                    not (number.startswith('0x') or number.startswith('0X'))):
+                seq = [(NAME, 'Float'), (OP, '('),
+                    (NUMBER, repr(str(number))), (OP, ')')]
+            else:
+                seq = [(NAME, 'Integer'), (OP, '('), (
+                    NUMBER, number), (OP, ')')]
+
+            result.extend(seq + postfix)
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def rationalize(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Converts floats into ``Rational``. Run AFTER ``auto_number``."""
+    result: List[TOKEN] = []
+    passed_float = False
+    for toknum, tokval in tokens:
+        if toknum == NAME:
+            if tokval == 'Float':
+                passed_float = True
+                tokval = 'Rational'
+            result.append((toknum, tokval))
+        elif passed_float == True and toknum == NUMBER:
+            passed_float = False
+            result.append((STRING, tokval))
+        else:
+            result.append((toknum, tokval))
+
+    return result
+
+
+def _transform_equals_sign(tokens: List[TOKEN], local_dict: DICT, global_dict: DICT):
+    """Transforms the equals sign ``=`` to instances of Eq.
+
+    This is a helper function for ``convert_equals_signs``.
+    Works with expressions containing one equals sign and no
+    nesting. Expressions like ``(1=2)=False`` will not work with this
+    and should be used with ``convert_equals_signs``.
+
+    Examples: 1=2     to Eq(1,2)
+              1*2=x   to Eq(1*2, x)
+
+    This does not deal with function arguments yet.
+
+    """
+    result: List[TOKEN] = []
+    if (OP, "=") in tokens:
+        result.append((NAME, "Eq"))
+        result.append((OP, "("))
+        for token in tokens:
+            if token == (OP, "="):
+                result.append((OP, ","))
+                continue
+            result.append(token)
+        result.append((OP, ")"))
+    else:
+        result = tokens
+    return result
+
+
+def convert_equals_signs(tokens: List[TOKEN], local_dict: DICT,
+                         global_dict: DICT) -> List[TOKEN]:
+    """ Transforms all the equals signs ``=`` to instances of Eq.
+
+    Parses the equals signs in the expression and replaces them with
+    appropriate Eq instances. Also works with nested equals signs.
+
+    Does not yet play well with function arguments.
+    For example, the expression ``(x=y)`` is ambiguous and can be interpreted
+    as x being an argument to a function and ``convert_equals_signs`` will not
+    work for this.
+
+    See also
+    ========
+    convert_equality_operators
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import (parse_expr,
+    ... standard_transformations, convert_equals_signs)
+    >>> parse_expr("1*2=x", transformations=(
+    ... standard_transformations + (convert_equals_signs,)))
+    Eq(2, x)
+    >>> parse_expr("(1*2=x)=False", transformations=(
+    ... standard_transformations + (convert_equals_signs,)))
+    Eq(Eq(2, x), False)
+
+    """
+    res1 = _group_parentheses(convert_equals_signs)(tokens, local_dict, global_dict)
+    res2 = _apply_functions(res1, local_dict, global_dict)
+    res3 = _transform_equals_sign(res2, local_dict, global_dict)
+    result = _flatten(res3)
+    return result
+
+
+#: Standard transformations for :func:`parse_expr`.
+#: Inserts calls to :class:`~.Symbol`, :class:`~.Integer`, and other SymPy
+#: datatypes and allows the use of standard factorial notation (e.g. ``x!``).
+standard_transformations: tTuple[TRANS, ...] \
+    = (lambda_notation, auto_symbol, repeated_decimals, auto_number,
+       factorial_notation)
+
+
+def stringify_expr(s: str, local_dict: DICT, global_dict: DICT,
+        transformations: tTuple[TRANS, ...]) -> str:
+    """
+    Converts the string ``s`` to Python code, in ``local_dict``
+
+    Generally, ``parse_expr`` should be used.
+    """
+
+    tokens = []
+    input_code = StringIO(s.strip())
+    for toknum, tokval, _, _, _ in generate_tokens(input_code.readline):
+        tokens.append((toknum, tokval))
+
+    for transform in transformations:
+        tokens = transform(tokens, local_dict, global_dict)
+
+    return untokenize(tokens)
+
+
+def eval_expr(code, local_dict: DICT, global_dict: DICT):
+    """
+    Evaluate Python code generated by ``stringify_expr``.
+
+    Generally, ``parse_expr`` should be used.
+    """
+    expr = eval(
+        code, global_dict, local_dict)  # take local objects in preference
+    return expr
+
+
+def parse_expr(s: str, local_dict: Optional[DICT] = None,
+               transformations: tUnion[tTuple[TRANS, ...], str] \
+                   = standard_transformations,
+               global_dict: Optional[DICT] = None, evaluate=True):
+    """Converts the string ``s`` to a SymPy expression, in ``local_dict``.
+
+    Parameters
+    ==========
+
+    s : str
+        The string to parse.
+
+    local_dict : dict, optional
+        A dictionary of local variables to use when parsing.
+
+    global_dict : dict, optional
+        A dictionary of global variables. By default, this is initialized
+        with ``from sympy import *``; provide this parameter to override
+        this behavior (for instance, to parse ``"Q & S"``).
+
+    transformations : tuple or str
+        A tuple of transformation functions used to modify the tokens of the
+        parsed expression before evaluation. The default transformations
+        convert numeric literals into their SymPy equivalents, convert
+        undefined variables into SymPy symbols, and allow the use of standard
+        mathematical factorial notation (e.g. ``x!``). Selection via
+        string is available (see below).
+
+    evaluate : bool, optional
+        When False, the order of the arguments will remain as they were in the
+        string and automatic simplification that would normally occur is
+        suppressed. (see examples)
+
+    Examples
+    ========
+
+    >>> from sympy.parsing.sympy_parser import parse_expr
+    >>> parse_expr("1/2")
+    1/2
+    >>> type(_)
+    <class 'sympy.core.numbers.Half'>
+    >>> from sympy.parsing.sympy_parser import standard_transformations,\\
+    ... implicit_multiplication_application
+    >>> transformations = (standard_transformations +
+    ...     (implicit_multiplication_application,))
+    >>> parse_expr("2x", transformations=transformations)
+    2*x
+
+    When evaluate=False, some automatic simplifications will not occur:
+
+    >>> parse_expr("2**3"), parse_expr("2**3", evaluate=False)
+    (8, 2**3)
+
+    In addition the order of the arguments will not be made canonical.
+    This feature allows one to tell exactly how the expression was entered:
+
+    >>> a = parse_expr('1 + x', evaluate=False)
+    >>> b = parse_expr('x + 1', evaluate=0)
+    >>> a == b
+    False
+    >>> a.args
+    (1, x)
+    >>> b.args
+    (x, 1)
+
+    Note, however, that when these expressions are printed they will
+    appear the same:
+
+    >>> assert str(a) == str(b)
+
+    As a convenience, transformations can be seen by printing ``transformations``:
+
+    >>> from sympy.parsing.sympy_parser import transformations
+
+    >>> print(transformations)
+    0: lambda_notation
+    1: auto_symbol
+    2: repeated_decimals
+    3: auto_number
+    4: factorial_notation
+    5: implicit_multiplication_application
+    6: convert_xor
+    7: implicit_application
+    8: implicit_multiplication
+    9: convert_equals_signs
+    10: function_exponentiation
+    11: rationalize
+
+    The ``T`` object provides a way to select these transformations:
+
+    >>> from sympy.parsing.sympy_parser import T
+
+    If you print it, you will see the same list as shown above.
+
+    >>> str(T) == str(transformations)
+    True
+
+    Standard slicing will return a tuple of transformations:
+
+    >>> T[:5] == standard_transformations
+    True
+
+    So ``T`` can be used to specify the parsing transformations:
+
+    >>> parse_expr("2x", transformations=T[:5])
+    Traceback (most recent call last):
+    ...
+    SyntaxError: invalid syntax
+    >>> parse_expr("2x", transformations=T[:6])
+    2*x
+    >>> parse_expr('.3', transformations=T[3, 11])
+    3/10
+    >>> parse_expr('.3x', transformations=T[:])
+    3*x/10
+
+    As a further convenience, strings 'implicit' and 'all' can be used
+    to select 0-5 and all the transformations, respectively.
+
+    >>> parse_expr('.3x', transformations='all')
+    3*x/10
+
+    See Also
+    ========
+
+    stringify_expr, eval_expr, standard_transformations,
+    implicit_multiplication_application
+
+    """
+
+    if local_dict is None:
+        local_dict = {}
+    elif not isinstance(local_dict, dict):
+        raise TypeError('expecting local_dict to be a dict')
+    elif null in local_dict:
+        raise ValueError('cannot use "" in local_dict')
+
+    if global_dict is None:
+        global_dict = {}
+        exec('from sympy import *', global_dict)
+
+        builtins_dict = vars(builtins)
+        for name, obj in builtins_dict.items():
+            if isinstance(obj, types.BuiltinFunctionType):
+                global_dict[name] = obj
+        global_dict['max'] = Max
+        global_dict['min'] = Min
+
+    elif not isinstance(global_dict, dict):
+        raise TypeError('expecting global_dict to be a dict')
+
+    transformations = transformations or ()
+    if isinstance(transformations, str):
+        if transformations == 'all':
+            _transformations = T[:]
+        elif transformations == 'implicit':
+            _transformations = T[:6]
+        else:
+            raise ValueError('unknown transformation group name')
+    else:
+        _transformations = transformations
+
+    code = stringify_expr(s, local_dict, global_dict, _transformations)
+
+    if not evaluate:
+        code = compile(evaluateFalse(code), '<string>', 'eval') # type: ignore
+
+    try:
+        rv = eval_expr(code, local_dict, global_dict)
+        # restore neutral definitions for names
+        for i in local_dict.pop(null, ()):
+            local_dict[i] = null
+        return rv
+    except Exception as e:
+        # restore neutral definitions for names
+        for i in local_dict.pop(null, ()):
+            local_dict[i] = null
+        raise e from ValueError(f"Error from parse_expr with transformed code: {code!r}")
+
+
+def evaluateFalse(s: str):
+    """
+    Replaces operators with the SymPy equivalent and sets evaluate=False.
+    """
+    node = ast.parse(s)
+    transformed_node = EvaluateFalseTransformer().visit(node)
+    # node is a Module, we want an Expression
+    transformed_node = ast.Expression(transformed_node.body[0].value)
+
+    return ast.fix_missing_locations(transformed_node)
+
+
+class EvaluateFalseTransformer(ast.NodeTransformer):
+    operators = {
+        ast.Add: 'Add',
+        ast.Mult: 'Mul',
+        ast.Pow: 'Pow',
+        ast.Sub: 'Add',
+        ast.Div: 'Mul',
+        ast.BitOr: 'Or',
+        ast.BitAnd: 'And',
+        ast.BitXor: 'Not',
+    }
+    functions = (
+        'Abs', 'im', 're', 'sign', 'arg', 'conjugate',
+        'acos', 'acot', 'acsc', 'asec', 'asin', 'atan',
+        'acosh', 'acoth', 'acsch', 'asech', 'asinh', 'atanh',
+        'cos', 'cot', 'csc', 'sec', 'sin', 'tan',
+        'cosh', 'coth', 'csch', 'sech', 'sinh', 'tanh',
+        'exp', 'ln', 'log', 'sqrt', 'cbrt',
+    )
+
+    relational_operators = {
+        ast.NotEq: 'Ne',
+        ast.Lt: 'Lt',
+        ast.LtE: 'Le',
+        ast.Gt: 'Gt',
+        ast.GtE: 'Ge',
+        ast.Eq: 'Eq'
+    }
+    def visit_Compare(self, node):
+        if node.ops[0].__class__ in self.relational_operators:
+            sympy_class = self.relational_operators[node.ops[0].__class__]
+            right = self.visit(node.comparators[0])
+            left = self.visit(node.left)
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                keywords=[ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load()))],
+                starargs=None,
+                kwargs=None
+            )
+            return new_node
+        return node
+
+    def flatten(self, args, func):
+        result = []
+        for arg in args:
+            if isinstance(arg, ast.Call):
+                arg_func = arg.func
+                if isinstance(arg_func, ast.Call):
+                    arg_func = arg_func.func
+                if arg_func.id == func:
+                    result.extend(self.flatten(arg.args, func))
+                else:
+                    result.append(arg)
+            else:
+                result.append(arg)
+        return result
+
+    def visit_BinOp(self, node):
+        if node.op.__class__ in self.operators:
+            sympy_class = self.operators[node.op.__class__]
+            right = self.visit(node.right)
+            left = self.visit(node.left)
+
+            rev = False
+            if isinstance(node.op, ast.Sub):
+                right = ast.Call(
+                    func=ast.Name(id='Mul', ctx=ast.Load()),
+                    args=[ast.UnaryOp(op=ast.USub(), operand=ast.Num(1)), right],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load()))],
+                    starargs=None,
+                    kwargs=None
+                )
+            elif isinstance(node.op, ast.Div):
+                if isinstance(node.left, ast.UnaryOp):
+                    left, right = right, left
+                    rev = True
+                    left = ast.Call(
+                    func=ast.Name(id='Pow', ctx=ast.Load()),
+                    args=[left, ast.UnaryOp(op=ast.USub(), operand=ast.Num(1))],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load()))],
+                    starargs=None,
+                    kwargs=None
+                )
+                else:
+                    right = ast.Call(
+                    func=ast.Name(id='Pow', ctx=ast.Load()),
+                    args=[right, ast.UnaryOp(op=ast.USub(), operand=ast.Num(1))],
+                    keywords=[ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load()))],
+                    starargs=None,
+                    kwargs=None
+                )
+
+            if rev:  # undo reversal
+                left, right = right, left
+            new_node = ast.Call(
+                func=ast.Name(id=sympy_class, ctx=ast.Load()),
+                args=[left, right],
+                keywords=[ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load()))],
+                starargs=None,
+                kwargs=None
+            )
+
+            if sympy_class in ('Add', 'Mul'):
+                # Denest Add or Mul as appropriate
+                new_node.args = self.flatten(new_node.args, sympy_class)
+
+            return new_node
+        return node
+
+    def visit_Call(self, node):
+        new_node = self.generic_visit(node)
+        if isinstance(node.func, ast.Name) and node.func.id in self.functions:
+            new_node.keywords.append(ast.keyword(arg='evaluate', value=ast.NameConstant(value=False, ctx=ast.Load())))
+        return new_node
+
+
+_transformation = {  # items can be added but never re-ordered
+0: lambda_notation,
+1: auto_symbol,
+2: repeated_decimals,
+3: auto_number,
+4: factorial_notation,
+5: implicit_multiplication_application,
+6: convert_xor,
+7: implicit_application,
+8: implicit_multiplication,
+9: convert_equals_signs,
+10: function_exponentiation,
+11: rationalize}
+
+transformations = '\n'.join('%s: %s' % (i, func_name(f)) for i, f in _transformation.items())
+
+
+class _T():
+    """class to retrieve transformations from a given slice
+
+    EXAMPLES
+    ========
+
+    >>> from sympy.parsing.sympy_parser import T, standard_transformations
+    >>> assert T[:5] == standard_transformations
+    """
+    def __init__(self):
+        self.N = len(_transformation)
+
+    def __str__(self):
+        return transformations
+
+    def __getitem__(self, t):
+        if not type(t) is tuple:
+            t = (t,)
+        i = []
+        for ti in t:
+            if type(ti) is int:
+                i.append(range(self.N)[ti])
+            elif type(ti) is slice:
+                i.extend(range(*ti.indices(self.N)))
+            else:
+                raise TypeError('unexpected slice arg')
+        return tuple([_transformation[_] for _ in i])
+
+T = _T()