Project Proposal: LaTeX Equation Language (LEL): LaTeX equation to LLVM

[YoruCathy]

What will you do?
I will implement a compiler which will be refered to as LEL (LaTeX Equation Language), that translates LaTeX-formatted mathematical equations into executable LLVM IR code.
LaTeX is a common language for writing professional documents like academic papers. In the past, I have worked on many research projects that involve implementing mathematical equations. It’s natural to think of a tool that converts the LaTeX formatted equations into usable code directly and allows the generated code to connect with other developing technologies.
The goal is to enable direct conversion from symbolic mathematical notation (as used in academic papers) to low-level program code, bridging the gap between human-readable formulas and machine-executable representations.

The compiler will focus on supporting a subset of LaTeX equation grammar, specifically:

• Arithmetic expressions
• Conditional expressions (using \begin{cases})
• Function definitions and recursive function calls

How will you do it?

1. Parse LaTeX equations into an internal form for three constructs: arithmetic, piecewise conditions via \begin{cases}...\end{cases}, and function calls/definitions.
2. Infer semantics: treat the left-hand symbol as the function name; collect single-letter variables on the right-hand side as arguments; interpret \text{if} predicates and \text{otherwise} as control flow; use a consistent integer type.
3. Generate LLVM IR: emit a function per equation, allocate and load locals for arguments, lower arithmetic ops, build conditional branches for cases with a shared exit, and lower function calls with call.

How will you empirically measure success?
I will first verify the compiler’s correctness with a small set of hand-written LaTeX test cases for arithmetic equations, piecewise conditions, and recursive function calls. For each case, I will manually check that the generated LLVM IR structure and outputs match the expected behavior. After confirming these core cases, I will leverage GPT to automatically generate a larger benchmark suite of LaTeX equations covering varied arithmetic and conditional patterns. This expanded set will test the robustness of the parser and code generator across diverse equation structures.

[sampsyo]

Wow! This is a really bonkers idea! I like it. :)

Here is one thing to refine about your approach before you proceed: Are you really going to hand-write a LaTeX parser? Can you look around and see if there are any existing parsers you can use to save yourself the trouble? Maybe there is something you can borrow from MiTeX?

Next, can you please develop a more systematic plan for testing? These two parts of your plan are worrisome to me:

1. checking correctness by just inspecting the LLVM IR manually (this seems extremely unreliable)
2. using ChatGPT to generate equations (I have no idea what this kind of evaluation could possibly conclude)

I think you should instead:

1. develop a plan to write "test drivers" in C to link with these generated functions so you can actually compile and run the code on sample inputs
2. harvest real-world LaTeX equations from somewhere: for example, from LaTeX source code on arXiv, or from one of the many datasets of LaTeX equations available for training pixel-to-TeX OCR

Assuming you are amenable to both suggestions, can you please flesh out a more complete evaluation plan along those lines?

[YoruCathy]

Thanks for the suggestions!

Here is one thing to refine about your approach before you proceed: Are you really going to hand-write a LaTeX parser? Can you look around and see if there are any existing parsers you can use to save yourself the trouble? Maybe there is something you can borrow from MiTeX?

Instead of hand-writing a parser, I will first investigate existing LaTeX parsers such as MiTex, plasTex, and TexSoup, to reuse their AST or tokenization capabilities.

I think you should instead: develop a plan to write "test drivers" in C to link with these generated functions so you can actually compile and run the code on sample inputs harvest real-world LaTeX equations from somewhere: for example, from LaTeX source code on arXiv, or from one of the many datasets of LaTeX equations available for training pixel-to-TeX OCR

To test the correctness of the generated LLVM code, I will develop a framework that links each compiled LEL function with generated C test drivers. Each driver will declare the function, supply representative input values, and compute expected outputs using a simple reference implementation for comparison. A consistent ABI (using double types and standard C calling conventions) will allow seamless linking. The testing pipeline will compile the LLVM IR into object files, link them with the drivers, execute them to compare outputs within numerical tolerance, and report pass/fail results.
I will expand testing by collecting a dataset of real LaTeX equations from open-source sources such as arXiv LaTeX corpora or public equation datasets (e.g., Im2LaTeX).
I will then automatically extract equation snippets, run them through the compiler, and check for successful parsing and code generation.

[sampsyo]

OK! All sounds good.

Instead of hand-writing a parser, I will first investigate existing LaTeX parsers such as MiTex, plasTex, and TexSoup, to reuse their AST or tokenization capabilities.

Can you please make a decision about this early on (and update this thread)? Maybe one week would be enough to decide?

[YoruCathy]

Ok, will do!

[YoruCathy]

I decided to use MiTex.

[sampsyo]

Awesome. Thanks!

[YoruCathy]

Link to my code: https://github.com/YoruCathy/cs6120_final_project