CALT: Computer ALgebra with Transformer

• Documentation
• Practical Codebase (calt-codebase)

CALT is available as the Python package calt-x. For practical examples and project templates built with CALT, see calt-codebase.

Overview

CALT is a simple Python library for learning arithmetic and symbolic computation with a Transformer model (a deep neural model to realize sequence-to-sequence functions).

It offers a basic Transformer model and training pipeline, and non-experts in deep learning can focus on constructing datasets to train and evaluate the model.

Quick Start

Installation

We recommend installing CALT in a dedicated conda environment.

conda create -n calt-env python=3.11
conda activate calt-env
conda install -c conda-forge calt-x

Alternatively, install it from PyPI with pip:

pip install calt-x

CALT supports Python >=3.11 (tested in CI on 3.11–3.14).

Optional: If you use features that depend on SageMath, install SageMath in the same conda environment:

conda install -c conda-forge sage

You can check the available versions with:

conda search calt-x --channel conda-forge

The conda-forge feedstock is available here: conda-forge/calt-x-feedstock.

Instance Generation

For minimal usage, users only need to implement an instance generator for their own task. For example:

def int_sum_generator(seed, N=5, lb=-10, ub=10):
    random.seed(seed)

    # get N random integers from [lb, ub]
    problem = [random.randint(lb, ub) for _ in range(N)]
    answer = sum(problem)

    return problem, answer

Feeding the generator to DatasetPipeline generates training and evaluation sets. The data.yaml configuration file provides full control over the generation process.

cfg = OmegaConf.load("configs/data.yaml")
pipeline = DatasetPipeline.from_config(
    cfg.dataset,
    instance_generator=int_sum_generator
)
pipeline.run()

Training Script

Then, a short script handles training and evaluation through IOPipeline, ModelPipeline, and TrainerPipeline. The train.yaml configuration file and the associated lexer.yaml file provide control over the training setup.

cfg = OmegaConf.load("configs/train.yaml")

io_pipeline = IOPipeline.from_config(cfg.data)
io_dict = io_pipeline.build()

model = ModelPipeline.from_io_dict(cfg.model, io_dict).build()
trainer_pipeline = TrainerPipeline.from_io_dict(cfg.train, model, io_dict).build()

trainer_pipeline.train()
trainer_pipeline.save_model()
trainer_pipeline.evaluate_and_save_generation()

Examples

See examples/ for minimal examples. For practical experiments and project templates built with CALT, see calt-codebase.

For users without a local GPU

If you do not have a local GPU, you can still try CALT in two ways:

1. Run the demo on Google Colab

   Use the demo notebook from your browser: https://colab.research.google.com/github/HiroshiKERA/calt/blob/main/examples/demos/minimal_demo.ipynb

2. Use remote jobs on Kaggle

   Submit and monitor training jobs from your local terminal using calt remote .... See the remote job documentation: https://hiroshikera.github.io/calt/remote/

Citation

If you use CALT in your project, please cite our paper:

@misc{kera2025calt,
  title={CALT: A Library for Computer Algebra with Transformer},
  author={Hiroshi Kera and Shun Arakawa and Yuta Sato},
  year={2025},
  archivePrefix={arXiv},
  eprint={2506.08600}
}

Note: The current arXiv preprint is based on the previous version of CALT. The update will come soon.