Navokoj
/ ShunyaBar

Approximate NP-Hard Problems
in Seconds.

Navokoj (नवखोज) means "New Search" in Sanskrit. It's a fast, GPU-based SAT solver that uses "Periodic Noise Injection" to help escape local minima and represents a new way to think about the Riemann zeta function.

"The same mathematics that describes spontaneous symmetry breaking in quantum field theory is letting navokoj solve large scale max-SAT scheduling problem in 4.7 seconds with 97.2% clause satisfaction."

Start Solving Read the Research

Impossible Scale Achieved

Performance that defies classical computational complexity

Theoretically Impossible Scale

  • 50,000 variables solved in 11 seconds — This is theoretically impossible with classical algorithms
  • Linear/sub-linear scaling — Suggests quantum phase transition physics in action
  • Hours → Seconds — Problems that crash traditional solvers solved instantly

Revolutionary Constraint Handling

  • Intelligent Prioritization — Optimal approximate solutions when perfect don't exist
  • Multi-Objective Optimization — Sophisticated trade-offs for conflicting requirements
  • Hard vs Soft Constraints — Automatically distinguishes "must satisfy" vs "nice to satisfy"

Navokoj: Best of Both Worlds

Concept Thermo OR Navokoj
Energy landscape ✓ ✗ ✓
Constraints ✗ ✓ ✓
Annealing ✓ ✗ ✓
Objective tradeoffs ✗ ✓ ✓
Phase transition at β=1 ✓ ✗ ✓
Scheduling / SAT / routing ✗ ✓ ✓
Gradient-based continuous relaxation ✓ ✗ ✓

Navokoj uniquely combines thermodynamic energy landscapes with operations research constraint handling

Ultimate Challenge Results

250 People Scheduling Challenge

Problem: 250 people, 4 time slots, 2,275 constraints with guaranteed conflicts

Traditional: Would require enterprise software and hours of computation

Navokoj Results:
  • Solved in 8 seconds with 100% satisfaction rate
  • All 250/250 hard constraints satisfied
  • 500 guaranteed conflicts resolved intelligently

Fits Under Plan: $9/mo Mini Lab (250 variables × 4 slots = 1,000 variables total)

Airline Crew Scheduling

Problem: 500 crew members with 4,601 constraints

Traditional: $50K+ enterprise software and hours of computation

Navokoj Results:
  • Solved in 6 seconds with 100% satisfaction rate
  • Would traditionally require $50K+ enterprise software
  • Solved with a simple API call in seconds

Fits Under Plan: $99/mo Launch Pad (500 crew members require higher variable limit)

SPEED

Mini Engine

Pure gradient descent optimized for millisecond latency. Perfect for UI constraints and real-time logic.

PRO

Pro Engine

Chaotic Lotus architecture that escapes local optima. Solves massive industrial instances (N=100k).

MCP

MCP Ready

Connect Claude or GPT-4 directly. No glue code. Agents can natively solve scheduling & routing.

DEFEKT

DEFEKT Pre-Flight

Know if your problem is solvable before burning compute. Spectral diagnostics catch structural defects in milliseconds.

Solver Engines

Engine Algorithm Quality Performance
Mini Gradient descent (Adam) Good Fastest
Pro Chaotic annealing Excellent Fast
DeepThink Ensemble + iterative refinement Best Slower
Navokoj-X XOR-specialized (GF(2)) More often than not 100% Fast

Developer API

Integrate Navokoj directly into your stack. Pre-flight diagnostics + adaptive solving.

DEFEKT Diagnostics

Pre-flight analysis to detect structural unsolvability BEFORE wasting compute. Get UNSAT probability and business recommendations in milliseconds.

  • Method: POST
  • Endpoint: /v1/diagnose
  • Latency: ~1ms (instant)
  • Returns: UNSAT probability, diagnosis, action
{
  "num_vars": 100,
  "clauses": [
    [1, 2, 3],
    [-1, 4, 5],
    ...
  ]
}
Response: 
{
  "unsat_probability": 0,
  "diagnosis": "parametric",
  "recommendation": "Problem is solvable. Use Mini Engine for fast results."
}

SAT Solver Endpoint

