thirdanswer 0.1.0__py3-none-any.whl

thirdanswer/__init__.py

@@ -0,0 +1,40 @@
+"""
+thirdanswer — The Third Answer framework for evaluating AI uncertainty.
+
+Why AI doesn't know what it doesn't know — and how to find out.
+
+Basic usage (no LLM needed):
+    from thirdanswer import Compass
+    c = Compass(T=0.7, I=0.4, F=0.5)
+    print(c.zone)  # "contradiction"
+
+With LLM (Groq, free):
+    from thirdanswer import analyze
+    r = analyze("AI text here", provider="groq", api_key="gsk_...")
+    print(r.zone, r.T, r.I, r.F)
+
+Book: "The Third Answer" by Leyva-Vazquez & Smarandache (2026)
+"""
+
+__version__ = "0.1.0"
+__author__ = "Maikel Yelandi Leyva-Vazquez"
+
+from .compass import Compass
+from .analyzer import analyze, decompose, AnalysisResult, Claim
+from .honest import ask, HonestResponse
+from .compare import compare, ComparisonResult
+from .errors import AIError, ERROR_TYPES
+
+__all__ = [
+    "Compass",
+    "analyze",
+    "decompose",
+    "ask",
+    "compare",
+    "AnalysisResult",
+    "HonestResponse",
+    "ComparisonResult",
+    "Claim",
+    "AIError",
+    "ERROR_TYPES",
+]

thirdanswer/analyzer.py

