Mogan STEM: Interactive Scientific Authoring

• Mogan STEM is a WYSIWYG, tree-based structured editor designed for interactive, LLM-assisted scientific authoring using an explicit document tree and the .tmu format.
• It offers efficient incremental rendering, local error localization, and on-demand plugin loading to overcome TeX’s batch compilation and macro stream limitations.
• Its design improves semantic clarity and token efficiency in LLM workflows, making it ideal for documents rich in cross-references, equations, and technical figures.

Mogan STEM is a WYSIWYG, structured editor derived from GNU TeXmacs that is presented as an alternative to TeX for scientific authoring in the era of LLMs. Its defining claim is that TeX’s linear macro stream, batch compilation model, and multi-pass side effects are poorly matched to interactive, AI-assisted writing, whereas Mogan keeps a document tree in memory, renders interactively, and stores structure explicitly in its .tmu format (Liu et al., 3 Mar 2026). In the source paper, Mogan STEM is characterized by an explicit document tree, local and parallel rendering, on-demand plugin loading, in-file storage of structural links such as cross-references, and lower information entropy for LLM-oriented workflows than TeX (Liu et al., 3 Mar 2026).

1. Scope and nomenclature

Within the cited literature, “Mogan STEM” refers specifically to the editor introduced in “LaTeX Compilation: Challenges in the Era of LLMs” (Liu et al., 3 Mar 2026). It should be distinguished from “MoGAN,” a motion-centric post-training framework for video diffusion (Xue et al., 26 Nov 2025), and from “STEM,” the “Structured Transition Evaluation Method” for LLM capability evaluation (Hu et al., 16 Aug 2025). The overlap in naming is lexical rather than conceptual.

The paper positions Mogan STEM against TeX by arguing that TeX’s design, which originated in the 1970s–80s, is a poor fit for interactive and LLM-assisted scientific writing. Four limitations are identified as central: compilation efficiency, generated semantics, error localization, and tool ecosystem constraints (Liu et al., 3 Mar 2026). This framing places Mogan STEM not merely as an editor, but as an alternative document representation and execution model for technical writing.

A plausible implication is that the topic is best understood at the intersection of document engineering, interactive theorem-and-math authoring, and LLM-oriented representation design. The paper’s emphasis is not only typographic output, but also compilation behavior, semantic analyzability, and token efficiency in machine-mediated workflows (Liu et al., 3 Mar 2026).

2. Motivation: TeX’s limitations in interactive and LLM-assisted writing

The paper’s critique of TeX begins with compilation. TeX uses a unidirectional “read → expand → typeset → output” flow, which requires full re-compilation even for small edits. A one-line deletion can trigger global re-pagination affecting page breaks, float positions, counters, and headers or footers (Liu et al., 3 Mar 2026). Multi-pass recovery mechanisms for cross-references, tables of contents, and bibliographies depend on auxiliary files such as .aux, .toc, and .bbl, and repeated runs such as pdflatex → bibtex → pdflatex → pdflatex (Liu et al., 3 Mar 2026). The paper also cites platform variance and toolchain fragmentation, including pdfLaTeX versus XeLaTeX versus LuaLaTeX, and BibTeX versus Biber, as sources of latency and cognitive overhead.

A second limitation concerns generated semantics. In TeX, semantic and layout behavior are conflated in macro expansion. The paper uses \section as a representative example: it simultaneously declares structure and triggers formatting, counter changes, and table-of-contents writing. Because macros may act either as text wrappers or as structural entities, static tools cannot reliably distinguish their roles. Moreover, conditionals such as \ifdefined... determine structure only at expansion time, so there is no stable, analyzable AST without simulating TeX execution (Liu et al., 3 Mar 2026).

The third limitation is error localization. TeX errors can surface late and far from their origin. The paper gives two examples: missing braces in \frac may trigger “Runaway argument?” at \end{equation}, and mismatched \left/\right can fail during closing stages rather than where the structural inconsistency originated. Reported locations therefore indicate where execution stalled, not where the structure actually broke (Liu et al., 3 Mar 2026).

