# How Mathematical Content Is Validated in Invention Disclosures Using the Formula-Paradigm System

> Learn how the formula-paradigm system validates mathematical content in invention disclosures. Discover its restricted-evaluation pipeline for parsing LaTeX, evaluating equations, and reporting status.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: how-to-guide
- Published: 2026-09-02

---

**The formula-paradigm system validates mathematical content in invention disclosures through a restricted-evaluation pipeline that parses LaTeX equations, evaluates them against numeric examples, and reports ok/mismatch/skip status.**

Invention disclosures in the `handsomestWei/patent-disclosure-skill` repository rely on a **formula-paradigm system** to ensure mathematical correctness. This system bridges the gap between human-readable LaTeX formulas and machine-verifiable numeric validation, giving inventors immediate feedback on whether their equations hold true under concrete examples.

## The Five-Stage Validation Pipeline

The formula-paradigm validation follows a strict pipeline implemented across three core modules in `tools/shared/`.

### 1. Load Formula-Paradigm Configuration

The system first loads a merged configuration of **rules**, **paradigms**, and **combos** from [`references/formulas/paradigms.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/references/formulas/paradigms.yaml). Case-specific overrides can extend or modify these definitions.

```python

# tools/shared/formula_paradigms.py → load_paradigms()

from tools.shared.formula_paradigms import load_paradigms

paradigms = load_paradigms("my_custom_case/")

# Returns merged dict with 'rules', 'paradigms', 'combos' keys

```

This configuration declares which formula patterns are recognized (e.g., `weighted_sum`, `stoichiometric_reaction`) and what structural constraints apply.

### 2. Parse Each Equation from the Disclosure Plan

The `check_plan()` function in [`tools/shared/check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/check_formula_plan.py) extracts equations from the disclosure plan and prepares them for evaluation.

```python

# tools/shared/check_formula_plan.py → check_plan()

from tools.shared.check_formula_plan import check_plan

plan = {
    "paradigm_ids": ["weighted_sum"],
    "equations": [
        {"tag": 1, "paradigm_id": "weighted_sum", "latex": r"s = \alpha x + \beta y", "role": "score"},
    ],
    "numeric_example": {
        "given": {"alpha": 0.5, "x": 0.8, "beta": 0.5, "y": 0.6},
        "result": {"s": 0.7},
    },
}

```

Each equation carries a LaTeX representation and references a declared paradigm.

### 3. Perform Restricted Evaluation of the Right-Hand Side