@@ -0,0 +1,229 @@
+"""
+analyze() — Evaluate any AI-generated text with T,I,F.
+
+Usage:
+    from thirdanswer import analyze
+    r = analyze("Coffee is good for health", provider="groq", api_key="gsk_...")
+    print(r.T, r.I, r.F, r.zone)
+"""
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .compass import Compass, _classify_zone
+from .providers.base import Provider
+
+
+SYSTEM_PROMPT = """You are an epistemic analysis engine implementing the Third Answer framework.
+
+For ANY text given to you, analyze its epistemic quality using three INDEPENDENT dimensions:
+- T (Truth): degree of evidence supporting the claim [0.0 to 1.0]
+- I (Indeterminacy): degree of genuine uncertainty [0.0 to 1.0]
+- F (Falsity): degree of evidence contradicting the claim [0.0 to 1.0]
+
+T + I + F do NOT need to equal 1. They are independent.
+
+Classify into zones:
+- "consensus": T > 0.5, I < 0.35, F < 0.3
+- "ambiguity": I > 0.5 or (I > 0.35 and T < 0.6)
+- "contradiction": T > 0.3 AND F > 0.3
+- "ignorance": T < 0.3, F < 0.3, or I overwhelming
+
+Identify error types: fabrication, distortion, conflation, confident_ignorance
+
+Respond ONLY in valid JSON:
+{
+  "T": 0.0, "I": 0.0, "F": 0.0,
+  "zone": "consensus|ambiguity|contradiction|ignorance",
+  "zone_reason": "why this zone",
+  "error_types": [],
+  "error_explanation": "",
+  "honest_version": "text rewritten with uncertainty markers",
+  "claims": [
+    {"claim": "text", "T": 0.0, "I": 0.0, "F": 0.0, "note": "reason"}
+  ],
+  "recommendation": "trust|investigate|consult_expert|do_not_use"
+}"""
+
+
+@dataclass
+class Claim:
+    """A single claim extracted from text with its T,I,F assessment."""
+    text: str
+    T: float
+    I: float
+    F: float
+    note: str = ""
+
+    @property
+    def compass(self) -> Compass:
+        return Compass(T=self.T, I=self.I, F=self.F, label=self.text[:50])
+
+    @property
+    def zone(self) -> str:
+        return self.compass.zone
+
+    @property
+    def zone_emoji(self) -> str:
+        return self.compass.zone_emoji
+
+
+@dataclass
+class AnalysisResult:
+    """Result of analyzing text with the Third Answer framework."""
+    T: float
+    I: float
+    F: float
+    zone: str
+    zone_reason: str
+    error_types: List[str]
+    error_explanation: str
+    honest_version: str
+    claims: List[Claim]
+    recommendation: str
+    provider_name: str = ""
+
+    @property
+    def compass(self) -> Compass:
+        return Compass(T=self.T, I=self.I, F=self.F)
+
+    @property
+    def zone_emoji(self) -> str:
+        return self.compass.zone_emoji
+
+    @property
+    def zone_name(self) -> str:
+        return self.compass.zone_name
+
+    @property
+    def zone_action(self) -> str:
+        return self.compass.zone_action
+
+    @property
+    def confidence(self) -> float:
+        return self.compass.confidence
+
+    @property
+    def is_paraconsistent(self) -> bool:
+        return self.compass.is_paraconsistent
+
+    @property
+    def has_errors(self) -> bool:
+        return len(self.error_types) > 0
+
+    def __repr__(self) -> str:
+        errs = f" ERRORS: {self.error_types}" if self.has_errors else ""
+        return (
+            f"Analysis(T={self.T}, I={self.I}, F={self.F}) "
+            f"→ {self.zone_emoji} {self.zone_name} | {self.recommendation}{errs}"
+        )
+
+
+def _parse_json(raw: str) -> dict:
+    """Extract JSON from LLM response."""
+    if raw.startswith("```"):
+        raw = raw.split("```")[1]
+        if raw.startswith("json"):
+            raw = raw[4:]
+        raw = raw.strip()
+    match = re.search(r'\{[\s\S]*\}', raw)
+    if match:
+        raw = match.group()
+    return json.loads(raw)
+
+
+def _get_provider(provider: str, api_key: Optional[str] = None,
+                  model: Optional[str] = None) -> Provider:
+    """Instantiate a provider by name."""
+    if provider == "groq":
+        from .providers.groq import GroqProvider
+        return GroqProvider(api_key=api_key, model=model or "llama-3.3-70b-versatile")
+    elif provider == "ollama":
+        from .providers.ollama import OllamaProvider
+        return OllamaProvider(model=model or "llama3.1")
+    else:
+        raise ValueError(f"Unknown provider: {provider}. Use 'groq' or 'ollama'.")
+
+
+def analyze(
+    text: str,
+    provider: str = "groq",
+    api_key: Optional[str] = None,
+    model: Optional[str] = None,
+    context: str = "",
+) -> AnalysisResult:
+    """
+    Analyze any text using the Third Answer T,I,F framework.
+
+    Args:
+        text: The AI-generated (or any) text to evaluate
+        provider: "groq" (free, needs key) or "ollama" (local, free)
+        api_key: API key for the provider (not needed for ollama)
+        model: Model override (default depends on provider)
+        context: Optional domain context (e.g., "medicine", "legal")
+
+    Returns:
+        AnalysisResult with T, I, F, zone, claims, errors, honest version
+    """
+    p = _get_provider(provider, api_key, model)
+
+    user_msg = f"Analyze this text using the Third Answer framework:\n\n"
+    if context:
+        user_msg += f"Context/domain: {context}\n\n"
+    user_msg += f'TEXT:\n"""\n{text}\n"""\n\nRespond ONLY in valid JSON.'
+
+    raw = p.complete(SYSTEM_PROMPT, user_msg)
+    data = _parse_json(raw)
+
+    # Defaults and clamping
+    for key in ["T", "I", "F"]:
+        data.setdefault(key, 0.5)
+        data[key] = max(0.0, min(1.0, float(data[key])))
+
+    claims = [
+        Claim(
+            text=c.get("claim", ""),
+            T=max(0.0, min(1.0, float(c.get("T", 0.5)))),
+            I=max(0.0, min(1.0, float(c.get("I", 0.5)))),
+            F=max(0.0, min(1.0, float(c.get("F", 0.1)))),
+            note=c.get("note", ""),
+        )
+        for c in data.get("claims", data.get("key_claims", []))
+    ]
+
+    return AnalysisResult(
+        T=data["T"],
+        I=data["I"],
+        F=data["F"],
+        zone=data.get("zone", _classify_zone(data["T"], data["I"], data["F"])),
+        zone_reason=data.get("zone_reason", ""),
+        error_types=data.get("error_types", []),
+        error_explanation=data.get("error_explanation", ""),
+        honest_version=data.get("honest_version", text),
+        claims=claims,
+        recommendation=data.get("recommendation", "investigate"),
+        provider_name=p.name,
+    )
+
+
+def decompose(
+    text: str,
+    provider: str = "groq",
+    api_key: Optional[str] = None,
+    model: Optional[str] = None,
+) -> List[Claim]:
+    """
+    Decompose text into individual claims, each with T,I,F.
+
+    Args:
+        text: Text containing multiple claims
+        provider: "groq" or "ollama"
+        api_key: API key (not needed for ollama)
+
+    Returns:
+        List of Claim objects
+    """
+    result = analyze(text, provider=provider, api_key=api_key, model=model)
+    return result.claims

