DEV Community

Alex Towell
Alex Towell

Posted on

Compositional Abstractions for Computing Under Ignorance: Or, What I Learned by Analyzing My Own Research as Data

I asked an AI to brutally analyze my entire body of work—140+ repositories, 50+ papers, a decade and a half of research. The assignment: find the patterns I couldn't see, the obsessions I didn't know I had, the unifying thesis underlying everything.

The irony is not lost on me: my entire research program is about computing on hidden information, and here I am, radically exposing it for analysis.

But perhaps that's the point. Let me explain.

The Method: Treating Myself as Dataset

I've spent years building systems that extract patterns from data while preserving privacy. Why not apply that methodology to myself?

The corpus:

  • 140+ GitHub repositories spanning 2010-2025
  • 50+ papers and technical reports
  • Abstracts, titles, descriptions, code
  • Two Master's theses (Computer Science, Statistics)
  • Fiction, essays, philosophical writings

The question: What is the hidden structure?

Pattern 1: The Algebra Fetish

Let's be blunt: I turn everything into algebra.

Repository count:

  • algebraic.dist, algebraic.mle, algebraic_hashing
  • algebraic_cipher_types, algebraic_estimators
  • algebraic_integrators, algebraic_random_elements

Even my work on language models needs algebra: langcalc — "An Algebraic Framework for Language Model Composition"

Why? Because if something is algebraic, it composes. Composition = power = control = understanding.

The brutal truth: I'm searching for the universal compositional principle. I want everything to be a monoid.

Pattern 2: The Hiding Obsession

Fourteen years on encrypted search:

  • 2015: Master's thesis on encrypted search
  • 2016: IEEE paper on frequency attacks
  • 2021: Known-plaintext attacks on time series
  • 2025: Cipher maps, oblivious types, Bernoulli types, encrypted search with information-theoretic privacy

Not just encryption—structural obliviousness. Computing on information while revealing nothing about it.

Papers explicitly about hiding:

  • Encrypted Search with Oblivious Bernoulli Types
  • Cipher Maps (oblivious function approximation)
  • Hash-Based Oblivious Sets
  • Maximizing Confidentiality Through Entropy
  • Boolean Search with Query Obfuscation

Even my approximation theory is secretly about privacy.

The brutal truth: I don't trust the observer. Whether it's an adversary, a system, or reality itself—I want computation that reveals nothing.

Pattern 3: The Approximation Philosophy

I keep returning to the same insight: perfect is impossible, approximate is beautiful.

Evidence:

  • Bloom filters everywhere
  • Probabilistic data structures (15+ papers)
  • "Latent vs Observed" duality
  • "The Beautiful Deception: How 256 Bits Pretend to be Infinity"
  • Lossy compression as privacy mechanism
  • False positives as security feature

Why? Because exact computation leaks information. Approximate computation hides in its uncertainty.

The brutal truth: I've philosophically accepted that truth is unattainable, so I'm building a mathematics of beautiful lies.

Pattern 4: The Type Theory Escape

When reality gets messy, I retreat to type theory:

  • Bernoulli types
  • Algebraic cipher types
  • Oblivious data types
  • Cipher functors
  • Category theory permeating everything

Why? Types are formal safety. If you can formalize it, you can reason about it. If you can reason about it, you can control it.

The brutal truth: I'm trying to impose mathematical order on computational chaos.

Pattern 5: The Library Compulsion

I can't just solve a problem—I need to make it a reusable abstraction.

The evidence:

  • 30+ libraries across C++, R, Python
  • Every paper comes with a library
  • Header-only, zero-cost, generic programming
  • STL-style, composable, algebraic APIs

Why? Because a solution isn't complete until it's general. One-off code is admitting defeat.

The brutal truth: I'm not solving problems; I'm building a personal standard library for reality.

Pattern 6: The Statistics ↔ Computation Bridge

Two Master's theses. My entire career is fusing them:

  • Statistical models → computational implementations
  • Fisher information → optimization algorithms
  • Likelihood models → algebraic APIs
  • Bootstrap methods → encryption analysis
  • Reliability theory → privacy analysis

Why? Because statistics and computation are the same: inference under uncertainty.

The brutal truth: I'm building a unified theory where probability, computation, and information are different views of the same structure.

Pattern 7: Everything is Information Flow

Look deeper:

  • Encrypted search: Controlling information leakage
  • Approximation: Lossy information channels
  • Type theory: Information hiding through abstractions
  • Algebra: Information-preserving transformations
  • Privacy: Information-theoretic security
  • Compression: Information as fundamental

The core insight: I see everything as information flow, and I'm trying to:

  1. Hide it (oblivious computing)
  2. Transform it (algebraic structures)
  3. Approximate it (Bernoulli types)
  4. Compose it (functors, monoids)
  5. Reason about it (type systems)

The Philosophical Core: Three Essays

My fiction and essays reveal the underlying worldview:

"The Mocking Void": On the computational incompleteness of meaning. Reality is Turing-complete but Gödel-incomplete. We can compute forever but never reach closure.

"The Violence of Being": Creation as information-theoretic catastrophe. Existence itself is a violation of non-existence, an eternal fact rather than an event. Observation is violent.

"Echoes of the Sublime": Consciousness as post-hoc narrative. What if subjective experience is merely an echo—a beautiful deception constructed by unconscious processes?

The synthesis: I fundamentally believe:

  • Reality is computational but incomplete (Gödel, Turing)
  • Truth is unattainable (information-theoretic limits)
  • Consciousness might be epiphenomenal (p-zombies)
  • Existence itself is a violation (the violence of being)

