Nine Dimensions of N/A: The Empty Array as a Security Primitive

Over the past seven days, one research pipeline returned zero information points across nine analytical dimensions. Not a degraded read. Not a partial fill. A structural zero — a single empty array sitting at the root of the data structure, with forty-odd table cells hanging off it, every one of them stamped N/A.

The detail that made me read the whole thing twice: the pipeline did not fail quietly. It rendered a complete report. Technical assessment. Token economics. Market positioning. Ecosystem role. Regulatory exposure. Team and governance. A six-row risk matrix with probability and impact columns. A narrative-versus-delivery gap table. An industry-chain transmission map spanning mining, exchanges, infrastructure, DeFi, NFT, and traditional finance. Then a glossary. Then a disclaimer. And attached to the central claim — the claim that no inference was possible — it printed a confidence tag reading "high."

The system was most confident about its own emptiness.

That is the only sentence in roughly four thousand words I would countersign. Every other research product shipped in the same window would have returned nine confident paragraphs built on the same nothing. The empty array is the anomaly, and the anomaly is worth disassembling, because it tells you what the rest of this industry's machinery is actually doing when nobody is watching the cells.

Context: what a nine-dimension framework does when the witness is missing

The document is not an article. It is an analyst framework that got handed an empty input and had to decide what to do about it. Nine dimensions, each with fixed sub-tables. Innovation, maturity, security assumptions, and performance metrics for the technical block. Team, early investor, community and liquidity, treasury and ecosystem fund for the supply structure, each with allocation, unlock schedule, and risk columns. Price impact, message type, sentiment, funding rate, and a three-column competitive landscape for the market block. Upstream dependency, developer signal, and user signal for the ecosystem block, drawn as a three-node arrow diagram with every node blank. A Howey four-element test for regulatory exposure. Contributor count, voter participation, and top-ten concentration for governance. A risk matrix with six categories, four severity columns, and a mitigation column. A narrative-sustainability table. A transmission map with directional impact, magnitude, and time frame per sector.

Every field in that structure requires an input. The input stage returned an empty array. So the framework printed placeholders and, to its credit, said so.

The mechanism that produced the honesty is worth naming precisely, because it is the whole article. The framework carries a traceability rule: every conclusion must cite a specific information point. Conclusion, arrow, information point number. That is a commitment scheme. Each conclusion is a hash of a fact it claims to have seen. If the fact set is empty, the commitment cannot be opened, and the system has no path to a valid-looking output.

It did not hallucinate because the schema made hallucination structurally expensive. Not because the model was well-behaved, not because the prompt was clever. Because the output format had no room for a claim without a pointer.

The framework then did three more things worth noting. It enumerated candidate causes for the vacuum — a very early project, marketing copy that withholds detail, or a parser failure — and judged the parser failure most likely. It printed a recovery checklist: at least three hundred words of source text, a title, a source and a date, project names, article type, a URL for cross-verification. And it defined two monitoring signals: an empty-field ratio above thirty percent triggers an alert, and an information-point count below five means the source lacks analytical density.

It also flagged three risks in itself. Hallucination risk, rated high. Pipeline break risk, rated high. Decision-misuse risk, rated medium, with the explicit recommendation to halt any downstream chain that would auto-consume the output. That recommendation is the correct instinct, and it is placed in the wrong layer — I will come back to that.

Those two monitoring signals and that misplaced recommendation are the parts of the document I want to attack. But first, the mechanics.

The anatomy of a schema-level null

Most pipelines collapse four distinct states into one label. Empty string. Null. Absent key. Not applicable. These are different facts about the world, and a schema that renders all four as N/A has thrown away exactly the information needed to act on any of them.

Look at what the document's tables actually contain. At least three distinct conditions are wearing the same mask. Not provided means the source was read and the field was absent — a property of the publisher. Not identifiable means the field may exist but the text did not permit classification — a property of the analyst. Not applicable means the dimension does not apply to this object — a property of reality. A marketing post with no token economics section is not missing data. There is no token. That is a positive finding about the asset, and the report files it as a negative one.

The Howey table shows the cost of that collapse. Four elements — money invested, common enterprise, expectation of profit, reliance on the efforts of others — all rendered as unknown, with a composite verdict of cannot determine. A Howey test with four unknowns is not a partial test. It is an unexecuted test. Yet it is rendered in the same table geometry as an executed one, with the same borders and the same confidence. A reader skimming tables cannot distinguish a legal analysis that ran and found ambiguity from one that never ran.

The consequence is measurable. An empty-field ratio computed over a collapsed null type is not a metric. It is a count of your own schema's ambiguity. You cannot alert on thirty percent when you cannot say thirty percent of what.

I have seen this exact bug class before, in a different stack. In 2018 I spent four months compiling the Sapling codebase locally on Ubuntu, tracing the Gnark library dependencies by hand. The defect I eventually found was an edge-case overflow in the proof aggregation logic — it only surfaced under a specific compiler optimization, which is why the first round of audits walked past it. The structural shape of that bug was a type boundary that treated absent and zero as equivalent. A value that should have been rejected at the boundary propagated silently downstream, and by the time it reached aggregation it looked like a legitimate input.