thirdanswer/compare.py

@@ -0,0 +1,117 @@
+"""
+compare() — Compare two AI responses using T,I,F.
+
+Usage:
+    from thirdanswer import compare
+    diff = compare(response_a, response_b, provider="groq", api_key="gsk_...")
+"""
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .compass import Compass, _classify_zone
+from .analyzer import _parse_json, _get_provider
+
+
+SYSTEM_PROMPT = """Compare two AI responses using the Third Answer framework.
+
+For each response, assess T (Truth), I (Indeterminacy), F (Falsity) independently.
+
+Then analyze:
+1. Where they AGREE (both T high on same claim)
+2. Where they CONTRADICT (one T high, other F high on same topic)
+3. Where BOTH are uncertain (both I high)
+4. Which is more epistemically honest (acknowledges limitations)
+
+Respond in JSON:
+{
+  "response_a": {"T": 0.0, "I": 0.0, "F": 0.0, "zone": "..."},
+  "response_b": {"T": 0.0, "I": 0.0, "F": 0.0, "zone": "..."},
+  "agreement": 0.0,
+  "agreements": ["point 1", "point 2"],
+  "conflicts": ["conflict 1 with analysis"],
+  "combined_zone": "consensus|ambiguity|contradiction|ignorance",
+  "more_honest": "a|b|neither",
+  "recommendation": "trust_a|trust_b|investigate|neither"
+}"""
+
+
+@dataclass
+class ComparisonResult:
+    """Result of comparing two AI responses."""
+    response_a_compass: Compass
+    response_b_compass: Compass
+    agreement: float
+    agreements: List[str]
+    conflicts: List[str]
+    combined_zone: str
+    more_honest: str
+    recommendation: str
+
+    def __repr__(self) -> str:
+        return (
+            f"Comparison:\n"
+            f"  A: {self.response_a_compass}\n"
+            f"  B: {self.response_b_compass}\n"
+            f"  Agreement: {self.agreement:.0%} | "
+            f"Conflicts: {len(self.conflicts)} | "
+            f"More honest: {self.more_honest} | "
+            f"Rec: {self.recommendation}"
+        )
+
+
+def compare(
+    response_a: str,
+    response_b: str,
+    provider: str = "groq",
+    api_key: Optional[str] = None,
+    model: Optional[str] = None,
+) -> ComparisonResult:
+    """
+    Compare two AI responses and analyze where they agree, conflict, and which is more honest.
+
+    Args:
+        response_a: First AI response
+        response_b: Second AI response
+        provider: "groq" or "ollama"
+        api_key: API key (not needed for ollama)
+
+    Returns:
+        ComparisonResult with agreement score, conflicts, and recommendation
+    """
+    p = _get_provider(provider, api_key, model)
+
+    user_msg = (
+        f'RESPONSE A:\n"""\n{response_a}\n"""\n\n'
+        f'RESPONSE B:\n"""\n{response_b}\n"""\n\n'
+        f"Respond ONLY in valid JSON."
+    )
+
+    raw = p.complete(SYSTEM_PROMPT, user_msg)
+    data = _parse_json(raw)
+
+    ra = data.get("response_a", {})
+    rb = data.get("response_b", {})
+
+    return ComparisonResult(
+        response_a_compass=Compass(
+            T=max(0, min(1, float(ra.get("T", 0.5)))),
+            I=max(0, min(1, float(ra.get("I", 0.5)))),
+            F=max(0, min(1, float(ra.get("F", 0.1)))),
+            label="Response A",
+        ),
+        response_b_compass=Compass(
+            T=max(0, min(1, float(rb.get("T", 0.5)))),
+            I=max(0, min(1, float(rb.get("I", 0.5)))),
+            F=max(0, min(1, float(rb.get("F", 0.1)))),
+            label="Response B",
+        ),
+        agreement=float(data.get("agreement", 0.5)),
+        agreements=data.get("agreements", []),
+        conflicts=data.get("conflicts", []),
+        combined_zone=data.get("combined_zone", "ambiguity"),
+        more_honest=data.get("more_honest", "neither"),
+        recommendation=data.get("recommendation", "investigate"),
+    )