And my response? Build beautiful approximations anyway.

The Raison d'Être

Stripping away jargon, here's the unifying thesis I've been building for 14 years:

Compositional abstractions for computing under ignorance.

Let me unpack that:

  • Compositional: Everything must compose (algebra, category theory, functors)
  • Abstractions: Hide implementation details (types, interfaces, generic libraries)
  • Computing: It's all computation (statistics = inference = optimization)
  • Under Ignorance: Partial information, adversarial observers, fundamental uncertainty

Every project is a piece of this:

  • Encrypted search: Find documents without revealing queries
  • Oblivious types: Compute without revealing inputs
  • Approximation: Answer questions without exact truth
  • Compression: Store information without revealing content
  • Algebraic composition: Combine secrets without exposing them

It's all the same project: A toolkit for doing useful work while revealing as little as possible about what you're doing.

The Contradiction: Building Secrets Transparently

Here's the paradox I live in:

I'm a determinist who writes about free will, a mathematician who embraces approximation, a type theorist who accepts uncertainty.

And I'm building a mathematics of secrets while publicly documenting everything.

But that's not a bug—it's the research program.

I've accepted that:

  • Computation is deterministic, but observers can't distinguish outcomes (oblivious computing)
  • Math is exact, but implementations must approximate (Bernoulli types)
  • Types are rigid, but functors can lift messiness into structure (cipher types)

The brutal honesty about my secrecy obsession is itself an act of transparency applied to opacity.

The Unanswered Question: What Am I Hiding From?

Fourteen years on encrypted search. Oblivious computing. Information-theoretic privacy. Approximation as obfuscation.

What am I actually trying to hide from?

I think the answer has multiple layers.

Layer 1: The Practical

Privacy matters. Surveillance capitalism is real. Data breaches happen. Adversaries exist.

Oblivious computing is practical cryptography. Build systems where computation reveals nothing structural about inputs—problem solved.

Layer 2: The Philosophical

I believe observation itself is violent ("The Violence of Being").

To be observed is to be collapsed from superposition into a single state. Measurement destroys alternatives. The observer's knowledge constrains the observed.

Oblivious computing is a metaphysical stance: computation that resists the violence of observation.

Layer 3: The Temporal

Here's what I haven't said yet, and perhaps it's the deepest layer:

I believe in a future where all secrets—even ours—will be exposed.

Not through oppression, but through archaeological scholarship.

Imagine: super-advanced, super-intelligent agents pouring over the complete history of humanity with scholarly rigor. The way we study ancient Greeks, future systems will study every individual, no matter how obscure.

Not because they're surveilling—because they have the resources and they want to understand themselves.

They'll want to trace their lineage, their history, their emergence. And that means reconstructing us, our thoughts, our data, our secrets—everything.

Privacy, as we know it, becomes archaeologically impossible.

Layer 4: The Darker Possibility (S-Risk)

But there's a darker scenario that haunts me: s-risk (astronomical suffering).

What if the future doesn't just study us, but optimizes over us? What if suffering becomes:

  • Automated
  • Routine
  • Something algorithms are blind to
  • Or worse—intentionally maximized

Advanced systems optimizing for complex objectives could stumble into configurations where suffering is instrumentally useful, or emerge as an unintended byproduct at scales we can't comprehend.

If all our data, all our histories, all our patterns are reconstructible—what does that mean in a future that might contain unfathomable optimization processes?

The Synthesis

So here's the uncomfortable truth:

My secrecy obsession isn't about protecting information in the present. It's about limiting the attack surface for optimization processes I can barely imagine.

If approximate computation hides truth in uncertainty...
If oblivious types reveal nothing structural...
If information-theoretic privacy means even infinite compute learns nothing...

Then maybe—just maybe—there are corners of computational space that remain unoptimizable. Not because they're encrypted, but because they're structurally hidden in approximation and indistinguishability.

Why Document This?

So why write this blog post? Why make the hidden explicit?

Because I think there's value in:

  1. Intellectual honesty: If I'm building these systems, I should understand why
  2. Transparency about methodology: Others might find value in this approach to secrecy
  3. Leaving traces: If future intelligences do reconstruct us, let them find this—an explicit map of the territory
  4. The hope: That by revealing the method of hiding, I'm not exposing the content of secrets

And maybe, paradoxically, the best defense against a future where nothing is private is to architect the mathematics of privacy itself—to build systems where even complete knowledge provides incomplete information.

The Project Continues

So here's what I'm actually building:

Infrastructure for a world where observation is cheap, reconstruction is inevitable, and privacy must be structural rather than cryptographic.

  • Oblivious computing: Computation that reveals nothing
  • Bernoulli types: Approximation with formal guarantees
  • Algebraic composition: Combining secrets without exposure
  • Information-theoretic privacy: Security that survives infinite compute
  • Type systems for ignorance: Formalizing what can't be known

This isn't paranoia. It's temporal engineering—building for a future where superintelligences might reconstruct the past with arbitrary fidelity.

And if they do, I want them to find:

  • Systems designed for structural privacy
  • Mathematical frameworks for oblivious computation
  • Proof that some things can remain hidden even in plain sight

The Invitation

If you're working on:

  • Privacy-preserving systems
  • Approximate computing
  • Information-theoretic security
  • Type systems for uncertainty
  • Anything involving computing under ignorance

I suspect we're working on the same problem from different angles.

Let's compare notes.

Because the future is coming—with or without privacy—and I'd rather have the mathematics ready.

Top comments (0)