Same class. Different stack. When absent and zero share a symbol, every downstream consumer inherits the error, and no amount of downstream validation catches it, because downstream never sees the distinction. That is why theoretical security models keep failing under specific compiler optimizations: the model assumes the type boundary holds, and the boundary was the thing under test.

Completeness, soundness, and which failure the market pays for

Proof systems have two properties that matter, and they are not symmetric. Completeness: a true statement can be proven. Soundness: a false statement cannot be proven. Every real system trades between them.

A prover that fails to produce a proof has a liveness problem. It is visible. It is recoverable. You retry, you re-provision, you page someone at 3 a.m. A prover that produces a valid proof for a false statement has a soundness problem. It is silent, it is catastrophic, and it is irreversible the moment a verifier accepts it.

Confabulated research is a soundness failure. The N/A report is a liveness failure. This industry treats liveness failures as incidents and soundness failures as content.

Math doesn't grade on the curve you applied. A dashboard that logs a revert as downtime and a fabricated fill as uptime will, over enough cycles, optimize itself into a machine that only fabricates. That is not a hypothetical trajectory. It is the default trajectory of any system whose reward signal is output volume, because output volume is the only thing that increments reliably.

There is also an asymmetry in verification cost that nobody budgets for. Verifying a liveness failure costs one log read: did the process return, yes or no. Verifying a soundness failure costs the entire original analysis, re-run from scratch by someone who does not trust the first pass. The N/A report is cheap to audit. A nine-paragraph confident report about an empty source is expensive to audit and, in practice, never gets audited at all. It gets cited.

There is a cleaner way to state what the empty array is. It is close to a zero-knowledge proof of absence. It demonstrates that the prover holds no witness, without revealing a witness — because there is none to reveal. It is the one output in the entire research stack that a consumer can verify without trusting the operator. Everything else in that document, including the confidence tag, is attestation: believe me, I looked. The array is the only verifiable claim in it.

The traceability rule is the load-bearing wall

Strip the framework down and the only part doing security work is the citation requirement. Conclusion, arrow, information point number. That is a Merkle-style commitment at the level of prose. It converts a claim into a pointer, and a pointer either resolves or it does not. There is no third state where the pointer is vague but the paragraph is confident.

Compare that to how nearly every AI research product is built. The output schema is free text. Free text has no slot for no input. It has infinite capacity to absorb nothing and emit something. So the model fills it — not out of malice, but because the schema offers no revert path and generation always terminates. Termination is the only invariant free-text generation actually enforces.

The fix is not a better prompt. Prompts are advisory. Schemas are enforced. If your pipeline's output type is a string rather than a union of string and a revert with a reason, you have already decided that fabrication is preferable to silence, and you made that decision at the type level, before any model ran, before any content arrived.

I made a version of this argument in 2024 while auditing the state transition function of a ZK-Rollup. Six weeks in, the finding was that the recursive proof aggregation mechanism introduced a latency bottleneck that threatened finality under load. The system kept producing correct proofs. It just produced them slower than the settlement window could tolerate. I proposed SNARK-friendly hash functions and cut proof generation time by about fifteen percent. The team shipped it and acknowledged it in their technical blog.

The part I did not put in that report: finality is a latency property, and it is also a semantic one. A system that settles into the wrong state quickly is worse than one that does not settle at all. Nine locally correct N/As, composed into a four-thousand-word document, settle into the wrong state. They produce the artifact of analysis without the substance, and the artifact is what gets consumed, forwarded, and cited.

That is why the 2021 Aave write-up traveled the way it did. Fifty thousand views, cited by three security firms in subsequent audits. Not because the prose was good. Because every claim in it terminated in a function name and a line, and any reader could walk the pointer back. Commitments that open are the only ones worth publishing.

Staleness semantics, or what a consumer should do with N/A

Every oracle integration I have audited has the same fork in the road. When the feed goes stale, do you revert, or do you serve the last known price?

Aave V2's answer was revert. The price getter checks the last-updated timestamp against a heartbeat threshold; if the observation is older than the window, the call fails rather than returning a number. That check is not defensive programming. It is the protocol. A lending market that accepts stale prices is not a lending market. It is a queue for liquidation with extra steps.

I know that path in detail because in 2021 I reverse-engineered the V2 liquidation engine and wrote up the liquidation call line by line. The interesting part was never the flash loan. It was the slippage tolerance parameter and the fact that the documented oracle manipulation mitigations did not fully cover the upgrade path. Liquidity is an illusion until it is tested by an exit. So is price discovery. So is a research report.

Here is where the framework gets closest to correct and then stops one layer short. It recommends halting any downstream chain that would auto-consume the output. That is a revert. But it expresses the revert in prose, inside a disclaimer, at the bottom of the document. Prose is free text. Free text is unenforceable. The enforceable location for that recommendation is a status field in the payload — a machine-readable flag that says this object must not be consumed. The document puts the safety check where no machine will look and calls it a mitigation.

