Oracle machines and the limits of law

What computer science reveals about courts that won’t show their work

I have spent a few hours recently exploring the intersection of three parts of my life that rarely get to talk to each other: my undergraduate training in formal methods and proofs of correctness, my telecoms work on performance science (in particular the ∆Q algebra), and my direct experience of modern courtrooms — including encounters with what I’ve come to think of as “ghost courts”.

The outcome of that exploration is something I’ve started calling a Theory of Attributability. It’s inspired by the kind of questions people like Turing were asking in the 1930s, when they stepped back and asked not how to compute, but what it really means to compute at all.

Rather than inflict a full ∆Σ calculus of attribution on my readers, I want to share just one idea that really caught my attention: the concept of an oracle machine. It turns out to explain a great deal about what feels off in many courtrooms and administrative systems today — cleanly, efficiently, and without conspiracy or drama.

What’s happening isn’t so much malice as magical thinking: systems behaving as if certain foundational questions have already been answered, without ever showing how. Once you see that pattern, it becomes hard to unsee.

What follows is, I hope, genuinely useful. It puts substance behind that familiar feeling of “one, two, skip a few, ninety-nine, a hundred” when you ask for evidence of authority to act and are met with assumptions rather than answers.

I wish I had understood this a year ago — it would have allowed me to explain what was going on far more clearly, without reaching for dense legal theories of jurisdiction or arcane questions of naming.

---

Have you ever found yourself in a legal or administrative process where you weren’t really disputing the outcome — you were asking a simpler question — and no one would answer it?

Not “is this fair?”
Not “is this wise?”

But something more basic:

Who actually had the authority to do this — and how do we know?

If you’ve ever been told that something is “settled”, “assumed”, or “not open to challenge”, without anyone ever showing you why, you’ve already encountered the phenomenon this essay is about.

It’s like asking a calculator to show its steps — and being told “trust me” instead.

Showing your working

Most of us learned early on that in maths, getting the right answer isn’t always enough. You’re expected to show your working.

Not because teachers enjoy pedantry, but because the working proves that the answer belongs to the problem. It’s the certificate that shows the result is grounded in the rules, not guessed or smuggled in.

Now imagine a calculator that always gives answers — but refuses, even in principle, to show how it got them. You might trust it for a while. But eventually, confidence erodes. You start to wonder whether the answer is grounded at all.

Modern law increasingly behaves like that calculator.

Black boxes and dropped proofs

There’s a difference between a system being opaque and a system skipping proof altogether.

A black box doesn’t just hide how an answer was reached. It hides whether the answer had a valid origin in the first place.

In law, that “origin” is authority:
who is empowered to act, under what statute, in which forum, over what subject.

When a court says “jurisdiction exists”, or “the prosecutor has standing”, or “the court is properly constituted”, those statements aren’t conclusions. They are inputs — base cases in a reasoning chain.

Assuming them without verification drops the proof. The computation continues, but the certificate that shows the authority exists is missing.

Enter the oracle

In computer science, there’s a concept called an oracle.

An oracle is something a computational system can ask questions of — and it always answers correctly. Instantly. Authoritatively. But without explanation.

The system isn’t allowed to inspect how the oracle knows. It simply proceeds as if the answer is settled.

Crucially, oracles don’t solve hard problems. They relocate them somewhere you’re not allowed to look.

That’s why they scale. And that’s why they have limits.

Courts as oracle machines

Modern legal systems increasingly behave like oracle machines.

Foundational questions — about jurisdiction, constitution, standing, service — are treated as if they’ve already been answered somewhere else. The case proceeds on that assumption.

You’ll recognise the language:

• “The court is properly constituted.”

• “Jurisdiction exists.”

• “Service was regular.”

• “The matter is not justiciable.”

These aren’t explanations. They’re oracle answers.

Treating them as “already answered” skips the attribution computation. The legal act goes ahead — but without a visible authority certificate showing where the power actually comes from.

Why this happens (and why it isn’t a conspiracy)

This isn’t about malice or corruption.

It’s about load.

Legal systems today operate at enormous scale. Recomputing authority from first principles in every case is expensive. It slows things down. It threatens throughput.

So systems optimise.

They preserve continuity — cases move, hearings happen, orders are made — by dropping the expensive proof objects that would otherwise have to be carried along.

In computational terms:
authority certificates are omitted to keep the system running.

That’s efficient. And it works — until it doesn’t.

The human cost of oracle law

When authority stops showing its working, the loss isn’t abstract.

People experience it as:

• unanswerable objections,

• procedural run-arounds,

• decisions that cannot be meaningfully challenged,

• and a growing sense that law has become force with paperwork attached.

Trust erodes not because outcomes are unpopular, but because acts lack verifiable certificates. Belief in law depends on seeing the computation complete.

It’s like trusting a calculator that never shows carry-over. You might accept its answers — but you never quite believe them.

The limit of law

There is a point where this optimisation breaks down.

Sometimes someone asks a question that cannot be deferred:

• Which statute authorises this act?

• Which court actually exists?

• Who, precisely, is exercising this power?

At that point, the system reaches a halting condition.

Either it:

1. Produces the authority certificate — shows the working — or

2. Proceeds anyway, explicitly, without one.

That second move isn’t law pretending to be law.
It’s law admitting it has crossed its own limits.

This is not anti-law

None of this is an argument against courts, or law, or governance.

Every system has limits.

Thermodynamics doesn’t make engines useless — it makes engineering honest.
Computability theory doesn’t stop machines — it defines what cannot be done inside them.

Understanding the limits of legal attribution strengthens law. Denying them weakens it.

Why this matters now

Automation, bulk justice, administrative enforcement, and AI-assisted decision-making all make oracle-style authority easier to deploy.

Decisions scale. Proofs don’t.

As outputs accelerate, ungrounded chains of authority erode faster under digital load. The gap between action and attribution widens.

Which makes the question of authority more urgent, not less.

A quiet question to carry with you

So here’s a lens you can use, anywhere power is exercised:

When an act claims authority without a verifiable certificate, are we still inside law — or dealing with an oracle skipping the computation?

You don’t need to shout it.
You don’t need to accuse anyone.

Just notice what happens when the system is asked to show its work.

That’s where its limits are.