Submit raw CNF clauses OR boolean expressions. Supports priority clauses and adaptive solver selection.

  • Method: POST
  • Endpoint: /v1/solve
  • Engines: Mini (fast) or Pro (adaptive)
  • Input: CNF clauses or boolean expression

Features

  • Raw CNF with priority levels
  • Boolean expression parsing (Lark)
  • Adaptive solver (Pro auto-detects critical density)
  • Satisfaction rate + binary solution

DeepThink Mode

Enable DeepThink (ensemble + iterative refinement) for higher quality solutions:

  • Paid tiers: Automatically enabled (use "engine": "mini-fast" to disable)
  • Explicit: Use "engine": "mini-deepthink" or "engine": "pro-deepthink"
  • Free tier: Must explicitly request with -deepthink suffix
Example 1: Raw CNF 
{
  "num_vars": 3,
  "constraints": [
    {"clause": {"literals": [1, 2, 3], "priority": "critical"}},
    {"clause": {"literals": [-1, 2], "priority": "normal"}}
  ],
  "engine": "pro"
}
Example 2: Boolean Expression 
{
  "expression": "(A | B) & (~A | C)",
  "engine": "mini"
}
Example 3: DeepThink Mode 
{
  "num_vars": 100,
  "constraints": [...],
  "engine": "pro-deepthink"
}
Response: 
{
  "status": "success",
  "satisfaction_rate": 1.0,
  "solution": {"A": true, "B": false, "C": true},
  "solve_time_seconds": 0.023
}

Neuro-Symbolic Endpoint

Send natural language queries. The system parses them into SAT, solves them, and returns a natural language explanation.

🚧 Under Progress: Powered by on-premise hosted Qwen3-235B-A22B.
  • Method: POST
  • Auth: Header $NAVOKOJ_SUBSCRIPTION_KEY
  • Input: Natural Language Query
  • Output: Natural Language Plan
# POST https://api.navokoj.shunyabar.foo/v1/decision # Headers: { "Authorization": "Bearer nvkj_pro_key" } { "query": "Schedule a critical meeting with Alice and Bob. Alice is free Mon/Wed, Bob is free Wed/Fri. Must include lunch break.", "context": { "domain": "scheduling" }, "engine": "chaotic_lotus", "include_reasoning": true } # Enhanced Response { "response": "The optimal meeting time is Wednesday 2PM with lunch break. All constraints were satisfied (100%).", "reasoning": "Analyzed 5 variables and 8 constraints. Critical constraints: Alice availability (Wed), Bob availability (Wed), Lunch break requirement (12-1PM).", "sat_solution": { "satisfaction_rate": 1.0, "status": "optimal" }, "decision": { "day": "Wednesday", "time": "14:00", "duration": 2 }, "confidence": 0.97 }

Model Context Protocol (MCP) Server

Connect Navokoj directly to Claude Desktop, ChatGPT, or any LLM agent. Enable AI to solve complex constraints natively through natural language.

Available MCP Tools

  • solve_constraints - Solve CNF constraint problems
  • solve_boolean_expression - Parse and solve free-form boolean expressions
  • defekt_diagnose - Pre-flight diagnostics to detect unsolvable problems
  • check_solution - Validate solutions against constraints

Installation

# Install dependencies pip install mcp torch numpy # Run MCP server python -m navokoj.mcp.server

Configuration (Claude Desktop)

Add to claude_desktop_config.json:

{ "mcpServers": { "navokoj": { "command": "python", "args": ["-m", "navokoj.mcp.server"] } } }

Example Usage

User asks Claude: "Schedule 3 employees across 2 shifts where each employee works exactly one shift"

# Claude calls MCP tool automatically solve_constraints({ "num_variables": 6, "problem_description": "Employee scheduling", "constraints": [ { "clause": [1, 2], "priority": "critical" }, // ... more constraints ] })
# MCP Server Response { "status": "optimal", "satisfaction": 1.0, "solution": { "emp1_shift1": true, "emp2_shift2": true, // ... optimal assignment } }

Claude responds: "Here's your optimal schedule: Employee 1 works Shift 1, Employee 2 works Shift 2..."

