As discussed, it would be good to put all other lexicons in a subdirectory. As far as I know the common user only need the following lexicons:

• global-lexicon.txt
• thesaurus.txt
• global-ignorableLatex.txt
• MathAndTextCmdsWithParamsWithoutRelevantEffect.txt

Implement a converter for constants for LaTeX <-> Maple <-> Mathematica.

There are some features not yet support by the translator because there is no function for the command line program yet (for instance use alternative translations).
The Lexicon creator has no command line functionality at all yet!

There is a feature that is sometimes called "Meaning" and sometimes "Meanings".

The first milestone provides the conversion from semantic LaTeX to a given CAS (Maple & Mathematica).

• support all DLMF macros
• support simple prefix and suffix and DLMF macros in one equation (simple +-*/)
• support complicated arguments (functions like sqrt, frac)
• support multiple DLMF macros in one equation (multiply several macros)
• support nested functions and macros (macro of a macro)
• provide information about domains
• provide information about branch cuts
• support multiple CAS

please

Currently GreekLetters can translate all greek letters between Maple, Mathematica and LaTeX except those without a definition in one of the languages. (for instance variant form of pi).

The current implementation is also pretty hard to extend.

Lists of greek letters:

• LaTeX greek letters
• Maple greek letters
• Mathematica greek letters

I don't know if this is necessary but in a math environment we can assume n! means factorial function. Currently ! is just a punctuation symbol.

I could add it to my own global-lexicon but I think that's not meaningful.

