Vidai: Neural Mathematical Parsing with Deterministic Computation

Work in Progress: This is an early release demonstrating a novel architecture. The model requires more diverse training data to handle complex expressions reliably. We welcome contributions and feedback.

Why This Architecture

Transformers excel at sequence-to-sequence transformation and pattern recognition. Vidai uses them for exactly that: converting mathematical notation into structured tree representations. We don't ask the model to "learn" arithmetic facts like 7 × 8 = 56 from text tokens alone.

The key insight: Mathematical expressions have inherent tree structure. x^2 + 3*y is not just a sequence of characters; it's a tree where + is the root with x^2 and 3*y as children. Vidai's encoder learns to recognize this structure and output prefix notation (+ ** x 2 * 3 y), which explicitly encodes the tree.

The architecture:

• ContextEncoder: Processes input characters with tree-depth embeddings, helping the model understand expression structure
• SymbolicParserDecoder: Generates prefix notation tokens representing the parsed tree
• SymPy Bridge: Converts prefix notation to symbolic expressions for deterministic evaluation

This separation means the transformer does what it's good at (pattern recognition, sequence transformation) while symbolic engines handle what they're good at (exact computation).

Read more: Teaching Machines Arithmetic: The Vidai Journey

Current Status

Vidai (Tamil for "answer") is a neuro-symbolic system that parses mathematical notation into prefix notation trees, then delegates computation to symbolic engines (SymPy).

Model Description

• Architecture: Encoder-decoder transformer (44.6M parameters)
• Input: Character-level ASCII (vocabulary size 256)
• Output: Prefix notation tokens (vocabulary size 64)
• Computation: Deterministic via SymPy (0 learned parameters)

Component	Parameters
ContextEncoder	19M
SymbolicParserDecoder	25M
TreeComputeModule	0

Usage

import torch
from vidai.model.tree_compute import TreeComputeTransformer, TreeComputeConfig
from vidai.data.tokenizer import ParserTokenizer

# Load model
ckpt = torch.load('parser_v4_best.pt', map_location='cpu', weights_only=False)
config = TreeComputeConfig(**ckpt['config']['model_config'])
model = TreeComputeTransformer(config)
model.load_state_dict(ckpt['model_state_dict'])
model.eval()

# Parse expression
tokenizer = ParserTokenizer()
text = "x^2 + 3*y"
input_ids = torch.tensor([tokenizer.encode_input(text)])
input_mask = (input_ids != 0).bool()

with torch.no_grad():
    output_ids = model.parse(input_ids, input_mask, max_len=64)

prefix = tokenizer.decode_output(output_ids[0].tolist())
print(f"{text} -> {prefix}")
# Output: x^2 + 3*y -> + ** x 2 * 3 y

CLI Usage

pip install vidai
vidai parse "x^2 + 3*y"
vidai parse "3 + 5 * 2" --eval
vidai parse "x^2 + y" --eval x=3 y=4

Training Data

Trained on 2M synthetic examples with mixed notation formats:

• 30% explicit parentheses with spaces
• 15% explicit parentheses without spaces
• 20% unparenthesized with spaces
• 10% unparenthesized without spaces
• 25% edge cases (Unicode, negatives, trig functions)

Evaluation Results

Category	Accuracy
Basic arithmetic	100%
Parenthesized expressions	100%
Trig functions (sin, cos, tan)	100%
Unicode sqrt	100%
Left associativity	100%
Operator precedence (no parens)	86%
Extended variables (r, c, d, v, g)	91%
Overall on targeted patterns	90.8%

Important: Use Parentheses for Reliable Results

For 100% accuracy, always use explicit parentheses around:

1. Function calls: (sqrt(16)) + 2 not sqrt(16) + 2
2. Exponents in expressions: (x^2) + y not x^2 + y
3. Complex expressions: ((a + b)) * (c - d) not a + b * c - d

Examples:

Expression	Reliable?	Recommendation
sqrt(16) + 2^3	❌ May fail	(sqrt(16)) + (2^3)
x^2 - 3*y + pi	❌ May fail	((x^2) - (3*y)) + pi
(sqrt(16)) + (2^3)	✅ Works	Already parenthesized
3 + 5	✅ Works	Simple expressions are fine

Current Limitations

This model needs more training data. The architecture is sound, but the training dataset lacks diversity.

What Works	What Doesn't (Yet)
Simple expressions: 3 + 5 * 2	Deep nesting: sqrt(sqrt(sqrt(x)))
Parenthesized: (x^2) + (3*y)	Long polynomials (4+ terms)
Single functions: sin(x), sqrt(16)	Chained functions: log(exp(sqrt(x)))
Basic precedence	Complex precedence without parens

Known Issues:

• Unparenthesized expressions fail ~14% of the time
• Function calls without outer parens: sqrt(x) + y may be misparsed
• Deep nesting (3+ levels) often fails
• Long expressions get truncated
• Capital letters not in vocabulary

What's Needed: Training Data

The architecture can handle complex expressions, but needs:

1. More diverse synthetic data - especially deeply nested functions
2. Edge cases - operator precedence without parentheses
3. Real-world expressions - from textbooks, papers, code

Contributing: If you'd like to help improve Vidai, see our GitHub repository for data generation scripts.

Model Files

• parser_v4_best.pt - Best V4 checkpoint (pre-training)
• finetune_v1_step3500.pt - Fine-tuned on targeted patterns
• config.json - Model configuration
• tokenizer.json - Output vocabulary

Citation

@software{vidai2026,
  author = {Sampathkumar, Rajesh},
  title = {Vidai: Neural Mathematical Parsing with Deterministic Computation},
  year = {2026},
  url = {https://github.com/aiexplorations/vidai}
}

License

MIT License