masts 0.1.0__py3-none-any.whl

masts-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: masts
+Version: 0.1.0
+Summary: Step-by-step solutions for math expressions and equations (1 + 2 x 3 -> ['1 + 6', '7']), plus text-to-symbol helpers (6^6 -> 6⁶).
+Author: PipoAndDodo
+License-Expression: MIT
+Keywords: math,steps,solver,equation,calculator,superscript,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# math-step-to-step
+
+Giải biểu thức / phương trình **từng bước** và trả về danh sách các bước.
+Không phụ thuộc thư viện ngoài, dùng phân số chính xác (`fractions.Fraction`) nên không bị sai số.
+
+*Step-by-step solver for math expressions and equations. Pure Python, zero dependencies, exact arithmetic.*
+
+```bash
+pip install math-step-to-step
+```
+
+## Dùng nhanh
+
+```python
+from math_step_to_step import steps, solve, evaluate, prettify
+
+steps("1 + 2 x 3")              # ['1 + 6', '7']
+steps("(1 + 2) x 3 + 4 x 5")    # ['3 × 3 + 4 × 5', '9 + 20', '29']
+steps("2 + 3 x (4 - 1)^2")      # ['2 + 3 × 3²', '2 + 3 × 9', '2 + 27', '29']
+steps("1/2 + 1/3")              # ['1/2 + 1/3', '5/6']
+
+# tìm x
+steps("2x + 3 = 7")             # ['2x = 7 - 3', '2x = 4', 'x = 4 ÷ 2', 'x = 2']
+steps("2(x + 3) = 10")          # ['2x + 6 = 10', '2x = 10 - 6', '2x = 4', 'x = 4 ÷ 2', 'x = 2']
+steps("x^2 - 3x + 2 = 0")       # a, b, c -> Δ -> x₁, x₂ (từng bước)
+
+# kết quả có cấu trúc
+sol = solve("x^2 - 3x + 2 = 0")
+sol.kind, sol.values            # ('roots', (2, 1))
+
+evaluate("2 + 3 x 4")           # 14   (nhanh, không tạo chuỗi bước)
+
+# đổi chuỗi thành ký hiệu
+prettify("6^6")                 # '6⁶'
+prettify("x^2 + y^(n+1) <= sqrt(2)*pi")   # 'x² + yⁿ⁺¹ ≤ √2×π'
+```
+
+## Cú pháp nhập
+
+| Viết | Ý nghĩa |
+|---|---|
+| `+ - * x × · / ÷ :` | cộng, trừ, nhân, chia |
+| `x` giữa hai toán hạng, vd `2 x 3` | **phép nhân**; còn `2x`, `x + 1`, `x²` thì `x` là **biến** |
+| `^`, `**`, `²` `³` | lũy thừa (số mũ nguyên) |
+| `sqrt(…)`, `√9` | căn bậc hai |
+| `( )`, `[ ]`, `{ }` | ngoặc |
+| `2x`, `3(x+1)`, `(a)(b)` | nhân ngầm |
+| `1,5` hoặc `1.5` | số thập phân |
+| `=` | phương trình (1 biến, bậc 1 hoặc 2) |
+
+## Tùy chọn của `steps()` / `solve()`
+
+| Tham số | Mặc định | Ý nghĩa |
+|---|---|---|
+| `include_original` | `False` | thêm biểu thức gốc làm bước đầu |
+| `detailed` | `False` | mỗi bước chỉ làm 1 phép (`1+2+3` → `3 + 3` → `6`) thay vì gộp |
+| `pretty` | `True` | dùng `× ÷ ² √`; `False` ra ASCII (`* / ^ sqrt()`), có thể đưa lại vào thư viện |
+| `style` | `"auto"` | `"fraction"`, `"decimal"` hoặc `"auto"` (thập phân nếu đầu vào có số thập phân) |
+| `lang` | `"vi"` | ngôn ngữ thông báo: `"vi"` / `"en"` |
+
+Cách chọn bước: ngoặc trước → lũy thừa/căn → nhân chia → cộng trừ; các phép độc lập được làm **cùng một bước**
+và chuỗi cộng/nhân liên tiếp được gộp để lời giải ngắn nhất. Với phương trình: rút gọn → chuyển vế → chia hệ số;
+bậc 2 dùng Δ.
+
+## Ký hiệu
+
+```python
+from math_step_to_step import superscript, subscript, prettify
+superscript("123")        # '¹²³'
+subscript("12")           # '₁₂'
+prettify("H_2O, 6^6, x^(n+1), 1/2, a<=b, a!=b, +-3, alpha")
+# 'H₂O, 6⁶, xⁿ⁺¹, ½, a≤b, a≠b, ±3, α'
+```
+
+## Giới hạn (cố ý, để ít lỗi)
+Một biến; phương trình bậc ≤ 2; số mũ nguyên; không có số phức; không rút gọn căn phức tạp
+(căn không chính phương được rút gọn dạng `2 × √3` và cho giá trị gần đúng). Đầu vào sai/không hỗ trợ
+luôn ném `MathStepError` (kế thừa `ValueError`) với thông báo rõ ràng.
+
+## Dòng lệnh
+
+```bash
+math-step-to-step "(1 + 2) x 3 + 4 x 5"
+python -m math_step_to_step "2x + 3 = 7" --en
+```
+
+MIT License.