The fourth limitation concerns the surrounding tool ecosystem. Real-time preview in editors is achieved through frequent background compilations, and the lack of a structured tree makes refactoring, semantic checks, and conflict-aware merges difficult. The paper also notes distribution bloat: the TeX Live ISO grew from 2.4 GB (2008) to 5.9 GB (^^^^111^^^^5), minimal installs exceed 1 GB, and full distributions are ≈ 6 GB in ^^^^111^^^^5 (Liu et al., 3 Mar 2026).

For LLM workflows, the paper argues that TeX carries “syntax noise,” since multiple forms can render identically, such as \frac{a}{b} versus {a \over b} and x^{2} versus x^2. This increases uncertainty and token budget during learning and generation. Because multi-pass semantics and external side effects distribute structural information across files and compilation stages, an LLM may need broad scans to recover display numbers or citation contexts (Liu et al., 3 Mar 2026).

3. Document model, rendering architecture, and the .tmu format

Mogan STEM is described as a functional, tree-based representation for both document structure and mathematics. Its architectural components are an explicit document tree, a rendering engine with local and parallel rendering at leaf nodes, incremental repainting of affected subtrees after edits, and a plugin system that loads features on demand rather than at startup (Liu et al., 3 Mar 2026). Unlike TeX’s macro stream, Mogan separates abstract structure from rendering and maintains a verifiable structural state.

The contrast between TeX and Mogan can be summarized as follows:

Aspect	TeX	Mogan STEM
Core representation	Linear macro stream	Explicit document tree
Reference stabilization	Auxiliary files and repeated runs	Relationships stored in-tree
Update strategy	Full re-compilation	Incremental subtree re-rendering

The .tmu format is the concrete representation of this model. It uses tree or functional S-expressions for content, together with compact tags for associations (Liu et al., 3 Mar 2026). Representative forms given in the paper include the fraction expression (frac "1" "2"), an integral encoded through quasi-quoted Scheme with concat, rsub, rsup, and around*, and a multi-line document snippet containing a figure and list: $S$3

Cross-references are stored in-file after update. The paper’s example $S$4 encodes a label, section number, and page number directly in the document (Liu et al., 3 Mar 2026). Likewise, a section labeled sec:intro may later appear as: $S$5 This means that tools and LLMs can resolve structure from the document itself rather than from external auxiliary products of a compilation pipeline.

A plausible implication is that Mogan’s document model is intended not only as a rendering substrate but also as a semantically legible interchange format. The paper explicitly links this explicitness to lower information entropy and easier structural resolution for downstream tooling (Liu et al., 3 Mar 2026).

4. Incremental compilation, rendering efficiency, and plugin loading

The paper decomposes total measured time as

$$t_{\text{total}} = t_{\text{compiling}} + t_{\text{rendering}} + t_{\text{IO}}.$$

This definition is important because Mogan’s measurements include WYSIWYG I/O overhead, whereas TeX is typically discussed in terms of compilation alone (Liu et al., 3 Mar 2026).

Mogan’s speed claims derive from incremental rendering, tree diffing, local repaint, parallel processing, and the elimination of multi-pass external tools for stabilizing global state. The paper describes the conceptual flow on edit as: identify the affected subtree $S$; validate $S$ against schema or constraints; recompute layout for $S$; update structural links in $S$ and directly linked nodes; diff the old and new subtree; apply a minimal patch to the render tree; and render patched leaves in parallel before updating the viewport (Liu et al., 3 Mar 2026).

