ZDTP Chess

Multi-Dimensional Decision Intelligence Using Applied Pathological Mathematics

"Better math, less suffering" - Chavez AI Labs

What Makes This Different

Traditional chess engines evaluate positions with a single number. Zero Divisor Transmission Protocol (ZDTP) evaluates positions across three dimensional layers simultaneously:

• 16D Tactical Layer - Immediate threats, hanging pieces, forcing sequences

• 32D Positional Layer - Piece coordination, pawn structure, gateway patterns

• 64D Strategic Layer - Long-term planning, endgame evaluation, strategic depth

Each position is analyzed through six mathematical gateways (King, Queen, Knight, Bishop, Rook, Pawn) derived from zero divisor patterns in higher-dimensional algebras. When multiple gateways converge on the same evaluation, that agreement is a signal that the assessment is stable across the different feature weightings each gateway induces.

This is infrastructure for AI systems, not a chess product. Chess is the proof of concept for multi-dimensional decision intelligence.

Related MCP server: Chess MCP

Features

Gateway Convergence Detection

Six mathematical "gateways" (King, Queen, Knight, Bishop, Rook, Pawn) analyze each position. When several gateways independently arrive at similar evaluations, that agreement indicates the assessment is stable across the different feature weightings each gateway induces. It is a confidence signal, not a proof of optimality.

Blunder Prevention

Industry-standard Static Exchange Evaluation (SEE) integrated with dimensional analysis to catch hanging pieces and catastrophic moves before they happen.

Educational Interface

Clear visualization of dimensional scores, gateway patterns, and convergence indicators help players understand not just what move to make, but why it scores well across multiple evaluation perspectives.

Candidate Suggester (Session 2)

LLMs systematically miss pawn moves, defensive resources, and quiet positional moves when playing chess. They fixate on "obvious" piece moves while overlooking quiet pawn advances, pawn captures, and defensive interpositions. No amount of prompting fixes this because the bias operates below the reasoning layer.

The chess_suggest_candidates tool solves this by categorizing every legal move by tactical function before the LLM makes any recommendation:

Each move includes a Static Exchange Evaluation (SEE) safety assessment so the LLM sees material-loss warnings inline before recommending a move.

Master Dampener (Session 0.1)

Heuristic fortress draw detection. When structural signals (locked pawns, opposite-color bishops, insufficient material) combine with temporal stasis (evaluation unchanged over 4+ moves), the Master Dampener pulls evaluation toward 0.0 (draw). Formula: Consensus × (1 - FortressSignal)

Prerequisites

Required Software

• Python 3.10 - 3.13 - Python 3.14+ currently has compatibility issues

  • Download: https://www.python.org/downloads/

  • Windows users: During installation, check "Add Python to PATH"

• Claude Desktop with MCP support

  • Download: https://claude.ai/download

Optional (Recommended)

• Git for cloning repository

  • Download: https://git-scm.com/downloads

  • Alternative: Download ZIP file directly from GitHub (see Installation)

Verify Your Installation

# Check Python version (should show 3.10-3.13)
python --version

# Check pip is available
python -m pip --version

Installation

Quick Start (All Platforms)

1. Download ZDTP Chess

2. Install Python dependencies

3. Configure Claude Desktop

4. Restart Claude Desktop

Detailed platform-specific instructions below.

Installation on Windows

Step 1: Download ZDTP Chess

Option A: Using Git

git clone https://github.com/ChavezAILabs/zdtp-chess.git
cd zdtp-chess

Option B: Download ZIP (No Git Required)

1. Visit https://github.com/ChavezAILabs/zdtp-chess

2. Click the green "Code" button

3. Select "Download ZIP"

4. Extract to a permanent location (e.g., C:\Users\YourName\Documents\zdtp-chess)

5. Open PowerShell in the extracted folder:

   • Navigate to the folder in File Explorer

   • Hold Shift + Right-click in the folder

   • Select "Open PowerShell window here"

Step 2: Fix PowerShell Execution Policy (One-time Setup)

If you encounter "cannot be loaded because running scripts is disabled" errors:

# Run PowerShell as Administrator
# Right-click PowerShell in Start Menu -> "Run as Administrator"

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# Type 'Y' and press Enter when prompted

This is a one-time Windows security setting required for Python packages.

Step 3: Install Dependencies