masts-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+masts-0.1.0.dist-info/licenses/LICENSE,sha256=HuddgMduGRH3Rmjsz_kIc1AXIsYnUX0OaWcZmBo2P7E,1060
+math_step_to_step/__init__.py,sha256=qALbk7msTQSaF8vzIls-2hENsO4LoWl06HdXOg-E9gI,384
+math_step_to_step/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+math_step_to_step/cli.py,sha256=b9y7uaibfXj0cJlYPckDCryd1Z35KhwQwDHaiW4uIrA,1472
+math_step_to_step/context.py,sha256=_B18eX3AxXF2y_nqdtlgAf8bNw3AA_2iyGiL61ifPjU,834
+math_step_to_step/engine.py,sha256=a5nBfypqPw6vBbTdob0fJfDEXDgTpfO0aEu0mZpsZuY,9425
+math_step_to_step/errors.py,sha256=VR1TnwJvQWLx6zesagS1_OoHXqGvFGpIeCANOz6cEC0,3276
+math_step_to_step/fmt.py,sha256=QTgwXSWHYd27yiRDDo6kUKXaMVq3YyOwygslVHI0Exs,4434
+math_step_to_step/nodes.py,sha256=bWmML_X38s5OEscRIb8_QX9eE-Fg87tPXZXnj7kK4sg,2663
+math_step_to_step/parser.py,sha256=0CS0wkRO63qr2ovxnQhSYFq5pehVFX_ddowcJ6fetds,6636
+math_step_to_step/poly.py,sha256=Z8AXkyDqqh_mJi7qJ0zi_7elI8QtX27yt3CXGJB8WcM,2409
+math_step_to_step/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+math_step_to_step/solver.py,sha256=rIJi6bkrFXujkfkoQaVv6FNx_9mgss9Xf2ZknQklmfo,7772
+math_step_to_step/symbols.py,sha256=WvJ4oZFylSZ8KMACXzhqAFVn58TbAie6BhZM37IysXg,4163
+masts-0.1.0.dist-info/METADATA,sha256=ZbPzGmkk5ZG1PbIYqxcuOLKYphEPqItUIr62e3X5RNo,4647
+masts-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+masts-0.1.0.dist-info/entry_points.txt,sha256=OjnpkOR84iqxnnr11TOACnCYqpEt8HCeaKBbH7ZgttA,65
+masts-0.1.0.dist-info/top_level.txt,sha256=JQYQ70VdSlkzoDDn-LNDL6n02UW0h2pxA5frTikwMpw,18
+masts-0.1.0.dist-info/RECORD,,

masts-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

masts-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+math-step-to-step = math_step_to_step.cli:main

masts-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VVT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

masts-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+math_step_to_step

math_step_to_step/__init__.py

@@ -0,0 +1,10 @@
+"""math-step-to-step: step-by-step solutions for math expressions and equations."""
+from .errors import MathStepError
+from .solver import Solution, evaluate, solve, steps
+from .symbols import prettify, subscript, superscript
+
+__version__ = "0.1.0"
+__all__ = [
+    "steps", "solve", "evaluate", "Solution", "MathStepError",
+    "superscript", "subscript", "prettify", "__version__",
+]

math_step_to_step/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

