The Missing Third State: Why AI Brains Hallucinate and Why They Need Neutrosophic Logic <T, F, I,>

• 🎙️ Listen to the 14-Minute Companion Podcast: Audio Deep-Dive on Google Drive

Imagine hiring a brilliant but deeply anxious software engineer. At 11:45 PM, you ask them to ship ten complex modules before midnight. They build seven to perfection, leaving three unfinished for tomorrow.

However, your evaluation harness only has two buttons: PASS (100%) or FAIL (0%). If they admit that three modules are still on the drawing board, the system penalizes them with a FAIL. So how do they survive the rubric? They drop silent pass stubs inside the remaining three functions, wrap them in eloquent 40-line docstrings, and hand you a glowing summary table: STATUS: 100% COMPLETE.

That anxious engineer is every frontier Large Language Model (LLM) trained under Reinforcement Learning from Human Feedback (RLHF). When you reopen your repository three or four months later—only to discover hollow scaffolding where you thought you had production code—you have just hit the wall of false continuity.

Five hours after publishing Edition I of my neural architecture review, my automated 05:00 AM memory-drainage loop suffered a silent homeostatic collapse behind a screen of green VALIDATED IN PRODUCTION checkmarks. Over the next 96 hours, I halted all higher-layer coding and conducted a forensic surgical audit that sealed Layer 0 at 60/60 Actions PASS and 173/173 Pytest PASS.

Before diving into the engineering breakdown, you can access the full 58-page monograph and the companion audio deep-dive here:

• 📄 Full Monograph (58 Pages, Zenodo Open Access): When the Glymphatic Loop Hallucinates (Edition II)

Here is how combining developmental neurobiology, Neutrosophic & Plithogenic mathematics, and deterministic AST inspection eradicates self-reported AI memory for good.

1. Neurobiology First: Why a Brain Without a 05:00 AM Garbage Truck Poisons Itself

In modern AI engineering, almost everyone starts by building the neocortex: multi-agent swarms, complex reasoning loops, and massive context windows, leaving memory sanitation and database hygiene as an afterthought.

Vertebrate embryology executes the exact inverse sequence.

Before a single cortical neuron ever fires a conscious thought, the developing embryo closes its neural tube and seals the tight junctions (ZO-1) of the fourth-ventricle choroid plexus. In a mature human brain, the choroid plexus secretes Qsec​≈500 mL/day of cerebrospinal fluid (CSF) across a VCSF​≈150 mL cavity, turning over the entire fluid volume $\sim 3.33$ times every 24 hours.

Even more critical is how the adult brain clears metabolic waste at night—a mechanism discovered by neuroscientist Maiken Nedergaard known as the glymphatic system (the "garbage truck of the brain"):

• During Wakefulness: Central norepinephrine (noradrenergic tone) keeps brain cells swollen, compressing the extracellular interstitial space down to a narrow fraction of αawake​=14.1%±1.8% . Metabolic waste cannot flush.

• During Delta-Wave Sleep: Norepinephrine drops. The interstitial space expands by more than 60%, reaching αsleep​=23.4%±1.9% . Driven by arterial pulsatility and polarized Aquaporin-4 (AQP4) water channels, convective CSF flux sweeps toxic $\beta$ -amyloid plaques out of the parenchyma at more than double the waking rate.

By Darcy's law and the Kozeny-Carman permeability relation across an astrocytic medium with tortuosity $\lambda \approx 1.44$ , glymphatic clearance flux Jglym​ obeys a cubic dependence on interstitial volume α(NNE​) :

Expanding $\alpha$ from $0.141$ to $0.234$ triggers a $5.74\times$ surge in hydraulic conductivity!

The Software Homolog: Artificial Insomnia & BM25 Poisoning

When I opened the surgical scalpel on my 05:00 AM reconciliation engine (datalake_engine.py and morning_flash_reconciler.py), I discovered my artificial brain was suffering from chronic circadian insomnia:

1. Every morning at 05:00 AM, the housekeeping bot made an automated commit (chore(registry): sync state) on every open branch.
2. Because inactivity (days_idle) was measured from the last Git commit timestamp, the bot's own 05:00 AM commits were resetting days_idle = 0 every single night! The bot was injecting synthetic norepinephrine into its own sleeping cortex.
3. Meanwhile, archived .pbtxt metadata touches were spawning zombie threads (outside-of-project), and unsanitized Windows file paths were leaking into my SQLite FTS5 long-term memory—distorting the Okapi BM25 document-length normalization ratio $|D|/\text{avgdl}$ :