# Important: Use 'python -m pip' on Windows (not just 'pip')
python -m pip install -r requirements.txt

You may see warnings about scripts not on PATH - these are non-critical and can be ignored.

Step 4: Configure Claude Desktop MCP Server

1. Open Claude Desktop

2. Navigate to Settings -> Developer -> Edit Config

   • This opens claude_desktop_config.json in your default text editor

3. Add the ZDTP Chess configuration:

{
  "mcpServers": {
    "zdtp-chess": {
      "command": "python",
      "args": ["-m", "zdtp_chess_mcp"],
      "cwd": "C:\\Users\\YourName\\Documents\\zdtp-chess",
      "env": {
        "PYTHONPATH": "C:\\Users\\YourName\\Documents\\zdtp-chess"
      }
    }
  }
}

Critical Configuration Notes:

• Replace C:\\Users\\YourName\\Documents\\zdtp-chess with your actual installation path

• Use double backslashes (\\) in Windows paths for JSON format

• Both cwd and PYTHONPATH must point to the same directory

• The args must be ["-m", "zdtp_chess_mcp"] NOT ["-m", "zdtp_chess_mcp.zdtp_chess_server"]

• If you have other MCP servers, add zdtp-chess inside the existing mcpServers object

4. Save the config file

5. Completely close and restart Claude Desktop

   • Quit the application entirely, don't just close the window

   • On Windows: Right-click system tray icon -> "Quit"

Step 5: Verify Installation

1. Open Claude Desktop

2. Go to Settings -> Developer

3. Check MCP Servers list:

   • zdtp-chess should show as "connected"

   • If it shows "failed", see Troubleshooting section below

Installation on macOS/Linux

# Clone repository
git clone https://github.com/ChavezAILabs/zdtp-chess.git
cd zdtp-chess

# Install dependencies
pip install -r requirements.txt

Configure Claude Desktop by editing:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Linux: ~/.config/Claude/claude_desktop_config.json

Add to configuration:

{
  "mcpServers": {
    "zdtp-chess": {
      "command": "python",
      "args": ["-m", "zdtp_chess_mcp"],
      "cwd": "/absolute/path/to/zdtp-chess",
      "env": {
        "PYTHONPATH": "/absolute/path/to/zdtp-chess"
      }
    }
  }
}

Replace /absolute/path/to/zdtp-chess with your actual installation path. Restart Claude Desktop completely.

Requirements

• python-chess>=1.999 - Chess move generation and board representation

• mcp>=0.9.0 - Model Context Protocol server

• hypercomplex>=0.3.4 - Hypercomplex number systems (Sedenions, Pathions, Chingons)

Troubleshooting

"ModuleNotFoundError: No module named 'zdtp_chess_mcp'"

Causes & Solutions:

1. Missing cwd or PYTHONPATH in config

   • Verify your config has BOTH cwd AND PYTHONPATH set to the installation directory

2. Incorrect path format (Windows)

   • Use double backslashes (\\) in JSON paths

   • Wrong: "C:\Users\YourName\Documents\zdtp-chess"

   • Correct: "C:\\Users\\YourName\\Documents\\zdtp-chess"

3. Claude Desktop not restarted

   • Completely quit and restart Claude Desktop (not just close window)

"Server disconnected" Error

1. Wrong Python version

   • Check: python --version (must be 3.10-3.13, NOT 3.14+)

   • Solution: Install Python 3.13 from https://www.python.org/downloads/

2. Dependencies not installed

   • Run: python -m pip install -r requirements.txt

3. Wrong command in config

   • Use: "args": ["-m", "zdtp_chess_mcp"]

   • NOT: "args": ["-m", "zdtp_chess_mcp.zdtp_chess_server"]

4. Python not in PATH

   • Use full Python path in config:

"command": "C:\\Users\\YourName\\AppData\\Local\\Programs\\Python\\Python313\\python.exe"

• Find your Python path: where.exe python (Windows) or which python (macOS/Linux)

Multiple Python Installations

If packages install but you still get ModuleNotFoundError:

# Windows - see all Python installations
where.exe python

# Check which Python pip uses
python -m pip --version

Use the full path to your Python 3.13 installation in the config:

"command": "C:\\Users\\YourName\\AppData\\Local\\Programs\\Python\\Python313\\python.exe"

PowerShell "running scripts is disabled"