• convert simple JacobiP
• convert multiple forms of JacobiP (multiple @'s)
• convert complex forms (with complex parameters like frac and sqrt)

Since we already have a pretty stable prototype for JacobiP, I can rework it now to a general version.

test issue

@ClaudeZou @notjagan I cannot find your e-mail addresses on your profiles on github. Can you send me an e-mail with your current e-mail addresses?
[email protected]

Currently modulo is not supported by our program. There are two possible solutions to solve this problem.

1. Check for each expression if the next one is mod and handle that case.
2. Add modulo expressions to the grammar back-end and update our program than.

To achieve the first milestone:

• load a given LaTeX file
• locate and extract every mathematical formula from this file
• store each formula in an internal structure
• provide interfaces for further computations of these formulae

Extend the supported translations to Mathematica.

The current output is horrible. I will fix this soon.

This is just a quick list of questions I want to ask Abdou. Kind of remainder for myself...

• list of tags
  got it

• where can i found the implementation of sqrt and frac and how to change or extend it
  waiting for another email of the grammar.

• lexicon entry for each DLMF macro or is there a better option?
  yes, good approach

• I expected PomParser only use global-lexicon but throws an exception if some other lexicons are missing

• what about multiple names with same feature set. is it possible to write
  use a feature like "synonym" and searching in the lexicon for the synonym.

Cannot handle these kind of expressions yet.

There are some problematic special cases hard to translate. The current program cannot translate those cases properly (latest version 81bbdeb). The following table exemplifies the problem for translations from semantic LaTeX (DLMF/DRMF macros) to the CAS Maple.

¹ Could be solved, if the function f is given by the DLMF macro for a function: \f{f}@{x}. But in this case we need to extract the argument of one macro (here x) to put it in another translation. \LaplaceTrans{ \f{f}@{x} }{s} should translated to laplace(f, x, s). Extract the 2^nd argument of \f and put into the outer translation of \LaplaceTrans, namely into the 2^nd position of laplace(...), is not possible now.

Implement a simple parser to convert a given CSV file to a lexicon file.

Write a program that extracts all the information we need from the DLMF style files.
We need information about the subscript, superscript, variables and the form of them (are their any parenthesis, semicolons and if, where are their).

All mathematical constants has the Feature:
Role: mathematical constant

But all physical constants don't have a feature named "Role". Would be easier to find if all constants have a feature named "Role".

Currently a lot of the translations in Macro2Maple has no placeholders yet. Without these placeholders we cannot translate it correctly.

It's a easy task but it needs time.

Once we have done the previous steps we can write a third program that takes generic LaTeX input, analyze the output and convert all special functions with known DLMF/DRMF macros.

The above overview is too generic.

@ClaudeZou @notjagan Can you outline exactly and precisely what the Python, node.js and Java programs will actually do. Make sure the documentation explains all this.

@abdouyoussef
I think it would be nice to have some version numbers for the MLP jar. Sometimes we only have some changes in the lexicon file but since you upload the whole zip file always it is pretty hard for me to see what's going on in the jar. It worked well so far but now we reached a point where some updates in the jar could destroy my program.

The current concept provides alternative translations. For instance \acot@@{z} will be translated to Maple's arccot(z). But since Maple uses another branch cut for this function, the user has the alternative translation to arctan(1/z).

Currently our program just informs about this alternative but the user cannot configure the translation in a way, that our program choose the alternative translation instead of the first (most intuitive) translation.

Another example shows, why we should tackle this problem. Some DLMF macros has no direct translation, but based on the definition, we can provide an appropriate translation. For instance \BesselKtilde{\nu}@{x} has no translation to Maple yet. But based on the DLMF definition, we can provide the alternative translation to BesselK(I * nu, x).

Maple has difficulties to understand numbers after strings letters (variables, constants, functions). For instance

• 2 Catalan computes approx. 1.83
• Catalan 2 produces an Error, missing operation.

Mathematica has no problems with it.

That way it will be viewable immediately.

Add this guide to the readme file.
It would be nice to explain also a little bit what is missing currently and how to add missing stuff.

@physikerwelt I have no good ideas how to keep the door open for additional add-ons. Here is a list of examples:

• Mathematical Constants: solved by a JSON file GreekLettersAndConstants.json
• Greek Letters: solved by a JSON file GreekLettersAndConstants.json
• MathTerms, a list of all cases can be found in MathTermParser.java. As an example, "star" and "forward slash" can be seen as multiplication and division in Maple and Mathematica and can be translated directly to * and / but maybe not in all CAS.

Once we have done this, we have to write a program that translates the information about the macros into a lexicon file to use all information with Abdou's MLP.

We should extend the already existing lexicon file for special functions called [Special-functions-lexicon.txt](https://github.com/TU-Berlin/latex-grammar/blob/master/libs/ReferenceData/Lexicons/Special-functions-lexicon.txt).

@AndreG-P @ClaudeZou @notjagan Don't you agree?

@ClaudeZou @notjagan
MathMode.java

    private static int skipEscaped(String latex) {
        if (latex.startsWith("\\$")) {
            return 2;
        } else if (latex.startsWith("\\\\[")) {
            return 3;
        } else if (latex.startsWith("\\\\(")) {
            return 3;
        }
        return 0;
    }

Please store these numbers in private global constants. Maybe it's also better to store the strings in global constants as well.

As some examples:

• What is \pi? A constant or a variable? The user could uses \cpi to make it clear but what if he uses \pi?
• What is i? Is it \iunit?
• \gamma vs \EulerConstant

And an example of a different kind of ambiguities could be:

• n!! is it the factorial of the factorial or the double factorial? Maple opens a pop up window to ask the user what he means by that.

We should warn the user about potential ambiguities.

I cannot find a case where this function doesn't return null. This is probably a bug?

Write a simple program that translates the MLP output to strict content MathML. For a definition take a look to W3C. We currently only want to support simple cases. Here is a list of all supported strict content MathML tags:

• cn: for numbers
• csymbol: for mathematical operators (+, -, *, /). It can be used for mathematical functions in general but it needs a content dictionary to understand it.:

<apply>
  <csymbol cd="arith1">plus</csymbol>
  <ci>x</ci>
  <ci>y</ci>
  <ci>z</ci>
</apply>

• ci: for variables or parameters. For instance n can be an integer -> <ci type="integer">n</ci>
• cs: for general strings
• apply: a mathematical object (similar to a container). This block is needed to build the typical expression tree of a mathematical expression.

@physikerwelt @HowardCohl please take a short look to the CONTRIBUTING.md and also to the example PDF.

You can close this issue, once you have done this!

Their GitHub usernames are @notjagan @ClaudeZou.

There is a lot do to solve this problem. This issue is just a milestone representation.

When the underlying MLP software from Abdou changes, it may break our system. Thus, create some standard tests that help to incorporate new versions of the MLP.

Is something like\left ( (with space between t and ( ) allowed in LaTeX?
@abdouyoussef your code handles \left( x \right) pretty well but cannot understand
\left ( x \right ).
Some quick tests with LaTeX shows me that the second variant also works but I'm not sure about that.

@HowardCohl
We know from the glossary file the maximum number of @ of each macro right? And if there is at least one @ in the macro, there is always a representation without an @ AND variables. Is this always true?

For instance the continuous q-Hermite polynomial If there is no @ in this macro, that means there are no variables defined also right? Something like \ctsqHermite{n}{x}{q} is not possible?

@abdouyoussef
I found a bug in the MLP grammar. To reproduce it, just try to parse

\\sqrt \\frac{1}{2}

Guess the reason is the definition for LatexCmd1or2Param or OtherLatex1Param.

Currently we using some hard-coded translations. We need to extract these and try to put all of them into a JSON file to make it easier to extend it.

@abdouyoussef You added the role a mathematical constant to your global lexicon for i and e but all of the other constants has simply the role mathematical constant (without an "a").

@abdouyoussef it seems you use hard-coded string variables to go from a given "References" directory into the Lexicon subfolder. That means your software is only usable on Windows machines, since Windows is the only system that uses \ as path delimiter. Linux uses / for instance.

Due to the fact that you use Java 7, I would recommended to change the code to Paths. Because a Path variable in Java 7 and higher always takes the system specific delimiters.

// given a string "refdir" as path to References
String pathToGlobalLex = refdir + Paths.get("Lexicon","global-lexicon.txt").toString();

PS: As far as I know, the only differences between Linux and Windows systems are the path delimiter and the new-line characters. To avoid this problem you can also use

String newLine = System.lineSeparator();

With these changes your program should work on all systems which supports Java 7 or higher.