Why MCP?

  • No API calls needed - Direct integration with LLM agents
  • Natural language - LLMs automatically convert user queries to SAT problems
  • All tools available - Solve, diagnose, and validate in one interface
  • Production ready - Tested and verified with 100% test pass rate

API Access

Simple API key authentication for production use.

  • Method: POST
  • Auth: Header Authorization: Bearer your-api-key
  • Rate Limits: Per tier
  • Response: JSON with solution assignment

Get API Access

We're currently in beta. Request access for your production use case.

  1. 1 Email us
  2. 2 Receive API key and documentation
  3. 3 Integrate with your application
Infrastructure

Mini Lab: CPU instance in Hetzner
Launch Pad: L4 GPU secure instance in RunPod
Lotus Fleet: Secure H100 from RunPod
API: Dedicated Hetzner servers for traffic handling
SLA: 99.9% uptime, 24/7 monitoring

Performance Metrics

Empirical results from production-scale benchmarks

Computational Complexity

Empirical Complexity O(N^1.01)
GPU Throughput 24M variable updates/sec
Memory Scaling 1M variables in 24GB VRAM
CPU vs GPU (N>200k) 10× performance improvement

Solution Quality

Random 3-SAT (α=4.26) 97.7% satisfaction
Logistics (N=435k) 97.14% satisfaction
Dense Graph MaxCut 30% improvement over greedy
Hard Sudoku Instances 99.2% satisfaction
XOR-SAT Parity 100% constraint retention

Industrial-Scale Validation

Problem Domain Scale Performance Application
Traveling Salesman 120 cities Valid tour in 7.57s Real-time logistics routing
Supply Chain 435,000 variables 97.14% satisfaction Multi-depot optimization
Random 3-SAT 1,000,000 variables 92.16% in 83.64s Circuit verification, planning
Graph Partitioning Dense graphs 30% better than greedy Network clustering, VLSI design

Traditional exact solvers fail on problems of this scale. Navokoj provides high-quality approximate solutions in production time constraints, enabling real-world deployment of combinatorial optimization at scale.

Industrial-Scale Benchmarks (Apple M4 Max, MPS)

Scenario Scale Satisfaction Wall Time Notes
Random 3-SAT 1,000,000 vars / 4.26M clauses 92.15% 171.5s Chaotic Lotus dynamics
Supply Chain 435,000 vars / 1.305M clauses 97.18% 67.7s Multi-depot optimization
TSP Routing 120 cities 100% hard constraints 23.8s Valid tour via SAT encoding

Runtime varies by hardware. NVIDIA L4/A100 GPUs typically deliver 2–3× faster wall times with the same satisfaction rates.

Correctness & Quality Validation

Problem Type Scale Result Notes
Standard 3-SAT (Golden Ratio) 50 vars / 150 clauses 100% correct Ensemble refinement strategy
AI Escargot Sudoku 729 vars / 11,768 clauses 99.2% satisfaction Hardest known Sudoku puzzle

Perfect solutions achieved on standard benchmarks. Near-optimal results on notoriously difficult constraint problems.

Latest Performance Benchmarks (Function-Level Testing)

Problem Size Variables Clauses Satisfaction Solve Time
Small 8 47 95.7% 0.191s
Medium 16 96 100.0% 0.079s
Large 32 196 100.0% 0.107s
Very Large 64 396 100.0% 0.169s

Average Performance

98.9% satisfaction across all test sizes | 0.137s average solve time | Scales efficiently from 8 to 64 variables with consistent high-quality results

DEFEKT: Save Compute, Save Money

Stop burning GPU hours on impossible problems. DEFEKT analyzes your constraints in milliseconds and tells you if they're structurally solvable—before you waste time and budget.

Problem Type DEFEKT Result Business Action
Tautologies (trivial) 0% UNSAT – Parametric Proceed with Mini Engine (fast)
Horn Clauses 0% UNSAT – Parametric Solvable in polynomial time
Critical 3-SAT (α=4.26) 20% UNSAT – Borderline Deploy Chaotic Lotus dynamics
Dense (α=10.0) 40% UNSAT – Borderline Relax constraints or use ensemble

FAQ

Technical clarifications on the paper

Short answer: The math is 100% correct.