# Open PowerShell as Administrator
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
# Type 'Y' and press Enter

Can't Find Config File

Easy method: Settings -> Developer -> Edit Config (works on all operating systems)

Manual paths:

• Windows: C:\Users\YourName\AppData\Roaming\Claude\claude_desktop_config.json

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Linux: ~/.config/Claude/claude_desktop_config.json

Note: On Windows, the AppData folder is hidden by default. Use Settings -> Developer -> Edit Config instead.

Python 3.14 Compatibility

If you see:

pip._vendor.pyproject_hooks._impl.BackendUnavailable: Cannot import 'setuptools.build_backend'

Python 3.14 has breaking changes in setuptools. Use Python 3.13 or earlier:

1. Download Python 3.13 from https://www.python.org/downloads/

2. Install with "Add to PATH" checked

3. Reinstall dependencies: python -m pip install -r requirements.txt

Getting Help

If you encounter issues not covered here:

1. Check the logs: Claude Desktop -> Settings -> Developer -> View logs

2. Verify installation:

python --version
python -m pip list | findstr "chess mcp hypercomplex"

3. Create a GitHub Issue: https://github.com/ChavezAILabs/zdtp-chess/issues

   • Include your OS, Python version, and error messages from Claude Desktop logs

The Math Section

"I was told there would be no math." - Anonymous Student

Sorry, but there's math. Here's the minimal math you need to understand how this works:

Zero Divisors

In normal arithmetic, if A × B = 0, then either A = 0 or B = 0 (or both). This is the zero-product property you learned in algebra.

In higher-dimensional algebras, however, this breaks down with amazing annihilation.

Starting in 16D sedenions and continuing upward to 32D pathions, and 64D chingons, you can find non-zero elements P and Q where:

P × Q = 0

even though P ≠ 0 and Q ≠ 0

These are called zero divisors, and mathematicians traditionally have dismissed them as "pathological", wrongly demeaning them as algebraic structures that make systems "unusable."

Why Zero Divisors Are Actually Useful

Key insight: Zero divisors can encode information about dimensional collapse and information loss in algebraic systems. ZDTP Chess uses this as a design motif for its three evaluation layers:

• Tactical collapse (16D) - Positions where forcing sequences eliminate options

• Positional transformation (32D) - How piece coordination changes across moves

• Strategic encoding (64D) - Long-term plan evaluation

How much the zero-divisor algebra itself contributes to move quality, as opposed to the chess features computed alongside it, has not yet been measured. See Open Questions.

Example: The Canonical Six