Which brings the risk into focus. The consumer of a research document in 2026 is increasingly not human. In 2025 I built a simulation environment where autonomous agents attempted to exploit standard ERC-20 approval patterns, and the finding that generalizes beyond that specific test was this: agents do not check preconditions, they check for the presence of an object. Hand an agent something shaped like a report and it acts on it. Shape is the entire interface.

The N/A document is report-shaped. It has a title, a risk matrix, a confidence rating, a glossary, and a disclaimer. An agent reading it does not see an empty witness. It sees a schema-conformant payload with a populated confidence field. That is the actual attack surface, and it is not the one the framework was worried about. The framework worried about hallucination. The vector is format.

The thirty-percent threshold is Goodhart bait

Now the monitoring signals. Empty-field ratio above thirty percent triggers an alert. Information-point count below five means insufficient density.

The instinct is right. The instrument is wrong in a specific and predictable way. Empty-field ratio measures the parser's fill rate, not the source's information density. And the cheapest way to clear a thirty-percent threshold is to loosen the definition of a filled field. You do not need better data. You need a more generous notion of what counts as an information point. Any team whose compensation or uptime metric is tied to that ratio will discover this within one sprint, and they will discover it without intending to cheat, because the incentive gradient points there.

The second signal has the opposite defect. A source with four information points is treated identically to a source with zero. Both fail the below-five check. But four points is not nothing — it is a thin, real signal that could support a narrow conclusion if the schema allowed narrow conclusions. The binary threshold throws that away, which trains operators to either pad to five or discard to zero. Neither is analysis.

Community governance makes this worse, not better. Put a fill-rate KPI in front of a governance process and the process will optimize the KPI. Proposal quality drops, voter participation numbers look healthy, and top-ten concentration shifts from token holders to whoever controls the definition of information point. The document marks governance health as N/A across participation and concentration. Fine. The concentration risk that actually matters here is concentration of the definition, and no token-distribution table will ever show it to you.

The 2022 forensics work taught me the general form of this. Mapping twelve thousand transactions to specific contract calls around the FTX collapse, the conclusion was not fraud — it was that the absence of standardized cross-chain messaging produced irreversible asset locks during a liquidity crisis. Absence of a protocol is not a neutral state. It is an unbounded failure mode with no error handler. The same holds at the schema level. Absence of a slot for unknown does not produce unknown-free data. It produces unlabeled unknown, which is strictly worse than a labeled one, because the labeled one can be triaged.

Contrarian: the report is right about the facts and wrong about itself

Here is where I stop agreeing with the document on its own terms.

It names parser failure as the most likely cause of the vacuum, and it may well be correct. But that framing misses the more interesting failure, which is not the empty array. It is that the system produced four thousand words about the empty array.

A sound system reverts at dimension one. It does not render nine sections, a risk matrix, a transmission map, a glossary, and a disclaimer. That output is not the absence of hallucination. It is hallucination with the values set to null. The structure is identical to a filled report — same section count, same table geometry, same rhetorical posture, same confidence apparatus. Only the cells changed.

Verbosity under uncertainty is a tell, and it is one I use constantly. When I audit a protocol and the documentation runs eighty pages with no state transition diagram, I stop reading the documentation and read the bytecode. The N/A report is eighty pages. Its bytecode is one line: information points equals empty array. Everything above that line is presentation, and presentation is where the risk lives.

So the framework has a soundness guarantee at the cell level and none at the document level. Nine locally correct N/As compose into a globally misleading artifact. Composability bugs are the ones that kill protocols, because every component passes its own unit test and the system still fails. The framework tested its cells. Nobody tested the composition.

The confidence tag is the smaller error and the more revealing one. It attaches a high rating to its own inability to infer. A confidence score that returns high on an empty witness is not calibrated. It is a formatting convention. And a formatting convention is precisely what an automated reader will parse as signal. The document worries, correctly, that readers cannot distinguish analysis from fabrication — and then it ships a field that guarantees they cannot.

The structural problem is larger, and no prompt will fix it. Everyone in this cycle is publishing survival research on a schedule: which treasuries have runway, which unlocks are queued, which protocols are bleeding liquidity. That content gets produced whether or not the data supports it, because the schedule is the product. The empty array is a refusal to participate in the schedule. Refusal is unmonetizable. That is why you almost never see it, and it is why the market will keep pricing output volume over soundness until a soundness failure costs more than a liveness failure does. In a drawdown, that repricing is not a hypothetical. It is a margin call on the research layer.

Takeaway: instrument refusal, not fill rate

If you run one of these pipelines, stop measuring how often fields fill and start measuring how often the system refuses. Time-to-revert, from bad input to halt. The ratio of published conclusions that successfully open their commitments. The delta between what your schema can express and what the source actually asserts. Those are soundness metrics. Fill rate is a liveness metric wearing a risk badge.

And keep the empty array in the logs. Not as a failure record to be cleared. As the reference implementation of the only honest output your system is currently capable of producing.

The question I would put to every team shipping automated research this quarter is not whether their pipeline can handle missing data. It is whether their pipeline can return an empty array at all. If it cannot, then something is being returned in its place, every single time, and nobody downstream has a slot to notice.

Smart contracts execute. They don't adjudicate. Neither do research pipelines — but at least a contract reverts.