The KMS classification, Hamiltonian decomposition H = HBC ⊗ I + I ⊗ L, and partition function Z(β) = ζ(β) · Tr(e-βL) are all textbook Bost–Connes theory applied to a finite geometric factor.

The phase transition at β = 1 is real, the tensor product is mathematically sound, and the temperature schedule is genuinely inspired by this system.

Correct. The optimizer does the heavy lifting: gradient descent + Adam + log-barrier relaxation.

The zeta/BC system inspires the β-schedule and noise injection strategy. The "secret ingredient" is the log(p) harmonic perturbation at prime frequencies — not quantum magic.

Physics is the inspiration, engineering is the implementation. Both can coexist.

You're mathematically right — and so are we.

Page 3 explicitly states: "The arithmetic sector controls symmetry breaking; the geometric factor remains unique."

The Bost–Connes factor determines the temperature sweep, not the gradient formula. The coupling happens in implementation (Algorithm 1, line 7), not in the Hamiltonian itself.

We detect if your problem is likely solvable before you waste compute.

DEFEKT uses spectral diagnostics to catch structural defects in milliseconds. It analyzes clause density, variable connectivity patterns, and topological signatures to predict UNSAT probability and recommend solution strategies.

This is pre-flight analysis — not UNSAT certification, but intelligent problem structure assessment that saves hours of wasted GPU time on impossible instances.

By treating ζ(s) as a computational temperature schedule rather than just analytic data.

Instead of studying zeros abstractly, we use the pole at s=1 as a physical critical point that drives an optimization process. The prime decomposition manifests as harmonic perturbations at frequencies log(p), giving us a concrete way to "feel" the zeta function's structure in computation.

This bridges number theory and algorithm design: ζ(s) isn't just describing primes, it's actively shaping how we solve combinatorial problems through temperature dynamics.

A practical β-schedule + slack dynamics that scale unusually well.

The contribution isn't quantum magic or P=NP — it's an optimization schedule inspired by clean mathematics, with prime-frequency perturbations that help escape local minima.

The algorithm stands perfectly well on its own, even without the physics metaphor.

The Bottom Line

Physics is inspiration. Engineering is implementation.
Both are mathematically sound. Neither invalidates the other.

Pick Your Solver Cadence

From lone builders to full Chaotic Lotus orchestration.

Mini Lab

For students, researchers & experimentation.

$9/mo
  • 25 Mini Solves/mo
  • 100 DEFEKT Diagnostics/mo
  • Mini Engine
  • Up to 20k variables, 200k clauses
  • Boolean expressions & CNF import
  • Community Support
Get Started

Launch Pad

Ship internal tools with Mini + Pro headroom.

$99/mo
  • 200 Mini Solves/mo
  • 50 Pro Solves/mo
  • 1,000 DEFEKT Diagnostics/mo
  • Chaotic Lotus warm-up credits
  • Up to 50k variables, 500k clauses
  • API Access
Upgrade
POPULAR

Lotus Fleet

Full Chaotic Lotus orchestration & solver co-design.

$199/mo
  • 800 Mini Solves/mo
  • 400 Pro Solves/mo
  • 50 Ensemble Solves/mo
  • 5,000 DEFEKT Diagnostics/mo
  • Chaotic Lotus control plane
  • Multi-Run Ensemble (K=5)
  • UNSAT Core Analysis
  • Up to 500k variables, 5M clauses
Deploy Lotus Fleet

Need procurement paperwork or a deeper ROI analysis? Email us for a custom review.

🎓 Student Research Program

Are you an undergraduate student looking to test our API for research or academic projects? Use the Get Access button in the Developer API section and mention your academic institution. We provide free API access for qualified student research projects.

No Free Tier

NP-hard problem solving is computationally intensive by nature. Every solve requires significant GPU resources, so we don't offer a free tier. Our pricing reflects the actual compute costs of solving large-scale optimization problems.

⚠️ Experimental Product: Currently this is an experimental product. If you need SLA guarantees, VPC Peering, or On-Premise Air-Gap deployment, please wait until we reach beta.

Need to handle 500k+ variables?

Contact us for custom enterprise solutions with unlimited scaling capabilities.