We discovered six fundamental zero divisor patterns that appear consistently across 16D/32D/64D spaces. (Reference: https://zenodo.org/records/17402495)

Each pattern provides a different "lens" for evaluating positions. When several gateways independently arrive at similar evaluations, that agreement indicates the assessment is stable across the different feature weightings each gateway induces. It is a confidence signal, not a proof of optimality.

That's the math. The rest is engineering.

How It Works

Zero Divisor Transmission Protocol (ZDTP)

ZDTP builds a 64-dimensional position representation in stages:

1. 16D encoding — the board is encoded into sixteen evaluation features (material balance, pawn structure, king safety, center control, mobility, development, piece activity, castling rights, complexity).

2. 32D expansion — the 16D vector occupies dims 0–15 unchanged. Dims 16–31 are populated with tactical features (hanging pieces, pins, forks, SEE), advanced positional features, gateway interaction terms, and higher-order features.

3. 64D expansion — the 32D vector occupies dims 0–31 unchanged. Dims 32–63 carry strategic features: multi-move sequences, planning, game-phase recognition, positional imbalances, draw detection, the Session 0.1 analytic features (dims 52–55), gateway harmony, and meta-cognitive terms.

4. Convergence detection — gateway outputs are compared; agreement across gateways is reported as an evaluation-stability signal. Disagreement indicates tactical complexity requiring deeper analysis.

Where the algebra enters. Gateway patterns are sedenion zero-divisor pairs drawn from the Canonical Six. Products with the gateway P (and its conjugate Q) reach the output in four places: dims 24–27 (P × 16D state, top four coefficients by magnitude), dim 52 (tactical_ceiling), dims 56–59 (gateway harmony, from the 32D state × P), and dim 63 (zugzwang coefficient, |P·x − x·P|). Every other dimension is computed from the board alone. Each gateway's conjugate Q satisfies P × Q ≈ 0, verified at portal construction.

Scope of the preservation claim. Lower-dimensional features are preserved because the smaller vector is a prefix of the larger one — preservation by construction, not a consequence of zero-divisor algebra. The zero-divisor verification confirms a property of the gateway constants; it does not vary with position. Whether the gateway-derived dimensions measurably improve move selection is an open question we have not yet tested (see Open Questions).

Game Flow

1. You play White against a computer opponent (Black)

2. After each move, ZDTP analyzes the position through an adaptive gateway

3. Dimensional scores show tactical (16D), positional (32D), and strategic (64D) evaluation

4. Positive scores = advantage for White (you)

5. Gateway convergence alerts you when multiple frameworks independently agree

MCP Tools

ZDTP Chess provides the following tools through the Model Context Protocol:

• chess_new_game - Start a new game

• chess_suggest_candidates - Categorize all legal moves by type (forcing/defensive/developing/quiet)

• chess_make_move - Execute a move (requires explicit user confirmation)

• chess_analyze_move - Preview move consequences without executing (what-if analysis)

• chess_get_board - Display current position and game state

• chess_get_dimensional_analysis - Detailed breakdown of current position

• chess_check_gateway_convergence - Check whether multiple gateways agree on the evaluation (a stability signal)

• chess_load_position - Load a position from FEN or the Stressor Library (Session 0.1)

• chess_list_stressors - List curated test positions for dimensional analysis stress testing

Recommended workflow: Call chess_suggest_candidates first to see the full tactical landscape, then use chess_analyze_move to deep-dive promising candidates, then execute with chess_make_move.

Example Analysis Output

╔══════════════════════════════════════════════════════════════╗
║  BLACK RESPONDS: Nf6                                         ║
╚══════════════════════════════════════════════════════════════╝

Analysis Gateway: Knight (discontinuous gateway - non-linear patterns)
Position Evaluation: +0.94 (White's perspective)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  MULTI-DIMENSIONAL POSITION ANALYSIS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🎯 16D TACTICAL LAYER (Immediate Threats & Material)
   Score: +0.87 (White's perspective)
   • Material balanced
   • White has better mobility (3 more legal moves)
   • No immediate threats detected

🏗️ 32D POSITIONAL LAYER (Structure & Coordination)
   Score: +2.91 (White's perspective)
   • Gateway Pattern: Discontinuous Gateway (Knight)
   • Strong center control for White
   • Well-coordinated piece development

🌟 64D STRATEGIC LAYER (Long-term Planning)
   Score: +1.23 (White's perspective)
   • White's central pawns provide middlegame flexibility
   • Favorable pawn structure approaching
   • Long-term endgame potential

CONSENSUS EVALUATION: +0.94 (slight advantage: WHITE)

💡 SUGGESTED MOVES: Nf3 (develop), c4 (Queen's Gambit), Bf4 (bishop out)

Example: Using the Candidate Suggester

After starting a game and reaching a complex middlegame position, ask Claude to survey your options:

You: "What are my best options here?"

Claude calls chess_suggest_candidates and responds with the full tactical landscape:

Claude:

Here's what I see across all 41 legal moves:

Forcing moves:

• dxc6 (pawn capture) - Safe trade, wins a pawn

• Qxa5 (piece capture) - WARNING: Your queen hangs after recapture (loses 5.8 material)

Defensive moves:

• h3 - Moves your pawn off the attacked h2 square

• e4 - Your pawn now defends the d5 pawn that's under pressure

Developing moves:

• e3 - Center pawn advance, strengthens your pawn chain

• Rec1 - Rook activates on the semi-open c-file

The quiet pawn capture dxc6 stands out - it's safe and wins material. Want me to run a deeper ZDTP analysis on it?

Without the Candidate Suggester, the LLM would likely recommend the flashy queen capture and miss the safe pawn win entirely.

Architecture

ZDTP Chess combines standard chess engine components with novel multi-dimensional analysis:

Standard Components

• Legal move generation (python-chess library)

• Material evaluation

• Blunder detection using Static Exchange Evaluation (SEE)

• Basic tactical analysis

These components ensure ZDTP Chess meets baseline requirements for chess programming and can be validated against traditional engines.

ZDTP Innovation

• 16D Layer - Sixteen board-derived evaluation features (material, pawn structure, king safety, center control, mobility, and more), stored as sedenion coefficients

• 32D Layer - The 16D features plus tactical, positional and higher-order features computed from the board, and four gateway interaction terms (dims 24–27)

• 64D Layer - The 32D features plus strategic features computed from the board, and six more gateway-derived terms (dims 52, 56–59, 63)

• Gateway Convergence - Cross-gateway agreement as an evaluation-stability signal

Ten of the 64 dimensions involve the zero-divisor algebra; the rest are computed from the board directly. See How It Works and Open Questions.

The ZDTP layers run after standard blunder detection, adding strategic insight beyond traditional evaluation functions.

Mathematical Foundation

ZDTP Chess is built on research into Cayley-Dickson algebras and zero divisor patterns:

Research Publication: Framework-Independent Zero Divisor Patterns in Higher-Dimensional Cayley-Dickson Algebras: Discovery and Verification of The Canonical Six - Zenodo DOI: 10.5281/zenodo.17402495

Analytic Grounding (Session 0.1)

Three v2.0 features were designed from analytic bounds explored in the Chavez Transform work (ChavezTransform_genuine.lean, Chavez AI Labs):

• tactical_ceiling (Dim 52) — a saturation ratio, motivated by the bounded form of the bilateral kernel K_Z.

• mobility_occlusion (Dim 54) — a decay function for piece influence by board density, using the power-law weight (1 + ‖x‖²)^(−d/2) ≤ 1.

• Master Dampener threshold — a practical stasis threshold of M = 0.5, tuned empirically.

What is and is not verified. ChavezTransform_genuine.lean proves a sharp stability bound, with stability constant 2(‖P‖² + ‖Q‖²)/(α·e), and a clean axiom footprint ([propext, Classical.choice, Quot.sound], no sorryAx). That result is about a one-dimensional scalar-channel restriction where sedenion multiplication degenerates to scalar multiplication — the zero-divisor structure is not exercised by it. The constant above belongs to that Chavez Transform result; it is not the Master Dampener threshold. The features above are therefore heuristics informed by that analysis, not consequences of verified theorems about the chess evaluation.

An earlier version of this README cited ChavezTransform_Specification_aristotle.lean. That file was superseded: its CD4_mul was defined as the zero function, making its theorems vacuous (see CAIL-rh-investigation CORRECTIONS.md C-016, and C-018 for the scope of its replacement). It should not be cited as grounding for anything. The copy in this repository's lean/ directory is kept for provenance only; see CORRECTIONS.md.

The Six Gateways

Each gateway represents a different zero divisor pattern from 16D sedenion algebra:

1. King Gateway - Master gateway, holistic evaluation

2. Queen Gateway - Multi-modal gateway, tactical complexity

3. Knight Gateway - Discontinuous gateway, non-linear patterns

4. Bishop Gateway - Diagonal gateway, long-range planning

5. Rook Gateway - Orthogonal gateway, file control

6. Pawn Gateway - Incremental gateway, structural analysis

When several gateways independently arrive at similar evaluations, that agreement indicates the assessment is stable across the different feature weightings each gateway induces. It is a confidence signal, not a proof of optimality.

Open Questions

Do the gateway-derived dimensions contribute signal? Sedenion multiplication by the gateway pattern reaches the 64D output only through dims 24–27, 52, 56–59 and 63 (see How It Works). That is 10 of 64 dimensions, and nothing yet establishes that they improve move selection. The experiment that would settle it is an ablation: 50 games in each of three arms —

1. unmodified,

2. the gateway-derived dimensions zeroed,

3. the gateway-derived dimensions computed from a random sedenion in place of the gateway pattern.

Dims 24–27 can also be ablated on their own, since they are the most direct path.

If the arms are indistinguishable, the gateway contribution is decorative and this README will say so. If the unmodified arm wins, stronger claims about the algebra become defensible and will be restated with the measurement cited. This ablation has not been run.

Applications

Chess (Current Proof of Concept)

• Multi-dimensional position evaluation across tactical/positional/strategic layers

• Evaluation-stability assessment through gateway convergence

• Real-time blunder detection with dimensional analysis

• Educational tool for understanding multi-perspective decision-making

AI Infrastructure (Platform Vision)

• Decision Intelligence - Multi-framework validation for complex AI decisions

• Quantitative Finance - Portfolio analysis through dimensional risk assessment (CAILculator in development)

• Strategic Planning - Business decisions analyzed across multiple independent frameworks

• AI Safety - Catching edge cases that single-model systems miss

For Developers & Researchers

• Multi-Framework Analysis - Reference architecture for combining independent mathematical approaches

• Applied Pathological Mathematics - Demonstration that "unusable" mathematical structures have practical value

• Gateway Convergence Research - Study convergence patterns across different algebraic systems

Roadmap

Phase 1: Chess (Complete - v1.0)

• ✅ Core dimensional analysis engine (16D/32D/64D)

• ✅ Six gateway patterns implemented

• ✅ ZDTP protocol for staged 16D → 32D → 64D feature expansion

• ✅ Gateway convergence detection

• ✅ Blunder detection with SEE integration

• ✅ MCP server with user confirmation safeguards

Session 0.1: Analytic Grounding (Complete - v2.0)

• ✅ Analytically Motivated Features - Features designed from analytic bounds — see Mathematical Foundation for scope.

  • Bilateral kernel bound → Dim 52 (tactical_ceiling)

  • Power-law dimensional weight → Dim 54 (mobility_occlusion)

  • Empirically tuned stasis threshold → Master Dampener

• ✅ Master Dampener - Fortress draw detection with formula: Consensus × (1 - FortressSignal)

• ✅ Zugzwang Coefficient - Non-commutativity measure |P·x - x·P| (Dim 63)

• ✅ Stressor Position Library - Curated test positions for dimensional analysis validation

• ✅ Temporal Confirmation - 4-eval history check for fortress stasis detection

Session 2: Candidate Suggester (Complete)

• ✅ Move Categorization Engine - Every legal move classified into forcing/defensive/developing/quiet

• ✅ SEE Safety Per Move - Inline material-loss warnings using battle-tested Static Exchange Evaluation

• ✅ Attacked Piece Detection - Identifies all friendly pieces under attack with attacker/defender counts

• ✅ Workflow Integration - System prompt updated to call chess_suggest_candidates before recommending moves

• ✅ 12-Test Validation Suite - Covers starting position, hanging pieces, checks, captures, promotions, castling, and JSON structure

Phase 2: Financial Infrastructure (In Development)

• CAILculator - Quantitative finance application via MCP server

• Portfolio risk assessment across dimensional frameworks

• Multi-asset correlation analysis through gateway patterns

• Gateway-convergence analysis for trading strategies

Phase 3: Platform Expansion

• Strategic business planning tools

• AI safety validation frameworks

• Natural language processing with dimensional embeddings

• Extended dimensional analysis (128D, 256D layers)

Chess Enhancements (Ongoing)

• Gateway selection strategy optimization

• Position-type adaptive gateway weighting

• Performance optimization (parallel gateway evaluation)

• PGN export with dimensional annotations

About Chavez AI Labs

Mission: "Better math, less suffering"

Chavez AI Labs applies pathological mathematics - mathematical structures traditionally dismissed as unusable - to create practical AI systems and decision-making tools.

Founder: Paul Chavez

• 30+ years journalism experience (Associated Press, LA Times)

• UCLA alumnus (Political Science, 1989)

• Published research with CERN DOI on zero divisor patterns

Products:

• CAILculator - MCP server for high-dimensional mathematical analysis

• ZDTP Chess - Proof of concept for applied pathological mathematics

• Additional applications in quantitative finance, data analysis, and AI infrastructure

Contributing

For collaboration inquiries, research partnerships, or commercial licensing:

• Contact: iknowpi@gmail.com

• Company: Chavez AI Labs (California-licensed AI company)

• Research: See published paper on framework-independent zero divisor patterns

License

Apache License 2.0 with patent protection.

Acknowledgments

• Python-chess library - Foundation for chess logic and board representation

• Anthropic MCP - Model Context Protocol implementation

• CERN - Digital Object Identifier (DOI) for research publication

• Chess community - Inspiration and education during development

Citation

If you use ZDTP Chess in academic research, please cite:

Chavez, P. (2025). ZDTP Chess: Multi-Dimensional Analysis Through Zero Divisor Patterns.
Chavez AI Labs. https://github.com/ChavezAILabs/zdtp-chess

Chavez AI Labs - Applied Pathological Mathematics