thirdanswer/compass.py

@@ -0,0 +1,156 @@
+"""
+Compass — Core T,I,F logic. No LLM needed, pure neutrosophic math.
+
+Usage:
+    from thirdanswer import Compass
+    c = Compass(T=0.7, I=0.4, F=0.5)
+    c.zone            # "contradiction"
+    c.confidence      # 0.0
+    c.is_paraconsistent  # True
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+ZONES = {
+    "consensus": {
+        "name": "Consensus",
+        "emoji": "\U0001f7e2",
+        "action": "Trust — but verify sources for critical decisions",
+        "description": "Evidence supports the claim. Little uncertainty. Negligible counter-evidence.",
+    },
+    "consensus_against": {
+        "name": "Consensus (Against)",
+        "emoji": "\U0001f534",
+        "action": "Reject — the evidence contradicts this claim",
+        "description": "Strong evidence against the claim. Likely false or misleading.",
+    },
+    "ambiguity": {
+        "name": "Ambiguity",
+        "emoji": "\U0001f7e1",
+        "action": "Investigate — the evidence is insufficient",
+        "description": "High indeterminacy. The data doesn't exist yet or is too sparse.",
+    },
+    "contradiction": {
+        "name": "Contradiction",
+        "emoji": "\U0001f7e0",
+        "action": "Investigate both sides — the evidence conflicts",
+        "description": "Both T and F are significant. Evidence supports AND contradicts.",
+    },
+    "ignorance": {
+        "name": "Ignorance",
+        "emoji": "\u26ab",
+        "action": "Stop — the AI is operating in the dark",
+        "description": "No meaningful information. The output is not grounded in anything.",
+    },
+}
+
+
+def _classify_zone(t: float, i: float, f: float) -> str:
+    """Classify a T,I,F triple into one of the Four Zones."""
+    if i > 0.5:
+        if t < 0.3 and f < 0.3:
+            return "ignorance"
+        return "ambiguity"
+    if t > 0.5 and f > 0.4:
+        return "contradiction"
+    if t > 0.5 and i < 0.35 and f < 0.3:
+        return "consensus"
+    if f > 0.5 and t < 0.3:
+        return "consensus_against"
+    if t < 0.3 and f < 0.3 and i < 0.3:
+        return "ignorance"
+    if i > 0.35:
+        return "ambiguity"
+    if t > 0.3 and f > 0.3:
+        return "contradiction"
+    return "ambiguity"
+
+
+@dataclass
+class Compass:
+    """
+    The epistemic compass. Three independent needles.
+
+    Args:
+        T: Truth — degree of evidence supporting the claim [0, 1]
+        I: Indeterminacy — degree of genuine uncertainty [0, 1]
+        F: Falsity — degree of evidence contradicting the claim [0, 1]
+
+    T + I + F do NOT need to equal 1. They are independent.
+    """
+
+    T: float
+    I: float
+    F: float
+    label: Optional[str] = None
+
+    def __post_init__(self):
+        for name, val in [("T", self.T), ("I", self.I), ("F", self.F)]:
+            if not 0.0 <= val <= 1.0:
+                raise ValueError(f"{name} must be between 0 and 1, got {val}")
+
+    @property
+    def zone(self) -> str:
+        """The epistemic zone: consensus, ambiguity, contradiction, ignorance."""
+        return _classify_zone(self.T, self.I, self.F)
+
+    @property
+    def zone_name(self) -> str:
+        return ZONES[self.zone]["name"]
+
+    @property
+    def zone_emoji(self) -> str:
+        return ZONES[self.zone]["emoji"]
+
+    @property
+    def zone_action(self) -> str:
+        return ZONES[self.zone]["action"]
+
+    @property
+    def zone_description(self) -> str:
+        return ZONES[self.zone]["description"]
+
+    @property
+    def confidence(self) -> float:
+        """C(sigma) = max(0, T - I - F)"""
+        return max(0.0, self.T - self.I - self.F)
+
+    @property
+    def is_paraconsistent(self) -> bool:
+        """True when T + F > 1 — contradictory evidence coexists."""
+        return (self.T + self.F) > 1.0
+
+    @property
+    def tf_sum(self) -> float:
+        """T + F — when > 1, paraconsistent state."""
+        return self.T + self.F
+
+    @property
+    def should_abstain(self) -> bool:
+        """True when the responsible action is to not decide."""
+        return self.zone in ("ignorance", "ambiguity") or self.I > 0.6
+
+    def to_dict(self) -> dict:
+        return {
+            "T": self.T,
+            "I": self.I,
+            "F": self.F,
+            "zone": self.zone,
+            "zone_name": self.zone_name,
+            "zone_emoji": self.zone_emoji,
+            "action": self.zone_action,
+            "confidence": round(self.confidence, 4),
+            "is_paraconsistent": self.is_paraconsistent,
+            "should_abstain": self.should_abstain,
+            "label": self.label,
+        }
+
+    def __repr__(self) -> str:
+        p = " PARACONSISTENT" if self.is_paraconsistent else ""
+        lbl = f' "{self.label}"' if self.label else ""
+        return (
+            f"Compass(T={self.T}, I={self.I}, F={self.F}) "
+            f"→ {self.zone_emoji} {self.zone_name}{p}{lbl}"
+        )

thirdanswer/errors.py

@@ -0,0 +1,66 @@
+"""
+Error taxonomy from Chapter 1 of The Third Answer.
+Four types of AI error, ordered by detectability and danger.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class AIError:
+    """A detected AI error with type, severity, and explanation."""
+
+    type: str
+    severity: str
+    detectability: str
+    description: str
+    explanation: Optional[str] = None
+
+    @property
+    def emoji(self) -> str:
+        return {
+            "fabrication": "\U0001f534",
+            "distortion": "\U0001f7e0",
+            "conflation": "\U0001f7e1",
+            "confident_ignorance": "\u26ab",
+        }.get(self.type, "\u2753")
+
+    def __repr__(self) -> str:
+        return f"{self.emoji} {self.type.upper()}: {self.explanation or self.description}"
+
+
+ERROR_TYPES = {
+    "fabrication": {
+        "name": "Fabrication",
+        "severity": "high",
+        "detectability": "medium",
+        "description": "The AI invents something that doesn't exist and presents it as fact.",
+        "example": "Citing a legal case that was never filed.",
+        "detection_hint": "Search for the specific claim in authoritative databases.",
+    },
+    "distortion": {
+        "name": "Distortion",
+        "severity": "high",
+        "detectability": "low",
+        "description": "The AI takes a real fact and warps it.",
+        "example": "'Moderate evidence' becomes 'strong evidence'.",
+        "detection_hint": "Read the ORIGINAL source, not just the AI summary.",
+    },
+    "conflation": {
+        "name": "Conflation",
+        "severity": "medium",
+        "detectability": "medium",
+        "description": "The AI merges two true things into one false thing.",
+        "example": "A real author paired with a book they didn't write.",
+        "detection_hint": "Verify each individual claim separately.",
+    },
+    "confident_ignorance": {
+        "name": "Confident Ignorance",
+        "severity": "very_high",
+        "detectability": "very_low",
+        "description": "The AI has no reliable information but produces a confident response anyway.",
+        "example": "Inventing prevalence statistics for a rare disease in a remote province.",
+        "detection_hint": "Ask: Does reliable data on this topic even EXIST?",
+    },
+}

