Datasets:
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
mathematics
formal-verification
symbolic-algebra
theorem-proving
multi-agent-systems
benchmark
Download lgmath/parse_b.py from tailot/lingologos-math: direct link, hf CLI and curl.
- Browser
- Download file 12.6 kB
-
https://huggingface.co/datasets/tailot/lingologos-math/resolve/main/lgmath/parse_b.py
- Command line
-
hf download hf://datasets/tailot/lingologos-math/lgmath/parse_b.py
-
curl -L -o parse_b.py https://huggingface.co/datasets/tailot/lingologos-math/resolve/main/lgmath/parse_b.py
12.6 kB
| """Formalizer B parser: string splitting for the logic layer, CPython's parser for arithmetic. | |
| It is written independently of :mod:`parse_a` on purpose. The logic layer (quantifiers, '<=>', | |
| '=>', 'or', 'and', 'not') is handled by splitting the text at the lowest precedence top level | |
| connective. Every arithmetic comparison operand is handed to ``ast.parse`` from the standard | |
| library, so the precedence of '+ - * / ^' comes from a third party parser, not from this code. | |
| """ | |
| import ast as pyast | |
| import re | |
| from fractions import Fraction | |
| from typing import Dict, List, Optional, Tuple | |
| from .tree import KEYWORDS, Node, ParseError, UnsupportedError, check_input_text | |
| _NAME = {"<=>": "iff", "=>": "imp", "or": "or", "and": "and"} | |
| _REL = {"=": "eq", "!=": "ne", "<": "lt", "<=": "le", ">": "gt", ">=": "ge", "|": "dvd"} | |
| _BINOPS = { | |
| pyast.Add: "add", | |
| pyast.Sub: "sub", | |
| pyast.Mult: "mul", | |
| pyast.Div: "div", | |
| pyast.Pow: "pow", | |
| pyast.Mod: "mod", | |
| pyast.FloorDiv: "idiv", | |
| } | |
| def _top_level_connectives(text: str) -> List[Tuple[int, str]]: | |
| """Connectives at parenthesis depth 0 that sit before any depth 0 quantifier.""" | |
| found: List[Tuple[int, str]] = [] | |
| depth = 0 | |
| i = 0 | |
| n = len(text) | |
| cut = False | |
| while i < n: | |
| char = text[i] | |
| if char == "(": | |
| depth += 1 | |
| elif char == ")": | |
| depth -= 1 | |
| if depth < 0: | |
| raise ParseError("unbalanced parenthesis") | |
| elif depth == 0: | |
| if text.startswith("<=>", i): | |
| found.append((i, "<=>")) | |
| i += 3 | |
| continue | |
| if text.startswith("=>", i): | |
| found.append((i, "=>")) | |
| i += 2 | |
| continue | |
| if char.isalpha() or char == "_": | |
| j = i | |
| while j < n and (text[j].isalnum() or text[j] == "_"): | |
| j += 1 | |
| word = text[i:j] | |
| if word in ("or", "and"): | |
| found.append((i, word)) | |
| elif word in ("forall", "exists"): | |
| cut = True | |
| break | |
| i = j | |
| continue | |
| i += 1 | |
| if depth > 0 and not cut: | |
| raise ParseError("unbalanced parenthesis") | |
| return found | |
| def _matching_paren(text: str, start: int) -> int: | |
| depth = 0 | |
| for i in range(start, len(text)): | |
| if text[i] == "(": | |
| depth += 1 | |
| elif text[i] == ")": | |
| depth -= 1 | |
| if depth == 0: | |
| return i | |
| raise ParseError("unbalanced parenthesis") | |
| _QUANT = re.compile( | |
| r"^(forall|exists)\b\s*([A-Za-z_][A-Za-z_0-9]*)\s*(?:in\s+([A-Za-z_][A-Za-z_0-9]*)\s*)?\.(.*)$", re.S | |
| ) | |
| def _formula(text: str) -> Node: | |
| text = text.strip() | |
| if not text: | |
| raise ParseError("empty formula") | |
| connectives = _top_level_connectives(text) | |
| for op, take_last in (("<=>", True), ("=>", False), ("or", True), ("and", True)): | |
| hits = [pos for pos, name in connectives if name == op] | |
| if hits: | |
| pos = hits[-1] if take_last else hits[0] | |
| return (_NAME[op], _formula(text[:pos]), _formula(text[pos + len(op):])) | |
| match = re.match(r"^not\b(.*)$", text, re.S) | |
| if match: | |
| return ("not", _formula(match.group(1))) | |
| match = _QUANT.match(text) | |
| if match: | |
| kind, name, domain, body = match.groups() | |
| if name in KEYWORDS: | |
| raise ParseError("reserved word used as a variable name") | |
| if domain is not None and domain not in ("R", "Z"): | |
| raise UnsupportedError("only the domains R and Z are supported") | |
| return (kind, name, domain or "R", _formula(body)) | |
| if text in ("true", "false"): | |
| return (text,) | |
| if text.startswith("(") and _matching_paren(text, 0) == len(text) - 1: | |
| return _formula(text[1:-1]) | |
| return _relation(text) | |
| def _relation(text: str) -> Node: | |
| parts: List[str] = [] | |
| ops: List[str] = [] | |
| depth = 0 | |
| start = 0 | |
| i = 0 | |
| while i < len(text): | |
| char = text[i] | |
| if char == "(": | |
| depth += 1 | |
| elif char == ")": | |
| depth -= 1 | |
| elif depth == 0: | |
| if text[i:i + 2] in ("<=", ">=", "!="): | |
| ops.append(text[i:i + 2]) | |
| parts.append(text[start:i]) | |
| start = i + 2 | |
| i += 2 | |
| continue | |
| if char in "<>=|": | |
| ops.append(char) | |
| parts.append(text[start:i]) | |
| start = i + 1 | |
| i += 1 | |
| continue | |
| i += 1 | |
| parts.append(text[start:]) | |
| if not ops: | |
| raise ParseError("a comparison operator is required") | |
| terms = [_term(part) for part in parts] | |
| result: Node = (_REL[ops[0]], terms[0], terms[1]) | |
| for index in range(1, len(ops)): | |
| result = ("and", result, (_REL[ops[index]], terms[index], terms[index + 1])) | |
| return result | |
| def _prepare(text: str) -> "Tuple[str, Dict[str, Fraction]]": | |
| """Make a term or literal digestible for ast.parse without changing its meaning.""" | |
| if "**" in text or "//" in text or "%" in text: | |
| raise ParseError("'**', '//' and '%' are not operators of the math language") | |
| if re.search(r"(?<![A-Za-z_0-9])\d+_", text) or re.search(r"(?<![A-Za-z_0-9])0[xXoObB]", text): | |
| raise ParseError("unsupported numeric literal") | |
| decimals: Dict[str, Fraction] = {} | |
| def keep(match: "re.Match[str]") -> str: | |
| key = "__d%d__" % len(decimals) | |
| decimals[key] = Fraction(match.group(0)) | |
| return key | |
| text = re.sub(r"(?<![A-Za-z_0-9.])\d+\.\d+", keep, text) | |
| text = re.sub(r"\bmod\b", "%", text) | |
| text = re.sub(r"\bdiv\b", "//", text) | |
| return text.replace("^", "**"), decimals | |
| def _parse_expression(text: str) -> "pyast.expr": | |
| try: | |
| return pyast.parse(text, mode="eval").body | |
| except (SyntaxError, ValueError, RecursionError, MemoryError) as exc: | |
| raise ParseError("invalid expression: %s" % exc) from exc | |
| def _term(text: str) -> Node: | |
| text = text.strip() | |
| if not text: | |
| raise ParseError("empty term") | |
| prepared, decimals = _prepare(text) | |
| return _convert(_parse_expression(prepared), decimals) | |
| def _literal_nodes(text: str) -> "Tuple[pyast.List, Dict[str, Fraction]]": | |
| prepared, decimals = _prepare(text.strip()) | |
| body = _parse_expression(prepared) | |
| if not isinstance(body, pyast.List) or not body.elts: | |
| raise ParseError("a matrix or vector literal such as [[1, 2], [3, 4]] or [1, 2] is required") | |
| return body, decimals | |
| def _matrix(text: str) -> Node: | |
| body, decimals = _literal_nodes(text) | |
| rows = [] | |
| for row in body.elts: | |
| if not isinstance(row, pyast.List) or not row.elts: | |
| raise ParseError("every matrix row must be a non empty list") | |
| rows.append(("row",) + tuple(_convert(e, decimals) for e in row.elts)) | |
| if len({len(r) for r in rows}) != 1: | |
| raise ParseError("matrix rows must have the same length") | |
| return ("mat",) + tuple(rows) | |
| def _vector(text: str) -> Node: | |
| body, decimals = _literal_nodes(text) | |
| if any(isinstance(e, pyast.List) for e in body.elts): | |
| raise ParseError("a vector literal is a flat list") | |
| return ("vec",) + tuple(_convert(e, decimals) for e in body.elts) | |
| def _take_literal(text: str) -> "Tuple[str, str]": | |
| """Split a leading bracketed literal from the rest of the text.""" | |
| text = text.lstrip() | |
| if not text.startswith("["): | |
| raise ParseError("a bracketed literal is required") | |
| depth = 0 | |
| for i, char in enumerate(text): | |
| if char == "[": | |
| depth += 1 | |
| elif char == "]": | |
| depth -= 1 | |
| if depth == 0: | |
| return text[: i + 1], text[i + 1:] | |
| raise ParseError("unbalanced bracket") | |
| def _convert(node: "pyast.AST", decimals: Dict[str, Fraction]) -> Node: | |
| if isinstance(node, pyast.BinOp): | |
| name = _BINOPS.get(type(node.op)) | |
| if name is None: | |
| raise UnsupportedError("unsupported operator") | |
| return (name, _convert(node.left, decimals), _convert(node.right, decimals)) | |
| if isinstance(node, pyast.UnaryOp): | |
| if isinstance(node.op, pyast.USub): | |
| return ("neg", _convert(node.operand, decimals)) | |
| raise UnsupportedError("unary plus is not part of the math language") | |
| if isinstance(node, pyast.Constant): | |
| if type(node.value) is int and node.value >= 0: | |
| return ("num", Fraction(node.value)) | |
| raise UnsupportedError("unsupported literal") | |
| if isinstance(node, pyast.Name): | |
| if node.id in decimals: | |
| return ("num", decimals[node.id]) | |
| if node.id in KEYWORDS: | |
| raise ParseError("reserved word used inside a term") | |
| return ("var", node.id) | |
| raise UnsupportedError("unsupported construct %s" % type(node).__name__) | |
| _COMMANDS = ("evaluate", "prove", "solve", "derivative", "antiderivative", "integral", "maximize", "minimize", | |
| "det", "rank", "inverse", "nullspace", "linsolve", "product", "power") | |
| _IDENT = r"[A-Za-z_][A-Za-z_0-9]*" | |
| def _name(text: str) -> str: | |
| text = text.strip() | |
| if text in KEYWORDS or not re.match("^" + _IDENT + "$", text): | |
| raise ParseError("invalid variable name %r" % text) | |
| return text | |
| def _wrt(rest: str) -> "Tuple[str, Optional[str]]": | |
| match = re.match(r"^(.*?)\s*(?:\bwrt\s+(" + _IDENT + r"))?\s*$", rest, re.S) | |
| assert match is not None | |
| return match.group(1), (_name(match.group(2)) if match.group(2) else None) | |
| def parse_problem(text: str) -> Node: | |
| """Parse one sentence of the math language into an AST (formalizer B).""" | |
| text = re.sub(r"\s+", " ", check_input_text(text)) | |
| match = re.match(r"^(" + "|".join(_COMMANDS) + r")\b\s*(.*)$", text) | |
| if not match: | |
| raise ParseError("a problem starts with a command word such as evaluate, prove or solve") | |
| kind, rest = match.groups() | |
| try: | |
| if kind == "evaluate": | |
| return ("evaluate", _term(rest)) | |
| if kind == "prove": | |
| over = re.match(r"^(.*)\bover\s+Z\s*$", rest) | |
| return ("provez", _formula(over.group(1))) if over else ("prove", _formula(rest)) | |
| if kind == "solve": | |
| tail = re.match(r"^(.*)\bfor\s+(" + _IDENT + r"(?:\s*,\s*" + _IDENT + r")*)\s*(over\s+Z)?\s*$", rest) | |
| if not tail: | |
| raise ParseError("solve needs a trailing 'for <variables>'") | |
| names = [_name(n) for n in tail.group(2).split(",")] | |
| if tail.group(3) and len(names) > 1: | |
| raise UnsupportedError("integer systems are not supported") | |
| body = _formula(tail.group(1)) | |
| if len(names) > 1: | |
| return ("solvesys", body, ("names",) + tuple(names)) | |
| return ("solvez" if tail.group(3) else "solve", body, names[0]) | |
| if kind in ("derivative", "antiderivative"): | |
| body, name = _wrt(rest) | |
| return (kind, _term(body), name) | |
| if kind == "integral": | |
| pieces = [s.strip() for s in re.split(r"\b(from|to|wrt)\b", rest)] | |
| if pieces[1:2] != ["from"] or pieces[3:4] != ["to"] or len(pieces) not in (5, 7): | |
| raise ParseError("integral needs 'from <a> to <b>'") | |
| name = None | |
| if len(pieces) == 7: | |
| if pieces[5] != "wrt": | |
| raise ParseError("only 'wrt <variable>' may follow the upper bound") | |
| name = _name(pieces[6]) | |
| return ("integral", _term(pieces[0]), name, _term(pieces[2]), _term(pieces[4])) | |
| if kind in ("maximize", "minimize"): | |
| split = re.match(r"^(.*?)\bsubject\s+to\b(.*)$", rest) | |
| if not split: | |
| raise ParseError("an optimization needs 'subject to <constraints>'") | |
| return ("optimize", kind[:3], _term(split.group(1)), _formula(split.group(2))) | |
| first, remainder = _take_literal(rest) | |
| if kind in ("det", "rank", "inverse", "nullspace"): | |
| if remainder.strip(): | |
| raise ParseError("unexpected trailing input") | |
| return (kind, _matrix(first)) | |
| if kind in ("linsolve", "product"): | |
| second, remainder = _take_literal(remainder) | |
| if remainder.strip(): | |
| raise ParseError("unexpected trailing input") | |
| return (kind, _matrix(first), _vector(second) if kind == "linsolve" else _matrix(second)) | |
| return ("power", _matrix(first), _term(remainder)) | |
| except RecursionError as exc: | |
| raise ParseError("expression nested too deeply") from exc | |