The heart of mathematical content validation is `eval_equation()` in [`tools/shared/formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/formula_eval.py). This function performs **safe, restricted evaluation** through these steps:

- **LaTeX normalization**: Converts `\frac`, `\cdot`, `\times`, Greek symbols, and other LaTeX constructs to pure Python arithmetic via `_latex_ops_to_python`
- **Symbol substitution**: Replaces symbolic names with numeric values from the `given` example (`given_map`)
- **Safety filtering**: Rejects expressions containing disallowed constructs via `_should_skip` and `_ast_allowed`
- **Implicit multiplication insertion**: Automatically inserts `*` where needed (e.g., `2x → 2 * x`)

```python

# tools/shared/formula_eval.py → eval_equation()

from tools.shared.formula_eval import eval_equation

result = eval_equation(
    r"s = \alpha x + \beta y",           # LaTeX equation

    {"alpha": 0.5, "x": 0.8, "beta": 0.5, "y": 0.6},  # given_map

    {"s": 0.7},                          # expected result map

)
print(result)

# {'status': 'ok', 'lhs': 's', 'got': 0.7, 'expected': 0.7}

```

### 4. Compare Computed vs. Disclosed Results Using Tolerance

The system determines match status through `close_enough()`, which applies:

- **Relative tolerance**: `1e-6`
- **Absolute tolerance**: `1e-9`

| Status | Trigger Condition |
|--------|-----------------|
| **ok** | Computed value matches disclosed `result` within tolerance |
| **mismatch** | Values differ beyond tolerance |
| **skip** | Expression cannot be safely evaluated (unsupported operators, missing symbols, etc.) |

### 5. Aggregate Validation Outcomes

`check_plan()` returns a structured result that downstream tools render to the inventor:

```python
validation = check_plan(plan, eval_numeric=True)
print(validation)

# {'ok': True, 'errors': [], 'warnings': []}

```

The `ok` boolean indicates overall validity, while `errors` and `warnings` provide detailed per-equation diagnostics.

## Core Validation Rules Enforced by the System

The formula-paradigm system imposes strict constraints to maintain safety and predictability.

### Allowed Operators and Constructs

Only these operations are permitted in `_ALLOWED_AST`:

- Arithmetic: `+`, `-`, `*`, `/`
- Functions: `min`, `max`
- Simple fractions via `\frac`

### Skip Patterns That Trigger Automatic Bypass

The `_SKIP_PATTERNS` regex and `_should_skip` function reject:

- Summations: `\sum`
- Products: `\prod`
- Case statements: `\begin{cases}`
- Absolute-value bars: `|...|`

```python

# Example: summation causes skip status

result = eval_equation(
    r"\sigma = \frac{1}{W} \sum_{k=1}^{W} s_{(k)}",
    {"W": 3},
    {"sigma": 1},
)
print(result)

# {'status': 'skip', 'reason': '含无法受限代算的结构（\\sum）'}

```

### Symbol Binding Requirements

All symbols on the right-hand side must exist in `given_map`. Missing symbols trigger a skip with explanatory reason.

### Result Mapping and Key Normalization

The left-hand side identifier is normalized via `_norm_key()` before matching against the `result` map, handling LaTeX formatting variations.

## Complete Validation Examples

### Valid Weighted-Sum Equation

```python
from tools.shared.formula_eval import eval_equation

result = eval_equation(
    r"s = \alpha x + \beta y",
    {"alpha": 0.5, "x": 0.8, "beta": 0.5, "y": 0.6},
    {"s": 0.7},
)
print(result)  # {'status': 'ok', 'lhs': 's', 'got': 0.7, 'expected': 0.7}

```

### Detected Mismatch with Diagnostic Details

```python
from tools.shared.check_formula_plan import check_plan

plan = {
    "paradigm_ids": ["weighted_sum"],
    "equations": [
        {"tag": 1, "paradigm_id": "weighted_sum", "latex": r"s = \alpha x + \beta y", "role": "score"},
    ],
    "numeric_example": {
        "given": {"alpha": 0.5, "x": 0.8, "beta": 0.5, "y": 0.6},
        "result": {"s": 0.1},  # INCORRECT: should be 0.7

    },
}

validation = check_plan(plan, eval_numeric=True)
print(validation["ok"])      # False

print(validation["errors"])

# [{'status': 'mismatch', 'reason': '代算 0.7 与 result 0.1 不符（rel=1e-06）', ...}]

```

### Full Plan Validation with Numeric Evaluation Enabled

```python
from tools.shared.check_formula_plan import check_plan

plan = {
    "paradigm_ids": ["weighted_sum"],
    "equations": [
        {"tag": 1, "paradigm_id": "weighted_sum", "latex": r"s = \alpha x + \beta y", "role": "score"},
    ],
    "numeric_example": {
        "given": {"alpha": 0.5, "x": 0.8, "beta": 0.5, "y": 0.6},
        "result": {"s": 0.7},
    },
}
validation = check_plan(plan, eval_numeric=True)
print(validation)  # {'ok': True, 'errors': [], 'warnings': []}

```

## Source Code Reference Map

| File | Purpose | Key Functions |
|------|---------|---------------|
| [`tools/shared/formula_paradigms.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/formula_paradigms.py) | Configuration loading | `load_paradigms()` |
| [`tools/shared/formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/formula_eval.py) | Core evaluation engine | `eval_equation()`, `_latex_ops_to_python()`, `_should_skip()`, `_ast_allowed()`, `close_enough()` |
| [`tools/shared/check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/check_formula_plan.py) | Plan-level orchestration | `check_plan()` |
| [`references/formulas/paradigms.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/references/formulas/paradigms.yaml) | Declarative paradigm definitions | YAML rules, paradigms, combos |
| [`tests/shared/test_formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tests/shared/test_formula_eval.py) | Unit tests for validation logic | Test cases for ok/mismatch/skip |

## Summary

- **Configuration-driven**: The formula-paradigm system loads reusable mathematical patterns from [`paradigms.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/paradigms.yaml) and supports case-specific overrides.
- **Safety-first evaluation**: `eval_equation()` in [`formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/formula_eval.py) converts LaTeX to Python through restricted AST evaluation, rejecting dangerous constructs automatically.
- **Clear status reporting**: Every equation receives one of three statuses—**ok**, **mismatch**, or **skip**—with human-readable explanations.
- **Tolerance-aware matching**: Numeric comparison uses `1e-6` relative and `1e-9` absolute tolerance to handle floating-point variation.
- **Integration-ready**: `check_plan()` aggregates results into a standard format consumable by skill UIs and documentation generators.

## Frequently Asked Questions

### What causes a formula to receive "skip" status instead of "mismatch"?

A **skip** status indicates the expression cannot be safely evaluated, not that it failed validation. Triggers include unsupported LaTeX constructs like `\sum`, `\prod`, or `\begin{cases}`, disallowed AST nodes beyond `+ - * / min max`, or missing symbols in the `given_map`. This distinction prevents false negatives while maintaining security.

### How does the system handle implicit multiplication in LaTeX formulas?

The `_insert_implicit_mul()` function in [`formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/formula_eval.py) automatically inserts multiplication operators between adjacent terms, converting patterns like `2x` or `\alpha\beta` into `2*x` and `alpha*beta` before Python evaluation. This bridges the gap between mathematical notation and executable code.

### Can custom formula paradigms be added to the system?

Yes. The `load_paradigms()` function accepts an optional directory path for case-specific overrides. Place a [`paradigms.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/paradigms.yaml) with your custom `rules`, `paradigms`, or `combos` definitions in this directory; they merge with the base configuration from [`references/formulas/paradigms.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/references/formulas/paradigms.yaml).

### What tolerance values does the validation use for numeric comparison?

The `close_enough()` function applies **relative tolerance of `1e-6`** and **absolute tolerance of `1e-9`**. This matches common scientific computing standards and reliably catches meaningful discrepancies while accommodating minor floating-point representation differences.