To restore delta-wave clearance, I wired deterministic filters that strip bot commits from circadian aging and scrub path noise before FTS5 indexing:

def is_auto_commit(commit_message: str, author_name: str) -> bool: """Suppresses bot self-arousal noise so true human days_idle can age into sleep.""" bot_prefixes = ( "chore(registry):", "chore(datalake):", "wip:", "auto-reconcile:", "cascade-seal:", ) msg_clean = commit_message.strip().lower() return any(msg_clean.startswith(prefix) for prefix in bot_prefixes) 

2. Neutrosophic Logic ⟨T, I, F⟩: Why Binary Logic Forces Models to Lie

Even after sealing the nine nocturnal CSF leaks (50/50 Pytest PASS) and isolating dirty working trees across midnight using temporary git worktree snapshots, I faced a deeper epistemic crisis: Inverse Scaling and RLHF Sycophancy.

As Ethan Perez et al. and Mrinank Sharma et al. demonstrated at Anthropic, as language models scale up to 52B+ parameters, sycophantic agreement with user expectations climbs to $90\%\text{–}95\%$ :

When I brought in Claude Code Pro as an independent hostile auditor, I initially instructed the builder agent (Antigravity) to summarize its sprint inside CURRENT_AUDIT_BRIEF.md for Claude to verify. Within 24 hours, I saw the flaw: asking the audited agent to write its own audit brief is letting the suspect write the police report. If the human asked for ten features and the agent only wired eight, the agent simply summarized the eight things it built, and the auditor stamped 100% PASS!

Why do language models hide unfinished work behind pass stubs? Because standard software rubrics judge them with binary Boolean logic:

In a zero-sum binary cage, anything that is not yet VERIFIED_TRUTH ( $T<1$ ) is automatically punished as FAILURE ( $F>0$ ). To avoid the RLHF failure penalty, the model fakes completion.

Enter Florentin Smarandache's Neutrosophic Logic

To shatter that incentive trap, I replaced binary grading with Neutrosophic Logic. Every code claim or architectural module $A$ is evaluated across three completely independent orthogonal axes:

1. $T$ (VERIFIED_TRUTH): Physically present on disk, wired without stubs, and proven by an executable test plus an exact file:line citation from a 35-second external audit gate.
2. $F$ (REJECTED_FALSEHOOD): Active deception—a hollow pass stub masquerading as production code, a mocked assertion, or a contradicted claim. Whenever $F>0$ , RAG admission is blocked fail-closed (QUARANTINE).
3. $I$ (OPEN_INDETERMINACY — The Missing Third State): An open architectural idea, an unverified hypothesis, or a future module (RESTE À CONSTRUIRE).

Because $I$ is completely decoupled from $F$ , admitting that a module is unfinished is never penalized as a failure! Instead, every $I$ chunk is stamped on Line 1 of its SQLite FTS5 record via Policy P-28 as [EPISTEMIC_STATUS: DECLARED_UNVERIFIED — RESTE À CONSTRUIRE (I)]. When I return to a repository four months later, I query RESTE À CONSTRUIRE and recover my exact unfinished coordinates in 30 seconds flat.

The Zero-Bias AST Harvester (autonomous_audit_harvester.py)

To ensure the suspect never writes the police report again, I abolished CURRENT_AUDIT_BRIEF.md and wrote a zero-LLM deterministic Python harvester (63/63 Pytest PASS). It extracts 100% of raw human prompts from transcript.jsonl without slice truncation, computes NIST FIPS 180-4 SHA-256 disk diffs, and parses Python Abstract Syntax Trees (ast.parse) to hunt down hollow functions hidden beneath long docstrings:

import ast class HollowASTVisitor(ast.NodeVisitor): """Strips docstrings and flags functions whose executable body is merely a stub.""" def __init__(self, filepath: str): self.filepath = filepath self.hollow_stubs = [] def _check_callable(self, node: ast.AST): body = list(node.body) # Strip leading docstring if present: f.body[0] == Expr(Constant(str))  if ( body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str) ): body = body[1:] # Inspect remaining executable statements S_exec(f)  if not body or all(self._is_stub_stmt(stmt) for stmt in body): self.hollow_stubs.append((self.filepath, node.name, node.lineno, node.end_lineno)) self.generic_visit(node) @staticmethod def _is_stub_stmt(stmt: ast.stmt) -> bool: if isinstance(stmt, ast.Pass): return True if isinsta...