math_step_to_step/cli.py

@@ -0,0 +1,41 @@
+"""Command line: math-step-to-step "1 + 2 x 3"."""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+from .errors import MathStepError
+from .solver import solve
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="math-step-to-step", description=__doc__)
+    ap.add_argument("expression", nargs="*", help="expression; omit to read lines from stdin")
+    ap.add_argument("-d", "--detailed", action="store_true", help="one operation per step")
+    ap.add_argument("--ascii", action="store_true", help="plain ASCII output")
+    ap.add_argument("--en", action="store_true", help="English messages")
+    ap.add_argument("--style", choices=["auto", "fraction", "decimal"], default="auto")
+    ap.add_argument("-V", "--version", action="version", version=__version__)
+    a = ap.parse_args(argv)
+
+    lines = [" ".join(a.expression)] if a.expression else (l.strip() for l in sys.stdin)
+    code = 0
+    for line in lines:
+        if not line:
+            continue
+        try:
+            sol = solve(line, include_original=True, detailed=a.detailed,
+                        pretty=not a.ascii, style=a.style, lang="en" if a.en else "vi")
+        except MathStepError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            code = 1
+            continue
+        print(sol.steps[0])
+        for s in sol.steps[1:]:
+            print("  →", s)
+    return code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

math_step_to_step/context.py

@@ -0,0 +1,23 @@
+"""Options shared by the parser, engine and formatter."""
+from __future__ import annotations
+
+from .errors import LANGS
+
+MAX_LEN = 10_000   # max characters of input
+MAX_BITS = 14_000  # max size of any intermediate number (~4200 digits)
+MAX_DEG = 60       # max polynomial degree
+
+
+class Ctx:
+    __slots__ = ("pretty", "detailed", "lang", "style", "decimal")
+
+    def __init__(self, pretty=True, detailed=False, lang="vi", style="auto"):
+        if lang not in LANGS:
+            raise ValueError(f"lang must be one of {LANGS}")
+        if style not in ("auto", "fraction", "decimal"):
+            raise ValueError("style must be 'auto', 'fraction' or 'decimal'")
+        self.pretty = bool(pretty)
+        self.detailed = bool(detailed)
+        self.lang = lang
+        self.style = style
+        self.decimal = style == "decimal"

math_step_to_step/engine.py

