boolean-algebra-engine 0.1.0__py3-none-any.whl

api/routes.py

@@ -0,0 +1,386 @@
+"""
+api/routes.py — REST API wrapping the boolean algebra engine.
+
+Endpoints:
+  POST /evaluate           expression → truth table
+  POST /simplify           expression → minimal form
+  POST /equivalent         two expressions → same truth table?
+  POST /satisfiable        expression → any row outputs 1?
+  POST /check-rules        list of expressions → contradictions, conflicts
+  POST /nl/ask             plain English → verified boolean result
+  POST /nl/check-rules     list of plain English rules → analysis
+  GET  /health             liveness check
+
+Run:
+  uvicorn api.routes:app --host 0.0.0.0 --port 8080 --reload
+
+Environment variables:
+  ANTHROPIC_API_KEY   — for nl/* endpoints with anthropic provider
+  OPENAI_API_KEY      — for nl/* endpoints with openai provider
+  REDIS_URL           — optional, enables caching (default: redis://localhost:6379)
+  API_KEY             — optional, enables auth (Pro/Team tiers)
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from core.evaluator import evaluate as _evaluate
+from core.synthesizer import synthesize as _synthesize
+from core.parser import validate, infix_to_prefix
+from core.evaluator import _evaluate_prefix
+
+app = FastAPI(
+    title="Boolean Algebra Engine",
+    description="Deterministic boolean logic verification API.",
+    version="0.1.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ---------------------------------------------------------------------------
+# Redis cache — optional, degrades gracefully if not available
+# ---------------------------------------------------------------------------
+
+_redis = None
+
+def _get_redis():
+    global _redis
+    if _redis is not None:
+        return _redis
+    try:
+        import redis
+        r = redis.from_url(os.environ.get("REDIS_URL", "redis://localhost:6379"))
+        r.ping()
+        _redis = r
+    except Exception:
+        _redis = None
+    return _redis
+
+
+def _cache_get(key: str) -> dict | None:
+    r = _get_redis()
+    if not r:
+        return None
+    try:
+        val = r.get(key)
+        return json.loads(val) if val else None
+    except Exception:
+        return None
+
+
+def _cache_set(key: str, value: dict, ttl: int = 86400):
+    r = _get_redis()
+    if not r:
+        return
+    try:
+        r.setex(key, ttl, json.dumps(value))
+    except Exception:
+        pass
+
+
+def _cache_key(*parts) -> str:
+    raw = ":".join(str(p) for p in parts)
+    return "bae:" + hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+# ---------------------------------------------------------------------------
+# Auth — optional, enabled when API_KEY env var is set
+# ---------------------------------------------------------------------------
+
+def _check_auth(request: Request):
+    required = os.environ.get("API_KEY")
+    if not required:
+        return
+    provided = request.headers.get("X-API-Key")
+    if provided != required:
+        raise HTTPException(status_code=401, detail="Invalid or missing X-API-Key")
+
+
+# ---------------------------------------------------------------------------
+# Request / response models
+# ---------------------------------------------------------------------------
+
+class EvaluateRequest(BaseModel):
+    expression: str
+
+class SimplifyRequest(BaseModel):
+    expression: str
+
+class EquivalentRequest(BaseModel):
+    expression1: str
+    expression2: str
+
+class SatisfiableRequest(BaseModel):
+    expression: str
+
+class CheckRulesRequest(BaseModel):
+    rules: list[str]
+
+class NLAskRequest(BaseModel):
+    sentence: str
+    provider: str = "anthropic"
+    api_key: Optional[str] = None
+    model: Optional[str] = None
+    base_url: Optional[str] = None
+
+class NLCheckRulesRequest(BaseModel):
+    rules: list[str]
+    provider: str = "anthropic"
+    api_key: Optional[str] = None
+    model: Optional[str] = None
+    base_url: Optional[str] = None
+
+
+# ---------------------------------------------------------------------------
+# Helper — build provider from request fields
+# ---------------------------------------------------------------------------
+
+def _build_provider(provider: str, api_key: Optional[str], model: Optional[str], base_url: Optional[str]):
+    from nl.nl import AnthropicProvider, OpenAIProvider, OllamaProvider, OpenAICompatProvider
+    if provider == "anthropic":
+        return AnthropicProvider(api_key=api_key, model=model or "claude-sonnet-4-6")
+    if provider == "openai":
+        return OpenAIProvider(api_key=api_key, model=model or "gpt-4o")
+    if provider == "ollama":
+        return OllamaProvider(model=model or "llama3", base_url=base_url or "http://localhost:11434")
+    if provider == "compat":
+        if not base_url or not model:
+            raise HTTPException(status_code=400, detail="base_url and model required for compat provider")
+        return OpenAICompatProvider(api_key=api_key or "", base_url=base_url, model=model)
+    raise HTTPException(status_code=400, detail=f"Unknown provider '{provider}'. Choose: anthropic, openai, ollama, compat")
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+@app.get("/health")
+def health():
+    redis_ok = _get_redis() is not None
+    return {"status": "ok", "version": "0.1.0", "redis": redis_ok}
+
+
+@app.post("/evaluate")
+def evaluate(req: EvaluateRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("evaluate", req.expression)
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    error = validate(req.expression)
+    if error:
+        raise HTTPException(status_code=422, detail={"error": "invalid_expression", "message": error, "expression": req.expression})
+
+    t0 = time.perf_counter()
+    table, metrics = _evaluate(req.expression)
+    elapsed = round((time.perf_counter() - t0) * 1000, 4)
+
+    result = {
+        "expression": table.expression,
+        "variables": table.variables,
+        "rows": [{**row.inputs, "output": row.output} for row in table.rows],
+        "satisfiable": table.satisfiable,
+        "tautology": table.tautology,
+        "minterms": table.minterms,
+        "maxterms": table.maxterms,
+        "eval_time_ms": elapsed,
+        "rows_evaluated": metrics.rows_evaluated,
+    }
+
+    _cache_set(cache_key, result, ttl=86400)
+    response.headers["X-Cache"] = "MISS"
+    response.headers["X-Eval-Time-Ms"] = str(elapsed)
+    return result
+
+
+@app.post("/simplify")
+def simplify(req: SimplifyRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("simplify", req.expression)
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    error = validate(req.expression)
+    if error:
+        raise HTTPException(status_code=422, detail={"error": "invalid_expression", "message": error, "expression": req.expression})
+
+    table, _ = _evaluate(req.expression)
+    minimal, metrics = _synthesize(table)
+
+    result = {
+        "original": req.expression,
+        "minimal": minimal,
+        "changed": minimal != req.expression,
+        "prime_implicant_count": metrics.prime_implicant_count,
+        "synth_time_ms": metrics.synth_time_ms,
+    }
+
+    _cache_set(cache_key, result, ttl=86400)
+    response.headers["X-Cache"] = "MISS"
+    return result
+
+
+@app.post("/equivalent")
+def equivalent(req: EquivalentRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("equivalent", req.expression1, req.expression2)
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    for expr in [req.expression1, req.expression2]:
+        error = validate(expr)
+        if error:
+            raise HTTPException(status_code=422, detail={"error": "invalid_expression", "message": error, "expression": expr})
+
+    from core.parser import get_variables
+    vars1 = set(get_variables(req.expression1))
+    vars2 = set(get_variables(req.expression2))
+    all_vars = sorted(vars1 | vars2)
+    n = len(all_vars)
+
+    p1 = infix_to_prefix(req.expression1)
+    p2 = infix_to_prefix(req.expression2)
+
+    differing = []
+    for i in range(2 ** n):
+        values = {var: (i >> (n - 1 - j)) & 1 for j, var in enumerate(all_vars)}
+        v1 = {k: v for k, v in values.items() if k in vars1}
+        v2 = {k: v for k, v in values.items() if k in vars2}
+        out1 = _evaluate_prefix(p1, v1)
+        out2 = _evaluate_prefix(p2, v2)
+        if out1 != out2:
+            differing.append({**values, req.expression1: out1, req.expression2: out2})
+
+    result: dict = {
+        "equivalent": len(differing) == 0,
+        "expression1": req.expression1,
+        "expression2": req.expression2,
+    }
+    if differing:
+        result["differing_rows"] = differing[:10]
+        result["total_differing"] = len(differing)
+
+    _cache_set(cache_key, result, ttl=86400)
+    response.headers["X-Cache"] = "MISS"
+    return result
+
+
+@app.post("/satisfiable")
+def satisfiable(req: SatisfiableRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("satisfiable", req.expression)
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    error = validate(req.expression)
+    if error:
+        raise HTTPException(status_code=422, detail={"error": "invalid_expression", "message": error, "expression": req.expression})
+
+    table, _ = _evaluate(req.expression)
+    result: dict = {"satisfiable": table.satisfiable, "expression": req.expression}
+    if table.satisfiable:
+        first = table.rows[table.minterms[0]]
+        result["example"] = {**first.inputs, "output": first.output}
+
+    _cache_set(cache_key, result, ttl=86400)
+    response.headers["X-Cache"] = "MISS"
+    return result
+
+
+@app.post("/check-rules")
+def check_rules(req: CheckRulesRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("check-rules", *sorted(req.rules))
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    from mcp_server.server import check_prompt_logic
+    result = check_prompt_logic(req.rules)
+
+    _cache_set(cache_key, result, ttl=3600)
+    response.headers["X-Cache"] = "MISS"
+    return result
+
+
+@app.post("/nl/ask")
+def nl_ask(req: NLAskRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    cache_key = _cache_key("nl-ask", req.sentence, req.provider, req.model or "")
+    cached = _cache_get(cache_key)
+    if cached:
+        response.headers["X-Cache"] = "HIT"
+        return cached
+
+    try:
+        from nl.nl import ask
+        prov = _build_provider(req.provider, req.api_key, req.model, req.base_url)
+        result = ask(req.sentence, provider=prov)
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail={"error": "parse_failed", "message": str(e)})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail={"error": "internal", "message": str(e)})
+
+    data = {
+        "input": result.input_sentence,
+        "expression": result.expression,
+        "variables": result.variables,
+        "minimal": result.minimal,
+        "satisfiable": result.satisfiable,
+        "tautology": result.tautology,
+        "contradiction": result.contradiction,
+        "minterms": result.minterms,
+        "maxterms": result.maxterms,
+        "explanation": result.explanation,
+        "rows": result.rows,
+    }
+
+    _cache_set(cache_key, data, ttl=3600)
+    response.headers["X-Cache"] = "MISS"
+    return data
+
+
+@app.post("/nl/check-rules")
+def nl_check_rules(req: NLCheckRulesRequest, request: Request, response: Response):
+    _check_auth(request)
+
+    try:
+        from nl.nl import check_rules as _check_rules
+        prov = _build_provider(req.provider, req.api_key, req.model, req.base_url)
+        result = _check_rules(req.rules, provider=prov)
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail={"error": "parse_failed", "message": str(e)})
+    except Exception as e:
+        raise HTTPException(status_code=500, detail={"error": "internal", "message": str(e)})
+
+    response.headers["X-Cache"] = "MISS"
+    return result

boolean_algebra_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: boolean-algebra-engine
+Version: 0.1.0
+Summary: Boolean algebra engine — evaluate expressions, generate truth tables, synthesize minimal forms
+Author-email: Aditya Shrivastava <adityars.work@gmail.com>
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/Shrivastava-Aditya/boolean-algebra-engine-python
+Project-URL: Repository, https://github.com/Shrivastava-Aditya/boolean-algebra-engine-python
+Project-URL: Issues, https://github.com/Shrivastava-Aditya/boolean-algebra-engine-python/issues
+Keywords: boolean,algebra,logic,truth-table,quine-mccluskey,digital-logic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: cli
+Requires-Dist: typer>=0.12.0; extra == "cli"
+Requires-Dist: rich>=13.0.0; extra == "cli"
+Provides-Extra: mcp
+Requires-Dist: mcp[cli]>=1.0.0; extra == "mcp"
+Provides-Extra: nl-anthropic
+Requires-Dist: anthropic>=0.50.0; extra == "nl-anthropic"
+Provides-Extra: nl-openai
+Requires-Dist: openai>=1.0.0; extra == "nl-openai"
+Provides-Extra: nl
+Requires-Dist: anthropic>=0.50.0; extra == "nl"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100.0; extra == "api"
+Requires-Dist: uvicorn>=0.20.0; extra == "api"
+Provides-Extra: api-cache
+Requires-Dist: fastapi>=0.100.0; extra == "api-cache"
+Requires-Dist: uvicorn>=0.20.0; extra == "api-cache"
+Requires-Dist: redis>=5.0.0; extra == "api-cache"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+Dynamic: license-file
+
+# boolean-algebra-engine-python
+
+A deterministic boolean algebra engine — evaluates expressions, generates truth tables, synthesises minimal forms, and verifies logical consistency.
+
+Forked from [boolean-algebra-java](https://github.com/Shrivastava-Aditya/boolean-algebra-java) — original Java implementation written during placement season.
+
+---
+
+## What it does
+
+**Forward:** expression → full truth table, exhaustive 2^n evaluation, exact.
+
+**Inverse:** truth table → minimal boolean expression via Quine-McCluskey.
+
+**Verification:** satisfiability, contradiction, tautology, equivalence, pairwise conflict detection across rule sets.
+
+---
+
+## Operators
+
+| Symbol | Operation | Precedence |
+|--------|-----------|------------|
+| `!` | NOT | 4 (highest) |
+| `.` | AND | 3 |
+| `^` | XOR | 2 |
+| `+` | OR | 1 (lowest) |
+
+Variables: uppercase `A`–`Z`. Parentheses override precedence.
+
+---
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────┐
+│                   Interface Layer                     │
+│   CLI/REPL    MCP Server    REST API    Streamlit UI  │
+└───────────────────────┬──────────────────────────────┘
+                        │
+┌───────────────────────┴──────────────────────────────┐
+│                     NL Layer                          │
+│   plain English → expression → plain English          │
+│   Anthropic · OpenAI · Ollama · OpenAI-compat         │
+└───────────────────────┬──────────────────────────────┘
+                        │
+┌───────────────────────┴──────────────────────────────┐
+│                   Core Engine                         │
+│   parser (shunting-yard) → evaluator (prefix stack)   │
+│                         → synthesizer (Quine-McCluskey)│
+└───────────────────────┬──────────────────────────────┘
+                        │
+┌───────────────────────┴──────────────────────────────┐
+│             Acceleration Layer (planned)               │
+│         numpy · CUDA · Redis                          │
+└──────────────────────────────────────────────────────┘
+```
+
+`core/` has zero external dependencies. Every layer above is a thin wrapper. Independently deployable, independently testable.
+
+---
+
+## Project structure
+
+```
+core/
+  models.py        TruthTable, TruthTableRow, PerformanceMetrics
+  parser.py        Shunting-yard — infix → prefix, validation, variable extraction
+  evaluator.py     Prefix stack evaluator — exhaustive 2^n row enumeration
+  synthesizer.py   Quine-McCluskey — truth table → minimal SOP expression
+
+mcp_server/
+  server.py        5 tools for agent integration (evaluate, simplify,
+                   equivalent, satisfiable, check_prompt_logic)
+
+api/
+  routes.py        FastAPI — 7 endpoints, Redis cache, optional auth
+
+nl/
+  nl.py            Provider abstraction — Anthropic, OpenAI, Ollama, OpenAI-compat
+
+cli/
+  main.py          typer + rich — REPL and one-shot, all output formats
+
+ui/
+  app.py           Streamlit — Expression, Rule Auditor, Plain English modes
+
+tests/             90 tests — unit, integration, edge cases, round-trips
+
+benchmark.py       LLM hallucination benchmark — engine as oracle
+visualisations.ipynb  Colab notebook — complexity vs variables, conflict graph
+```
+
+---
+
+## Quickstart
+
+```bash
+git clone https://github.com/Shrivastava-Aditya/boolean-algebra-engine-python
+cd boolean-algebra-engine-python
+pip install -e ".[dev]"
+python3 -m pytest tests/
+```
+
+---
+
+## Core usage
+
+```python
+from core.evaluator import evaluate
+from core.synthesizer import synthesize
+
+table, _ = evaluate("A.(B+C)")
+print(table.variables)    # ['A', 'B', 'C']
+print(table.minterms)     # [5, 6, 7]
+print(table.satisfiable)  # True
+
+minimal, _ = synthesize(table)
+print(minimal)            # A.C+A.B
+```
+
+---
+
+## check_prompt_logic
+
+```python
+from mcp_server.server import check_prompt_logic
+
+result = check_prompt_logic([
+    "A.B",   # approve: good credit AND income verified
+    "C",     # approve: collateral exists
+    "!A",    # reject:  bad credit
+    "!B.!C", # reject:  no income AND no collateral
+])
+print(result["summary"])
+# {'total': 4, 'contradictions': 0, 'conflicting_pairs': 3}
+```
+
+---
+
+## Benchmark
+
+Measures LLM hallucination rate on boolean logic. Engine is the oracle — ground truth by exhaustive enumeration, no human labelers.
+
+```bash
+ollama pull tinyllama
+python3 benchmark.py
+```
+
+First result: tinyllama (1B) · 3 variables · 10 cases · **40% hallucination rate**.
+
+See `FAILURES.md` for real-world severity analysis of each failure.
+
+---
+
+## Branches
+
+| Branch | What |
+|---|---|
+| `master` | Project — engine, interfaces, tests |
+| `product-readme` | Product brief — what it proves, what it's for |
+| `benchmark` | Benchmark methodology, multi-model results (in progress) |
+
+---
+
+## Related
+
+- [boolean-algebra-java](https://github.com/Shrivastava-Aditya/boolean-algebra-java) — original Java version

boolean_algebra_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api/routes.py,sha256=MUtb2if-jYhXOT2C5GD5mC6EgACawNTANtCPS57UnYc,12646
+boolean_algebra_engine-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=yU6Syy61qvtFgVGQADOUhjPFqjRO-D3IRqJE9n4berM,16055
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/evaluator.py,sha256=BqLvyb2JkF7WPmwPZYP1bzqbzLr7G8QJAAxELAypfNU,2655
+core/models.py,sha256=FTepIO8GFxzyRNScprYqUOzuYd10Ta1iTcdHjwMywTo,3255
+core/parser.py,sha256=cDJdlUhTliSZZw6VxlgKe7O_D9YEACsWGXfRviIGp-s,2364
+core/synthesizer.py,sha256=o044C3G9Az1ZCgLFaU-0g68CJvNtZMWW-cBRF-Ye6Ok,5648
+mcp_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_server/server.py,sha256=-3tyFeAndsCwNY-0pNnhA4xm_DBcAoIQPBBwwx5tNF4,8417
+nl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nl/nl.py,sha256=YdJo4rMMbTFPFNgyIXDNMn0zLICzt0av1bkx8NiilTU,14742
+boolean_algebra_engine-0.1.0.dist-info/METADATA,sha256=Anwq8pP8wjvFHQ11riofLqaEeSBIyZBuV01VauXsbZU,7890
+boolean_algebra_engine-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+boolean_algebra_engine-0.1.0.dist-info/entry_points.txt,sha256=-iwEp4864Mi7hNnYR1L1p5NxXEhSqJNn3X2mt_92nlk,42
+boolean_algebra_engine-0.1.0.dist-info/top_level.txt,sha256=CDi0ytQMStd1Hy9rROqsiRPzWUS3mN5P8-Jr7ztlVFI,27
+boolean_algebra_engine-0.1.0.dist-info/RECORD,,

boolean_algebra_engine-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

boolean_algebra_engine-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+boolcalc = cli.main:app