How AI Berkshire's Tool Layer Prevents Common AI Arithmetic Errors in Financial Analysis

AI Berkshire eliminates floating-point drift and rounding errors by forcing all financial calculations through a self-contained exact-decimal engine with domain-specific validation checks.

The xbtlin/ai-berkshire repository implements a specialized Tool Layer specifically designed to prevent common AI arithmetic errors in financial analysis. By replacing standard IEEE-754 floating-point operations with Python's Decimal module, the system ensures that critical calculations—such as market-cap multiplications and valuation ratios—maintain exact precision without binary-float drift.

The Exact Decimal Engine at the Core

High-Precision Context Configuration

In tools/financial_rigor.py, the module establishes a hardened arithmetic environment at line 28 by configuring a decimal.Context with 28-digit precision and ROUND_HALF_EVEN rounding. This context governs every subsequent operation, preventing the accumulation of microscopic errors that plague standard floating-point math.

The exact() Conversion Function

The exact() function (lines 31-38) serves as the mandatory entry point for all numeric inputs. It converts strings, integers, or scientific notation into Decimal objects before any mathematical operation occurs. This guarantees that expressions like price × shares evaluate to exact values rather than approximations such as 0.1 + 0.2 ≠ 0.3.

Domain-Specific Validation Functions

Market-Cap Verification with Automatic Tolerance Checks

The verify_market_cap() function (lines 61-90) multiplies price and shares using the exact engine, then computes the percentage deviation against reported market-cap figures. If the deviation exceeds 5% (line 80) or 1% (line 86) depending on the context, the system raises an immediate warning. This automatic sanity-check catches arithmetic slips or stale inputs before they propagate into research reports.

Valuation-Ratio Verification

verify_valuation() (lines 98-160) calculates PE, PB, ROE, P/FCF, and dividend yield using the same Decimal context. Results are rendered with two-decimal precision and stored in a dictionary for downstream use, eliminating the "off-by-a-cent" errors that can alter investment conclusions.

Cross-Source Data Validation

The cross_validate() function (lines 67-104) converts values from multiple data providers to Decimal, computes a median consensus, and flags any source whose deviation exceeds a configurable 2% tolerance. This detects outlier numbers often stemming from mis-typed values or inconsistent rounding across financial data feeds.

Benford's Law Statistical Guard

benford_check() (lines 111-162) analyzes the leading digits of numeric series using exact arithmetic and reports the Mean Absolute Deviation (MAD). This provides a statistical guard against fabricated or mistakenly altered financial figures—a subtle error source for AI-generated data.

Utility Functions for Safe Financial Modeling

Exact Calculator for Ad-Hoc Analysis

exact_calc() (lines 88-113) evaluates arbitrary arithmetic expressions safely by first sanitizing the input string and then executing it within the exact-decimal context. Analysts can run ad-hoc calculations without importing floating-point contaminants.

python3 tools/financial_rigor.py calc --expr '510 * 9.11e9'

Three-Scenario Valuation Projections

three_scenario_valuation() (lines 120-165) projects EPS growth over multiple years using the exact engine, then derives target prices for optimistic, neutral, and pessimistic cases. This ensures compound-growth math remains precise, preventing small rounding differences from compounding dramatically across scenarios.

Human-Readable Number Formatting

fmt_number() (lines 40-55) renders very large numbers (billions, trillions) in human-readable units with consistent labeling. This prevents confusion between "亿", "万亿", "B", and "T"—a frequent source of unit-mismatch errors in financial models.

Defense-in-Depth Architecture

Zero External Dependencies Policy

The entire toolkit relies exclusively on Python's standard library (decimal, json, math, argparse). No third-party packages are imported, ensuring deterministic and reproducible behavior across machines and CI pipelines without hidden sources of numeric inconsistency.

Practical Command Examples

Verify market-cap calculations with automatic deviation checking:

python3 tools/financial_rigor.py verify-market-cap \
  --price 510 --shares 9.11e9 --reported 4.65e12 --currency HKD

Compute valuation ratios with guaranteed precision:

python3 tools/financial_rigor.py verify-valuation \
  --price 510 --eps 23.5 --bvps 120 --fcf-per-share 18 --dividend 2.4

Validate data consistency across multiple sources:

python3 tools/financial_rigor.py cross-validate \
  --field revenue \
  --values '{"年报": 7518, "Yahoo": 7500, "StockAnalysis": 7520}' \
  --unit 亿

Perform statistical authenticity checks:

python3 tools/financial_rigor.py benford \
  --values '[1234, 2345, 3456, 4567, 5678, 6789, 7890, 8901, 9012]'

Run multi-scenario valuation with exact compounding:

python3 tools/financial_rigor.py three-scenario \
  --price 510 --eps 23.5 --shares 9.11 \
  --growth 0.15 0.08 0.0 \
  --pe 25 20 15 \
  --years 3 --currency HKD

Summary

• Exact-decimal enforcement: All numeric inputs convert to Decimal objects via exact() before calculation, eliminating binary-float drift.
• Automated tolerance checks: Functions like verify_market_cap() and cross_validate() enforce strict percentage thresholds (1%, 2%, 5%) to catch outliers.
• Domain-specific validation: PE, PB, and ratio calculations use a unified 28-digit precision context to prevent rounding errors.
• Statistical guards: Benford's Law analysis detects anomalous data patterns using exact arithmetic.
• Zero-dependency reliability: Standard-library-only design ensures reproducible results across environments.

Frequently Asked Questions

Why does AI Berkshire use Decimal instead of standard floating-point?

Standard IEEE-754 floating-point arithmetic introduces representation errors for common decimal values like 0.1 or 0.01. By routing all calculations through Python's Decimal class with a 28-digit precision context, AI Berkshire ensures that multiplication, division, and compound-growth operations yield exact results without accumulation of microscopic drift.

How does the Tool Layer detect data entry errors?

The cross_validate() function computes a median consensus across multiple data sources and flags any value exceeding a 2% deviation tolerance. Additionally, verify_market_cap() cross-checks calculated market caps against reported figures with configurable thresholds at 1% and 5%, catching stale or mis-typed inputs before they reach final reports.

What is the Benford's Law check used for?

benford_check() analyzes the distribution of leading digits in financial datasets using exact arithmetic. Natural financial data follows Benford's Law, so significant deviations indicate potential data fabrication, transcription errors, or AI hallucinations. The function reports Mean Absolute Deviation (MAD) and conformity ratings to flag suspicious patterns.

Can I use the exact calculator for custom expressions?

Yes. The exact_calc() function accepts arbitrary arithmetic expressions via the --expr argument, sanitizes the input string, and evaluates it within the exact-decimal context. This allows analysts to run ad-hoc calculations—such as 510 * 9.11e9—without importing floating-point errors from standard Python evaluation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}