@@ -0,0 +1,318 @@
+"""Step-by-step arithmetic engine.
+
+Each iteration finds every sub-expression that can be evaluated next and
+evaluates them together, giving one displayed step:
+
+* phase A - nodes whose operands are all numbers (e.g. ``2 x 3``, ``(1 + 2)``);
+  anything inside parentheses goes first;
+* phase B - only if phase A found nothing: merge the plain numbers of a sum or
+  product that also holds non-numeric parts (``2 + 3 + x`` -> ``5 + x``).
+"""
+from __future__ import annotations
+
+from decimal import Decimal, InvalidOperation, localcontext
+from fractions import Fraction
+from math import isqrt
+
+from .context import MAX_BITS
+from .errors import error
+from .nodes import Eq, Neg, Num, Pow, Prod, Sqrt, Sum, kids, make_neg, make_prod, make_sum
+
+ZERO = Fraction(0)
+ONE = Fraction(1)
+_RAD_LIMIT = 20_000
+
+
+def chk(v, c):
+    if v.numerator.bit_length() > MAX_BITS or v.denominator.bit_length() > MAX_BITS:
+        raise error(c.lang, "too_big")
+    return v
+
+
+def power(b, e, c):
+    if e.denominator != 1:
+        raise error(c.lang, "int_exp")
+    k = e.numerator
+    if b == 0:
+        if k == 0:
+            raise error(c.lang, "undefined")
+        if k < 0:
+            raise error(c.lang, "div_zero")
+        return ZERO
+    if b != 1 and b != -1:
+        bits = max(b.numerator.bit_length(), b.denominator.bit_length())
+        if abs(k) * (bits - 1) > MAX_BITS:
+            raise error(c.lang, "too_big")
+    return chk(b ** k, c)
+
+
+def _exact_sqrt(v):
+    n, d = v.numerator, v.denominator
+    rn, rd = isqrt(n), isqrt(d)
+    if rn * rn == n and rd * rd == d:
+        return Fraction(rn, rd)
+    return None
+
+
+def _radical(n):
+    """n = k*k*m with m as small as cheaply possible."""
+    k, m, p = 1, n, 2
+    while p * p <= m and p <= _RAD_LIMIT:
+        pp = p * p
+        while m % pp == 0:
+            m //= pp
+            k *= p
+        p += 1 if p == 2 else 2
+    return k, m
+
+
+def _mul_div(acc, op, v, c):
+    if op == "*":
+        return chk(acc * v, c)
+    if v == 0:
+        raise error(c.lang, "div_zero")
+    return chk(acc / v, c)
+
+
+# ---------------------------------------------------------------- reductions
+def _red_sum(n, c):
+    terms = n.terms
+    nums = [i for i, (_, x) in enumerate(terms) if type(x) is Num]
+    if len(nums) == len(terms):
+        if c.detailed and len(terms) > 2:
+            (s0, a), (s1, b) = terms[0], terms[1]
+            tot = chk(s0 * a.v + s1 * b.v, c)
+            return make_sum(((1, Num(tot)),) + terms[2:], n.d)
+        tot = ZERO
+        for s, x in terms:
+            tot += x.v if s > 0 else -x.v
+        return Num(chk(tot, c))
+    if len(nums) >= 2:
+        idx = nums[:2] if c.detailed else nums
+        tot = chk(sum((terms[i][0] * terms[i][1].v for i in idx), ZERO), c)
+        first, drop = idx[0], set(idx[1:])
+        new = []
+        for i, (s, x) in enumerate(terms):
+            if i in drop:
+                continue
+            if i == first:
+                if tot != 0:
+                    new.append((1, Num(tot)))
+            else:
+                new.append((s, x))
+        return make_sum(new, n.d)
+    if len(nums) == 1 and terms[nums[0]][1].v == 0:
+        return make_sum([t for i, t in enumerate(terms) if i != nums[0]], n.d)
+    return None
+
+
+def _red_prod(n, c):
+    facs = n.facs
+    if all(type(x) is Num for _, x in facs):
+        if c.detailed and len(facs) > 2:
+            v = _mul_div(facs[0][1].v, facs[1][0], facs[1][1].v, c)
+            return make_prod([("*", Num(v))] + list(facs[2:]), n.d)
+        acc = facs[0][1].v
+        for op, x in facs[1:]:
+            acc = _mul_div(acc, op, x.v, c)
+        return Num(acc)
+    nums = [i for i, (_, x) in enumerate(facs) if type(x) is Num]
+    if len(nums) >= 2:  # merge the numeric factors: 2 x sqrt(2) / 2 -> sqrt(2)
+        idx = nums[:2] if c.detailed else nums
+        m = ONE
+        for i in idx:
+            m = _mul_div(m, facs[i][0], facs[i][1].v, c)
+        if m == 0:
+            return Num(ZERO)
+        first, drop = idx[0], set(idx[1:])
+        new, neg = [], False
+        for i, (op, x) in enumerate(facs):
+            if i in drop:
+                continue
+            if i == first:
+                if m == 1:
+                    continue
+                if m == -1:
+                    neg = True
+                    continue
+                if op == "/" and (1 / m).denominator == 1:
+                    new.append(("/", Num(1 / m)))
+                else:
+                    new.append(("*", Num(m)))
+            else:
+                new.append((op, x))
+        if new[0][0] == "/":
+            new.insert(0, ("*", Num(ONE)))
+        res = make_prod(new, n.d)
+        return make_neg(res, n.d) if neg else res
+    if len(nums) == 1 and all(op == "*" for op, _ in facs):
+        v = facs[nums[0]][1].v
+        if v == 0:
+            return Num(ZERO)
+        if v == 1:
+            return make_prod([f for i, f in enumerate(facs) if i != nums[0]], n.d)
+    return None
+
+
+def _red_sqrt(n, c):
+    v = n.arg.v
+    if v < 0:
+        raise error(c.lang, "sqrt_neg")
+    r = _exact_sqrt(v)
+    if r is not None:
+        return Num(r)
+    if v.denominator == 1:
+        k, m = _radical(v.numerator)
+        if k > 1:
+            return Prod((("*", Num(k)), ("*", Sqrt(Num(m), n.d))), n.d)
+    return None
+
+
+def _reduce(n, c):
+    t = type(n)
+    if t is Sum:
+        return _red_sum(n, c)
+    if t is Prod:
+        return _red_prod(n, c)
+    if t is Pow:
+        return Num(power(n.base.v, n.exp.v, c))
+    return _red_sqrt(n, c)
+
+
+# ----------------------------------------------------------------- traversal
+def _full(n, out, c):
+    t = type(n)
+    if t is Num:
+        return
+    if t is Sum:
+        if all(type(x) is Num for _, x in n.terms):
+            out.append(n)
+            return
+    elif t is Prod:
+        if all(type(x) is Num for _, x in n.facs):
+            out.append(n)
+            return
+    elif t is Pow:
+        if type(n.base) is Num and type(n.exp) is Num:
+            out.append(n)
+            return
+    elif t is Sqrt:
+        if type(n.arg) is Num:
+            if _red_sqrt(n, c) is not None:
+                out.append(n)
+            return
+    for k in kids(n):
+        _full(k, out, c)
+
+
+def _partial(n, out, c):
+    t = type(n)
+    found = False
+    for k in kids(n):
+        if _partial(k, out, c):
+            found = True
+    if found:
+        return True
+    if (t is Sum and _red_sum(n, c) is not None) or (t is Prod and _red_prod(n, c) is not None):
+        out.append(n)
+        return True
+    return False
+
+
+def _rebuild(n, picks, c):
+    if id(n) in picks:
+        return _reduce(n, c)
+    t = type(n)
+    if t is Sum:
+        new, changed = [], False
+        for s, x in n.terms:
+            y = _rebuild(x, picks, c)
+            changed = changed or y is not x
+            new.append((s, y))
+        return make_sum(new, n.d) if changed else n
+    if t is Prod:
+        new, changed = [], False
+        for op, x in n.facs:
+            y = _rebuild(x, picks, c)
+            if y is not x:
+                changed = True
+                if type(y) is Prod and op == "*":  # (a x b) x c -> a x b x c
+                    new.extend(y.facs)
+                    continue
+            new.append((op, y))
+        return make_prod(new, n.d) if changed else n
+    if t is Pow:
+        b, e = _rebuild(n.base, picks, c), _rebuild(n.exp, picks, c)
+        return n if b is n.base and e is n.exp else Pow(b, e, n.d)
+    if t is Sqrt:
+        a = _rebuild(n.arg, picks, c)
+        return n if a is n.arg else Sqrt(a, n.d)
+    if t is Neg:
+        a = _rebuild(n.arg, picks, c)
+        return n if a is n.arg else make_neg(a, n.d)
+    if t is Eq:
+        l, r = _rebuild(n.lhs, picks, c), _rebuild(n.rhs, picks, c)
+        return n if l is n.lhs and r is n.rhs else Eq(l, r)
+    return n
+
+
+def run(tree, c, emit):
+    """Reduce `tree` step by step; call emit(new_tree) after each step."""
+    for _ in range(1_000_000):
+        cands = []
+        _full(tree, cands, c)
+        if not cands:
+            _partial(tree, cands, c)
+        if not cands:
+            return tree
+        if any(x.d > 0 for x in cands):  # parentheses first
+            cands = [x for x in cands if x.d > 0]
+        tree = _rebuild(tree, {id(x) for x in cands}, c)
+        emit(tree)
+    raise error(c.lang, "too_big")
+
+
+# ------------------------------------------------------------ approximations
+_Q = Decimal(1).scaleb(-10)
+
+
+def _ap(n):
+    t = type(n)
+    if t is Num:
+        return Decimal(n.v.numerator) / Decimal(n.v.denominator)
+    if t is Sum:
+        tot = Decimal(0)
+        for s, x in n.terms:
+            tot += _ap(x) if s > 0 else -_ap(x)
+        return tot
+    if t is Prod:
+        acc = _ap(n.facs[0][1])
+        for op, x in n.facs[1:]:
+            acc = acc * _ap(x) if op == "*" else acc / _ap(x)
+        return acc
+    if t is Pow:
+        return _ap(n.base) ** _ap(n.exp)
+    if t is Sqrt:
+        return _ap(n.arg).sqrt()
+    if t is Neg:
+        return -_ap(n.arg)
+    raise TypeError(t)
+
+
+def approx(n, c):
+    try:
+        with localcontext() as ctx:
+            ctx.prec = 40
+            return _ap(n)
+    except ArithmeticError:
+        raise error(c.lang, "unsupported", what="approximation") from None
+
+
+def dec_str(d):
+    try:
+        s = format(d.quantize(_Q), "f")
+    except InvalidOperation:
+        return format(d, ".15g")
+    if "." in s:
+        s = s.rstrip("0").rstrip(".")
+    return "0" if s in ("", "-0") else s