The benchmark corpus consists of six arXiv papers “rich in cross-references, TOC, bibliographies,” run on hardware listed as CPU Intel Ultra 9 285H; GPU GeForce RTX 5080; [RAM](https://www.emergentmind.com/topics/reinforce-adjoint-matching-ram) 32 GB LPDDR5X (Liu et al., 3 Mar 2026). The results summary states that Mogan outperforms TeX in full compilation for most documents despite I/O overhead, with one exception: ([2502.17655](/papers/2502.17655)), a 120-page paper, where Mogan is slower on initial open because I/O is proportionally large (Liu et al., 3 Mar 2026). For incremental updates—including adding sections, tables, adjusting labels and references, and minor rearrangements—Mogan is faster on all six documents. The paper explains that this removes the apparent contradiction, because during incremental edits t_IO = 0 after open and the advantage comes from local re-rendering (Liu et al., 3 Mar 2026).

The plugin system is also part of the efficiency argument. Mogan is described as a monolithic, self-contained editor containing the core executable, Scheme runtime, document model, and renderer, while plugins load only when required by a document’s structure or operations. Installation is said to be on the order of “one hundred megabytes,” with several hundred megabytes after extraction, compared with TeX Live minimal installations above 1 GB and full installations of ≈ 6 GB in ^^^^111^^^^5 (Liu et al., 3 Mar 2026).

5. Structural validity and error localization

A central technical distinction in the paper is that Mogan maintains verifiable structure at input time. Explicit around* and bracket nodes preserve completeness, and bracket pairs and similar constructs are functional objects that remain paired unless explicitly edited (Liu et al., 3 Mar 2026). This makes error propagation local rather than global.

The paper contrasts TeX and Mogan with concrete examples. In TeX, an “Unclosed brace in \frac” may fail only at \end{equation}, far from the origin of the structural defect. In Mogan, the fraction node is a 2-argument function, so validation fails locally and highlights the fractional subtree rather than the entire page (Liu et al., 3 Mar 2026). Likewise, the integral example encoded with around* manages nested brackets such as [F(x)] |, and even omitted parentheses do not break the overall expression because bracket functions are represented as nodes with enforced pairing.

The broader claim is that AST-level validation and constraints prevent error propagation. A missing bracket in TeX can “run away” and corrupt subsequent parsing, whereas in Mogan the fault is confined to the nearest ancestor node and the remainder of the document stays renderable (Liu et al., 3 Mar 2026). The paper also states that errors do not abort the entire output because local modules isolate faults.

This suggests a shift from recovery after failed batch execution to input-time structural preservation. In that interpretation, Mogan’s editor is not merely preventing specific syntax errors; it is constraining document states so that categories of failure become non-global by construction (Liu et al., 3 Mar 2026).

6. LLM-oriented experiments, token cost, and information entropy

The paper’s LLM-oriented argument is that .tmu has lower information entropy than TeX because it reduces interchangeable syntactic forms and encodes structure explicitly. The canonical entropy definition is stated as

$H(X) = -\sum_i p_i \log p_i.$

The argument is qualitative, but the paper says that lower entropy makes structurally valid next tokens more predictable and that fine-tuning results corroborate this interpretation (Liu et al., 3 Mar 2026).

Three task families are evaluated. The first is a structure locating task using four LLMs and 20 questions on ([2502.17655](/papers/2502.17655)). The score is

$$u_s = \max\left(0, \begin{cases} 5 - \left\lfloor \dfrac{T}{10^4} \right\rfloor, & \text{right answer} \ 0, & \text{wrong answer} \end{cases}\right),$$

with $\sum u_s \in [0,100]$, where $T$ counts input, thinking, output, and tool tokens (Liu et al., 3 Mar 2026). The reported result is that Mogan (.tmu) leads for most LLMs, despite those models being trained heavily on TeX corpora, because structural links such as <associate|label|<tuple|section|page>> are directly available.

The second family concerns merging files with distinct doc-styles. The paper defines doc-style as macro naming conventions, aliasing, and redefinitions. The assignment asks models to merge theorems.tex and proofs.tex, each written in distinct styles with cross-references, into a single file using the style of theorems.tex, with successful compilation and proper placement of proofs under theorems via cross-references (Liu et al., 3 Mar 2026). The score is

$$u_m = \max\left(0, \begin{cases} 20 - 2 E_{\text{ref}} - \left\lfloor \dfrac{T}{10^4} \right\rfloor - E_{\text{sty}}, & \text{success on first try} \ 10 - 2 E_{\text{ref}} - \left\lfloor \dfrac{T}{10^4} \right\rfloor - E_{\text{sty}}, & \text{success on second try} \ 0, & \text{fail within two tries} \end{cases}\right),$$

with $S$0 (Liu et al., 3 Mar 2026). The reported result is that .tmu achieves higher scores on all LLMs; the paper attributes this to grammar consistency and explicit structure, and states that in practice merging is copy-paste in Mogan.

The third family concerns debugging ill-formed documents. Twenty ill-formed samples are distributed as Unclosed bracket 4; Unclosed environment 5; Wrong command usage 4; Undefined cross-reference 3; Conflicting packages 2; Self-recursive macros 2 (Liu et al., 3 Mar 2026). The score is

$S$1

with $S$2 (Liu et al., 3 Mar 2026). The result reported is that the Mogan group fixes all errors, with only two cases above 10k tokens, whereas the TeX group requires more “thinking.” The paper adds an important qualification: if a document is authored in Mogan, .tmu cannot have “unclosed environments” or “self-recursive macros” (Liu et al., 3 Mar 2026).

The fine-tuning experiment uses parallel supervised fine-tuning ([LoRA](https://www.emergentmind.com/topics/low-rank-adaptation-lora-patching)) on Qwen2.5-7B-Instruct, with a dataset of 1000 random formulas in TeX converted to Mogan S-expressions, identical rendering, and 289 training steps on Intel Ultra 9 285H, GeForce RTX 5080, 32 GB RAM (Liu et al., 3 Mar 2026). Coverage includes fractions, radicals, subscripts and superscripts, matrices, piecewise functions, integrals and summations, limits, quantifiers, composite functions, and nested parentheses. The task is prefix completion. The reported training result is that loss converges to ≈0.4 on Mogan versus ≈0.7 on TeX after 289 steps (Liu et al., 3 Mar 2026).

A concise summary of the reported LLM results is useful:

Task	Setup	Reported outcome
Structure locating	4 LLMs, 20 questions	.tmu leads for most LLMs
Doc-style merging	4 LLMs, two assignments	.tmu higher scores on all LLMs
Fine-tuning	LoRA on Qwen2.5-7B-Instruct, 289 steps	Loss ≈0.4 vs ≈0.7

7. Conversion workflows, limitations, and research directions

Mogan includes a built-in LaTeX importing engine. In the reported experiments, .tex sources were imported to .tmu with identical rendering content (Liu et al., 3 Mar 2026). Export to final formats such as PDF is supported, but TeX compatibility is characterized as Partial rather than complete (Liu et al., 3 Mar 2026). The paper does not claim export back to .tex; its emphasis is on import and final-format export.

The stated limitations are concrete. First, TeX compatibility is partial, and very complex, heavily macro-driven templates may not map 1:1 to Mogan’s structural model. Second, TeX’s package ecosystem remains far broader, even though Mogan supports on-demand plugins. Third, very large documents may incur noticeable initial-open I/O overhead, illustrated by the slower first open for the 120-page ([2502.17655](/papers/2502.17655)) case. Fourth, community adoption is a nontrivial issue: migration requires different habits and workflows, and “Overleaf-style line-based collaboration” does not transfer directly because Mogan is structure-based rather than plain-text-based (Liu et al., 3 Mar 2026).

The paper’s practical guidance is correspondingly specific. Mogan is recommended for interactive WYSIWYG authoring with immediate feedback, for documents rich in cross-references, equations, and figures, for LLM-integrated workflows involving authoring, merging, and debugging, and for lightweight or constrained installations, given the contrast between a Mogan installer of roughly ≈100 MB and TeX Live installs above 1 GB or around ≈6 GB for full distributions (Liu et al., 3 Mar 2026). Migration is described as beginning with .tex import into .tmu, followed by validation of structure and references, while expecting only partial compatibility for exotic macro packages (Liu et al., 3 Mar 2026).

The paper closes with an explicit appeal for larger experiments on LLM training using .tmu. Proposed directions include broader scientific corpora incorporating sections, figures, and citations; varied model sizes; comparative token cost; perplexity; entropy estimates; tokens per second; and accuracy on authoring, merging, and debugging tasks (Liu et al., 3 Mar 2026). Research questions posed include whether .tmu consistently lowers token usage for structure-heavy tasks, how loss curves and downstream accuracy scale with corpus size, and which ablations—such as bracket function variants or reference-tag density—drive gains (Liu et al., 3 Mar 2026).

Taken together, these claims define Mogan STEM as a structured-document system whose significance lies not only in rendering and editing, but in the proposal that scientific document formats should be designed for both human authoring and machine reasoning. The paper’s results suggest faster incremental updates, more local error handling, and lower token cost for several LLM tasks, while leaving open broader questions of compatibility, ecosystem maturity, and scaling beyond the reported experiments (Liu et al., 3 Mar 2026).