# How Formulas Are Handled in the Patent Disclosure Process: A Technical Deep Dive

> Discover how formulas are handled in patent disclosures via a four stage pipeline: parsing, validation, evaluation, and integration within the handsomestWei/patent-disclosure-skill repository for accuracy and compliance.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: deep-dive
- Published: 2026-09-04

---

**Formulas in the patent disclosure process undergo a rigorous four-stage pipeline—chemical parsing, semantic validation, secure evaluation, and paradigm integration—to ensure scientific accuracy and legal compliance in the `handsomestWei/patent-disclosure-skill` repository.**

The `handsomestWei/patent-disclosure-skill` repository implements a sophisticated architecture for managing how formulas are handled in the patent disclosure process. This open-source skill treats chemical and mathematical expressions as first-class data structures that require specialized parsing, validation, and rendering workflows. The system separates concerns across four dedicated modules that transform raw formula strings into structured disclosure plans suitable for legal documentation.

## The Four-Stage Formula Processing Pipeline

### Stage 1: Chemical Syntax Parsing and Normalization

The pipeline begins in [`skills/patent-disclosure/tools/formula_chem.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_chem.py), where the `parse_formula_atoms()` function processes raw chemical strings such as "H₂O" or "C6H12O6·2H₂O". This module normalizes delimiters and extracts precise atomic counts, storing them in a Counter structure. The `latex_looks_chemical()` function validates that the syntax conforms to chemical notation expectations before further processing occurs.

### Stage 2: Semantic Unit and Additive Validation

Next, [`skills/patent-disclosure/tools/formula_units.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_units.py) performs semantic validation through the `check_additive_units()` function. This stage verifies that units and additive scores used within formulas are appropriate for the specific patent case, prohibiting decorative or non-compliant units while ensuring correct weighting parameters. The validation ensures that score weights and measurement units align with patent disclosure standards.

### Stage 3: Secure Arithmetic Evaluation

The [`skills/patent-disclosure/tools/formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_eval.py) module handles mathematical computation through the `eval_equation()` function. Rather than using unsafe evaluation methods, this implementation employs a sandboxed `eval` environment restricted to a whitelisted set of functions including `min` and `max`. This approach safely calculates arithmetic expressions embedded within formula plans without exposing the system to code injection vulnerabilities.

### Stage 4: Paradigm Integration and Plan Assembly

The final stage involves [`skills/patent-disclosure/tools/formula_paradigms.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_paradigms.py) and [`skills/patent-disclosure/tools/check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/check_formula_plan.py). The `load_paradigms()` function loads predefined formula paradigms from YAML or JSON configurations, while `paradigm_by_id()` retrieves specific interpretation schemas. The [`check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/check_formula_plan.py) module orchestrates the assembly of a comprehensive **formula_plan** that consolidates parsed atoms, validated units, evaluated results, and selected paradigms into a structured object that drives downstream document generation.

## Complete Workflow Implementation

The following Python example demonstrates the complete formula processing workflow as implemented in the patent-disclosure-skill repository:

```python
from formula_chem import parse_formula_atoms, latex_looks_chemical
from formula_units import check_additive_units
from formula_eval import eval_equation
from formula_paradigms import load_paradigms, paradigm_by_id

# 1️⃣ Parse the raw chemical formula string

atoms, err = parse_formula_atoms("C6H12O6·2H2O")
assert not err, f"Parse error: {err}"
print(atoms)       # Counter({'C': 6, 'H': 14, 'O': 8})

# 2️⃣ Validate chemical syntax conventions

assert latex_looks_chemical("C6H12O6·2H2O")

# 3️⃣ Check additive units and score weights

units_ok = check_additive_units({"score": 5, "weight": 0.2})
assert units_ok

# 4️⃣ Evaluate arithmetic components safely

value = eval_equation("5 * 0.2 + 3")
print(value)       # 4.0

# 5️⃣ Load paradigms and retrieve case-specific interpretation

paradigms = load_paradigms()
para = paradigm_by_id(paradigms, "weighted_sum")
print(para["description"])

```

This workflow transforms raw formulas into structured `formula_plan` objects that downstream tools consume for Markdown-to-Docx conversion and SVG rendering.

## Summary

- **`parse_formula_atoms()`** in [`skills/patent-disclosure/tools/formula_chem.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_chem.py) normalizes chemical strings and extracts atomic counts for formulas like "C6H12O6·2H2O".
- **`check_additive_units()`** in [`skills/patent-disclosure/tools/formula_units.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_units.py) validates semantic constraints and prohibits non-compliant units.
- **`eval_equation()`** in [`skills/patent-disclosure/tools/formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_eval.py) provides sandboxed arithmetic evaluation using a restricted function whitelist.
- **`load_paradigms()`** and **`paradigm_by_id()`** in [`skills/patent-disclosure/tools/formula_paradigms.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_paradigms.py) enable case-specific formula interpretation via YAML/JSON configurations.
- **[`check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/check_formula_plan.py)** orchestrates the complete pipeline, assembling validated components into executable **formula_plan** structures.

## Frequently Asked Questions

### What is the specific role of formula_chem.py in processing patent formulas?

The [`skills/patent-disclosure/tools/formula_chem.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_chem.py) module serves as the entry point for chemical formula processing, providing the `parse_formula_atoms()` function to normalize delimiters and extract atomic counts. It also includes `latex_looks_chemical()` to validate that raw strings conform to chemical notation standards before they enter the validation pipeline.

### How does the patent-disclosure-skill prevent security risks during formula evaluation?

The system utilizes `eval_equation()` in [`skills/patent-disclosure/tools/formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_eval.py), which implements a sandboxed evaluation environment restricted to a whitelisted set of safe functions such as `min` and `max`. This approach prevents code injection while allowing necessary arithmetic calculations for formula-derived values.

### What purpose do paradigms serve in the formula disclosure workflow?

Paradigms, managed by [`skills/patent-disclosure/tools/formula_paradigms.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/formula_paradigms.py), are predefined YAML/JSON configurations that specify how formulas should be interpreted in particular patent cases. The `paradigm_by_id()` function retrieves these schemas, enabling [`check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/check_formula_plan.py) to generate context-aware **formula_plan** objects that guide downstream document generation and rendering.

### Which module coordinates the entire formula processing pipeline?

The [`skills/patent-disclosure/tools/check_formula_plan.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/check_formula_plan.py) module acts as the orchestration layer, integrating outputs from [`formula_chem.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/formula_chem.py), [`formula_units.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/formula_units.py), and [`formula_eval.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/formula_eval.py) with paradigm definitions to produce comprehensive **formula_plan** structures. These plans subsequently drive text generation and illustration tools for final patent document assembly.