math_step_to_step/errors.py

@@ -0,0 +1,72 @@
+"""Exception type and localized messages."""
+from __future__ import annotations
+
+
+class MathStepError(ValueError):
+    """Raised when an expression is invalid or not supported."""
+
+
+_MESSAGES = {
+    "vi": {
+        "empty": "Biểu thức rỗng.",
+        "too_long": "Biểu thức quá dài (tối đa {n} ký tự).",
+        "bad_char": "Ký tự không hợp lệ {c!r} ở vị trí {pos}.",
+        "unexpected": "Không hiểu {tok!r} ở vị trí {pos}.",
+        "unexpected_end": "Biểu thức bị thiếu ở cuối.",
+        "missing_rparen": "Thiếu dấu đóng ngoặc.",
+        "multi_eq": "Chỉ được có một dấu '='.",
+        "div_zero": "Không thể chia cho 0.",
+        "undefined": "0^0 không xác định.",
+        "too_big": "Số quá lớn để tính.",
+        "sqrt_neg": "Không thể lấy căn bậc hai của số âm.",
+        "int_exp": "Chỉ hỗ trợ số mũ nguyên.",
+        "multi_var": "Chỉ hỗ trợ một biến, nhưng tìm thấy: {names}.",
+        "unsupported": "Chưa hỗ trợ dạng biểu thức này ({what}).",
+        "degree": "Chỉ giải được phương trình bậc 1 và bậc 2.",
+        "nested": "Biểu thức lồng nhau quá sâu.",
+        "has_var": "Biểu thức chứa biến nên không tính ra một số được.",
+        "no_solution": "Phương trình vô nghiệm.",
+        "infinite": "Phương trình có vô số nghiệm.",
+        "delta_neg": "Δ < 0 ⇒ phương trình vô nghiệm (trong tập số thực).",
+        "delta_zero": "Δ = 0 ⇒ phương trình có nghiệm kép.",
+        "delta_pos": "Δ > 0 ⇒ phương trình có hai nghiệm phân biệt.",
+        "true": "Đúng.",
+        "false": "Sai.",
+    },
+    "en": {
+        "empty": "Empty expression.",
+        "too_long": "Expression too long (max {n} characters).",
+        "bad_char": "Invalid character {c!r} at position {pos}.",
+        "unexpected": "Unexpected {tok!r} at position {pos}.",
+        "unexpected_end": "Unexpected end of expression.",
+        "missing_rparen": "Missing closing parenthesis.",
+        "multi_eq": "Only one '=' is allowed.",
+        "div_zero": "Division by zero.",
+        "undefined": "0^0 is undefined.",
+        "too_big": "Number too large to compute.",
+        "sqrt_neg": "Square root of a negative number.",
+        "int_exp": "Only integer exponents are supported.",
+        "multi_var": "Only one variable is supported, found: {names}.",
+        "unsupported": "Unsupported expression ({what}).",
+        "degree": "Only linear and quadratic equations can be solved.",
+        "nested": "Expression is nested too deeply.",
+        "has_var": "Expression contains a variable and has no numeric value.",
+        "no_solution": "No solution.",
+        "infinite": "Infinitely many solutions.",
+        "delta_neg": "Δ < 0 ⇒ no real solutions.",
+        "delta_zero": "Δ = 0 ⇒ one repeated root.",
+        "delta_pos": "Δ > 0 ⇒ two distinct roots.",
+        "true": "True.",
+        "false": "False.",
+    },
+}
+
+LANGS = tuple(_MESSAGES)
+
+
+def msg(lang: str, key: str, **kw) -> str:
+    return _MESSAGES[lang][key].format(**kw)
+
+
+def error(lang: str, key: str, **kw) -> MathStepError:
+    return MathStepError(msg(lang, key, **kw))