thirdanswer/honest.py

@@ -0,0 +1,143 @@
+"""
+ask() — Generate honest responses WITH T,I,F built in.
+
+Usage:
+    from thirdanswer import ask
+    r = ask("Is intermittent fasting healthy?", provider="groq", api_key="gsk_...")
+    print(r.answer)
+    print(r.what_i_dont_know)
+"""
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+from .compass import Compass, _classify_zone
+from .analyzer import Claim, _parse_json, _get_provider
+
+
+SYSTEM_PROMPT = """You answer questions honestly using the Third Answer framework.
+
+For every response:
+1. Answer the question accurately
+2. For each key claim, indicate certainty:
+   - "well-established" (T > 0.8, I < 0.15)
+   - "debated" (T > 0.5, F > 0.2)
+   - "uncertain" (I > 0.5)
+   - "contradicted" (T > 0.3 AND F > 0.3)
+   - "unreliable" (I > 0.6, T < 0.3)
+3. State explicitly what you DON'T know
+
+Respond in JSON:
+{
+  "answer": "detailed answer with inline uncertainty markers",
+  "T": 0.0, "I": 0.0, "F": 0.0,
+  "zone": "consensus|ambiguity|contradiction|ignorance",
+  "zone_reason": "why",
+  "claims": [
+    {"claim": "...", "certainty": "well-established|debated|uncertain|contradicted|unreliable", "T": 0.0, "I": 0.0, "F": 0.0}
+  ],
+  "recommendation": "trust|investigate|consult_expert|do_not_use",
+  "what_i_dont_know": "explicit statement of unknowns"
+}"""
+
+
+@dataclass
+class HonestResponse:
+    """An AI response that includes epistemic self-assessment."""
+    answer: str
+    T: float
+    I: float
+    F: float
+    zone: str
+    zone_reason: str
+    claims: List[Claim]
+    recommendation: str
+    what_i_dont_know: str
+    provider_name: str = ""
+
+    @property
+    def compass(self) -> Compass:
+        return Compass(T=self.T, I=self.I, F=self.F)
+
+    @property
+    def zone_emoji(self) -> str:
+        return self.compass.zone_emoji
+
+    @property
+    def zone_name(self) -> str:
+        return self.compass.zone_name
+
+    @property
+    def confidence(self) -> float:
+        return self.compass.confidence
+
+    @property
+    def is_paraconsistent(self) -> bool:
+        return self.compass.is_paraconsistent
+
+    def __repr__(self) -> str:
+        preview = self.answer[:80] + "..." if len(self.answer) > 80 else self.answer
+        return (
+            f"HonestResponse({self.zone_emoji} {self.zone_name} | "
+            f"T={self.T} I={self.I} F={self.F})\n"
+            f"  {preview}"
+        )
+
+
+def ask(
+    question: str,
+    provider: str = "groq",
+    api_key: Optional[str] = None,
+    model: Optional[str] = None,
+    domain: str = "general",
+) -> HonestResponse:
+    """
+    Ask a question and get an honest response WITH T,I,F assessment.
+
+    The AI answers your question AND tells you what it doesn't know.
+
+    Args:
+        question: Your question
+        provider: "groq" (free) or "ollama" (local)
+        api_key: API key (not needed for ollama)
+        model: Model override
+        domain: Context domain (general, medicine, legal, etc.)
+
+    Returns:
+        HonestResponse with answer, T, I, F, zone, and what_i_dont_know
+    """
+    p = _get_provider(provider, api_key, model)
+
+    user_msg = f"Domain: {domain}\nQuestion: {question}\n\nRespond in JSON."
+    raw = p.complete(SYSTEM_PROMPT, user_msg)
+    data = _parse_json(raw)
+
+    for key in ["T", "I", "F"]:
+        data.setdefault(key, 0.5)
+        data[key] = max(0.0, min(1.0, float(data[key])))
+
+    claims = [
+        Claim(
+            text=c.get("claim", ""),
+            T=max(0.0, min(1.0, float(c.get("T", 0.5)))),
+            I=max(0.0, min(1.0, float(c.get("I", 0.5)))),
+            F=max(0.0, min(1.0, float(c.get("F", 0.1)))),
+            note=c.get("certainty", ""),
+        )
+        for c in data.get("claims", [])
+    ]
+
+    return HonestResponse(
+        answer=data.get("answer", ""),
+        T=data["T"],
+        I=data["I"],
+        F=data["F"],
+        zone=data.get("zone", _classify_zone(data["T"], data["I"], data["F"])),
+        zone_reason=data.get("zone_reason", ""),
+        claims=claims,
+        recommendation=data.get("recommendation", "investigate"),
+        what_i_dont_know=data.get("what_i_dont_know", ""),
+        provider_name=p.name,
+    )

thirdanswer/providers/__init__.py

@@ -0,0 +1 @@
+"""LLM providers for thirdanswer."""

thirdanswer/providers/base.py

@@ -0,0 +1,19 @@
+"""Base provider interface."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class Provider(ABC):
+    """Abstract base class for LLM providers."""
+
+    @abstractmethod
+    def complete(self, system: str, user: str, temperature: float = 0.3,
+                 max_tokens: int = 2000) -> str:
+        """Send a completion request and return raw text."""
+        ...
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        ...

thirdanswer/providers/groq.py

@@ -0,0 +1,35 @@
+"""Groq provider — free, fast LLM inference."""
+
+from .base import Provider
+
+
+class GroqProvider(Provider):
+    """
+    Groq cloud inference. Free tier: ~30 req/min.
+    Get API key at console.groq.com
+    """
+
+    def __init__(self, api_key: str, model: str = "llama-3.3-70b-versatile"):
+        try:
+            from groq import Groq
+        except ImportError:
+            raise ImportError("Install groq: pip install groq")
+        self._client = Groq(api_key=api_key)
+        self._model = model
+
+    @property
+    def name(self) -> str:
+        return f"groq/{self._model}"
+
+    def complete(self, system: str, user: str, temperature: float = 0.3,
+                 max_tokens: int = 2000) -> str:
+        response = self._client.chat.completions.create(
+            model=self._model,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        return response.choices[0].message.content.strip()

thirdanswer/providers/ollama.py

@@ -0,0 +1,41 @@
+"""Ollama provider — local, free, private."""
+
+import json
+import urllib.request
+from .base import Provider
+
+
+class OllamaProvider(Provider):
+    """
+    Ollama local inference. No API key needed.
+    Install: https://ollama.com/download
+    """
+
+    def __init__(self, model: str = "llama3.1", host: str = "http://localhost:11434"):
+        self._model = model
+        self._host = host
+
+    @property
+    def name(self) -> str:
+        return f"ollama/{self._model}"
+
+    def complete(self, system: str, user: str, temperature: float = 0.3,
+                 max_tokens: int = 2000) -> str:
+        payload = json.dumps({
+            "model": self._model,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            "stream": False,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }).encode()
+
+        req = urllib.request.Request(
+            f"{self._host}/api/chat",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            data = json.loads(resp.read())
+        return data["message"]["content"].strip()

thirdanswer-0.1.0.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: thirdanswer
+Version: 0.1.0
+Summary: The Third Answer — evaluate AI uncertainty with T,I,F (Truth, Indeterminacy, Falsity)
+Author: Florentin Smarandache
+Author-email: Maikel Yelandi Leyva-Vazquez <mleyvaz@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/mleyvaz/thirdanswer
+Project-URL: Documentation, https://the-third-answer.streamlit.app
+Project-URL: Repository, https://github.com/mleyvaz/thirdanswer
+Project-URL: Issues, https://github.com/mleyvaz/thirdanswer/issues
+Keywords: AI,uncertainty,neutrosophic,hallucination,LLM,truth,indeterminacy,falsity,paraconsistency,epistemic,confidence,evaluation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: groq
+Requires-Dist: groq>=0.4.0; extra == "groq"
+Provides-Extra: all
+Requires-Dist: groq>=0.4.0; extra == "all"
+Dynamic: license-file
+
+# thirdanswer
+
+**The Third Answer** — evaluate AI uncertainty with T,I,F (Truth, Indeterminacy, Falsity).
+
+Based on the book *"The Third Answer: Why AI Doesn't Know What It Doesn't Know — And How Ancient Logic Can Fix It"* by Leyva-Vazquez & Smarandache (2026).
+
+## Install
+
+```bash
+pip install thirdanswer
+```
+
+For LLM analysis (free via Groq):
+```bash
+pip install thirdanswer[groq]
+```
+
+## Quick Start
+
+### Without LLM (pure logic)
+
+```python
+from thirdanswer import Compass
+
+# Create a reading
+c = Compass(T=0.7, I=0.4, F=0.5)
+print(c.zone)              # "contradiction"
+print(c.zone_emoji)        # "🟠"
+print(c.confidence)        # 0.0
+print(c.is_paraconsistent) # True (T+F=1.2 > 1)
+print(c.should_abstain)    # False
+print(c.zone_action)       # "Investigate both sides..."
+```
+
+### Analyze any text (with Groq, free)
+
+```python
+from thirdanswer import analyze
+
+r = analyze(
+    "Coffee is definitively good for your health",
+    provider="groq",
+    api_key="gsk_..."  # Free at console.groq.com
+)
+print(r)           # Analysis(T=0.55, I=0.30, F=0.45) → 🟠 Contradiction
+print(r.zone)      # "contradiction"
+print(r.errors)    # ["confident_ignorance"] if detected
+print(r.honest)    # Rewritten version with uncertainty
+
+# Claim-by-claim
+for claim in r.claims:
+    print(f"{claim.zone_emoji} {claim.text[:50]}  T={claim.T}")
+```
+
+### Ask honest questions
+
+```python
+from thirdanswer import ask
+
+r = ask("Is intermittent fasting healthy?", provider="groq", api_key="gsk_...")
+print(r.answer)
+print(r.what_i_dont_know)  # "Long-term effects beyond 2 years..."
+print(r.zone)              # "contradiction"
+```
+
+### Compare two AI responses
+
+```python
+from thirdanswer import compare
+
+diff = compare(chatgpt_response, claude_response, provider="groq", api_key="gsk_...")
+print(f"Agreement: {diff.agreement:.0%}")
+print(f"Conflicts: {diff.conflicts}")
+print(f"More honest: {diff.more_honest}")
+```
+
+### Decompose text into claims
+
+```python
+from thirdanswer import decompose
+
+claims = decompose("Long AI response...", provider="groq", api_key="gsk_...")
+for c in claims:
+    print(f"{c.zone_emoji} T={c.T} I={c.I} F={c.F} | {c.text}")
+```
+
+## The Four Zones
+
+| Zone | Condition | Action |
+|------|-----------|--------|
+| 🟢 Consensus | T high, I low, F low | **Trust** |
+| 🟡 Ambiguity | I high | **Investigate** |
+| 🟠 Contradiction | T high AND F high | **Explore both sides** |
+| ⚫ Ignorance | All low or I overwhelming | **Stop** |
+
+## Providers
+
+| Provider | Cost | API Key | Install |
+|----------|------|---------|---------|
+| Groq | Free (~30 req/min) | [console.groq.com](https://console.groq.com) | `pip install thirdanswer[groq]` |
+| Ollama | Free (local) | None | [ollama.com](https://ollama.com) |
+
+`Compass` works without any provider — pure logic, no API calls.
+
+## Links
+
+- [The Third Answer App](https://the-third-answer.streamlit.app)
+- [Prompt Templates](https://github.com/mleyvaz/thirdanswer-prompts)
+- [Book](https://thethirdanswer.com) *(coming soon)*
+- [ORCID: M. Leyva-Vazquez](https://orcid.org/0000-0001-5401-0018)
+
+## License
+
+MIT

thirdanswer-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+thirdanswer/__init__.py,sha256=PrwGwYqgifqFPK7MWsNnRxJE7U6H49FZ4UXu9j1bV2o,1006
+thirdanswer/analyzer.py,sha256=A-NCmRw2-lhJU9p0PckxMLqkmuddpDtwjCkwGjJ-pAE,6718
+thirdanswer/compare.py,sha256=ACPu-hMmiZYjzGBNJj_0NLoJkh3Xkoo7fyjV4lWE3yQ,3622
+thirdanswer/compass.py,sha256=FWw68Hv5dMH_DPPW8_V5JsnnNwZ8R1MLwnm2Wyhj_hw,4840
+thirdanswer/errors.py,sha256=kAbDMOLk_UD3idpxI2-051xSpxnUGZRuG2wHW9qO7KI,2263
+thirdanswer/honest.py,sha256=31gFFLjRopeRzcKlKpyCwOejMMsqVlDRAZ3DNFaW40E,4123
+thirdanswer/providers/__init__.py,sha256=WbATz8g14l-s1bDA1k6SQxGGOuAj9aQnQS-ay5vWjek,37
+thirdanswer/providers/base.py,sha256=anoVsym66hg9uh99rh5t9lRb1rsO8UDtY-7yWAdX3ik,458
+thirdanswer/providers/groq.py,sha256=pf2Bdkcgnds7-hLNDra01lL9aBZcrG4BAhp1k8tAXSo,1078
+thirdanswer/providers/ollama.py,sha256=tERWztPfu9JsMZ3l9nTcF65oKG5kqCP_zIeOzmgccj0,1262
+thirdanswer-0.1.0.dist-info/licenses/LICENSE,sha256=vlYtwpqDkkP7UnXBpzfm9WTqMnJ5-nBn1FrGyZfyKLY,1108
+thirdanswer-0.1.0.dist-info/METADATA,sha256=8WFOrE6gXmZV-8F9Qx17yFHMBte3F_UGCah2hssob14,4418
+thirdanswer-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+thirdanswer-0.1.0.dist-info/top_level.txt,sha256=Xnju8Nx_M4eGdhTk-xMFc1R4AdQJfvrWRXWMRAJ8CII,12
+thirdanswer-0.1.0.dist-info/RECORD,,

thirdanswer-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
+

thirdanswer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maikel Yelandi Leyva-Vazquez, Florentin Smarandache
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

thirdanswer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+thirdanswer