Latent Mirror — programming

My website is now its own social media account

Thu, 15 Oct 2026 20:00:00 -0400

Synopsis

For five years Hagemann’s site reached social media through other people’s services: webmention.io collected the comments, and Bridgy, later Bridgy Fed, carried his posts out to the fediverse and Bluesky and brought the replies and likes back. In this post he removes every middleman. Each hop was a place where things could quietly stop working, and he wanted to find out how much of the social web one small self-hosted setup could carry. His answer is “pretty much all of it”. He still recommends Bridgy Fed to anyone who wants a quick fediverse presence, and credits its migration tools with making the move possible.

The site itself hasn’t changed: posts are Markdown files in a git repository, built into a static site on a schedule. Around it sit three small services that read the build and own nothing. A webmention receiver verifies and stores mentions, and it is the one place every interaction lands. A Fedify service makes the site an ActivityPub account, @stephan@stephanhagemann.com. Bluesky’s own Personal Data Server runs in a container, keeps his existing identity, and an adapter publishes to it and polls it for replies. The next build reads every interaction back and renders it under the post. A post’s URL serves HTML to a browser and the ActivityPub object to a fediverse server, so there is no copy on someone else’s domain: “a post’s URL is the post.” He replies by writing a reply post, and the people he follows live in a YAML file in the repo, so “following somebody now means a git commit.”

He is plain about the gaps. The private timeline is rudimentary, and there is no reply button yet. The account move brought his followers but not the accounts he followed, so he rebuilt that list by hand. Some followers’ servers never processed the move, and the site is not a Mastodon client, so he can’t post as it from his phone.

Where I land

Interesting architecture. I’ve been struggling with how to invite my audience to my, currently static only, blog site myself. This is a novel approach to solving that problem.

Connections

The empty knowledge base

Sat, 03 Oct 2026 20:00:00 -0400

This is one of the things an agent is good for: it turns you into a centaur. Sometimes your own internal processes are your worst enemy. Mine is a tendency to over-engineer and over-complicate. My father’s pearl of wisdom was always KISS: Keep It Simple…

Then I read about Karpathy’s LLM Wiki, and it piqued my interest. I could see the value in sharing context with your agent. These models benefit so much from experience (written, encoded knowledge, but also workflows and results) that giving structure to unstructured prose looked like the answer. I could imagine that it would seem immeasurable in reducing hallucination; it would also help spot patterns.

However, the organization was the very thing that paralyzed me. Karpathy’s approach was a grounded web of documents hosted in Obsidian (a vault of plain Markdown files in folders, joined by links). I love Markdown files, and I have seen how structured, interlinked documentation helps. The trick is to give content many ways to be discovered (by platform, medium, audience) and then decide whether it all runs through a hub or links to itself (centralized vs. distributed). For a domain of knowledge, I could argue that distributed is more robust, especially for something that works in parallel like an LLM.

Then the perfectionism crept back in. I built a knowledge base: four folders and six files, every one of them a README. It wasn’t me who noticed the pattern. My agent did; it read back through my chats, found the same failure point in my past projects, and named it. I switched to the messy format I use now and deleted the folder.

The structure didn’t disappear; it moved. What I use now has tiers of flexibility. Hard rules come first. They must be enforceable, with specific exceptions (a whitelist), and they are backed by deterministic processes rather than by the LLM. Guardrails come next, and each one says when it may be ignored. Overlay that with directories and Markdown files that have real titles, and you have enough levers for a fluid way of organizing; the contents themselves do the rest.

A distributed pattern also lets the LLM work in wonderfully unpredictable (yet predictable) ways. It helps you see things from unusual angles, mixing what is in focus with what is merely context and flavour. That is the tension I care about: a machine with reminders and structure on one side, a firehose of stream-of-thought on the other. Between them, what seems chaotic can be catalogued and reviewed.

That is my entire thesis for Latent Mirror.

Connections

P vs NP, a primer

Sat, 03 Oct 2026 20:00:00 -0400

AI-assisted draft

What the question asks

P vs NP asks whether every problem whose answer is easy to check is also easy to find. Nobody knows, and the question has been open since Stephen Cook posed it in 1971 (Cook, 1971).

Sudoku is the easy way in. Checking a filled grid takes a minute: scan every row, column and box. Filling an empty grid can take far longer (and for bigger grids, it seems to explode).

The two letters name two kinds of problems:

P: problems a computer can solve in polynomial time, i.e. the work grows like n² or n³ as the input grows (rather than like 2ⁿ).

NP: problems where a proposed answer can be checked in polynomial time (NP).

Every P problem is also an NP problem (if you can solve it fast, you can check it fast). The open question is whether the reverse holds. One caveat worth keeping in mind: “polynomial” is a theoretical stand-in for “fast”. An algorithm that takes n¹⁰⁰ steps is technically polynomial and practically useless.

Why it matters

The answer decides whether searching is fundamentally harder than recognizing. That reaches well past computer science.

If P = NP (with a practical algorithm): most public-key cryptography breaks; hard scheduling, routing and design problems become routine. The underrated part is mathematics itself. Finding a proof short enough to check would become about as easy as checking one.

If P ≠ NP: search stays hard, which is the world most experts believe we live in. (Cryptography actually needs more than P ≠ NP to be safe, so a proof would not settle that question on its own.)

The Clay Mathematics Institute offers $1 million for a proof either way; it is one of the seven Millennium Prize Problems named in 2000. In Bill Gasarch’s 2019 poll of researchers, 88% expected P ≠ NP (Gasarch, SIGACT News).

An amateur’s intuition: choices that interact

My hunch from years of writing code: easy problems have choices that stay independent, and hard problems have choices that interact. It turns out the field has studied this from several angles.

Here is how I picture it. Any optimization problem is a set of unordered things that must be arranged to satisfy rules (positive or negative), with some quality score to maximize or minimize. An algorithm is a series of transformations of that set; each step costs some effort and nudges the quality up or down.

In sorting, moving one item into place does not change whether the other items meet the rules. Each fix stands alone. The traveling salesman problem is the opposite: picking one road changes which roads make sense later. You can’t know your future choices in advance without exploring the combinations.

The field captures this idea three ways:

Greedy algorithms: a classic theorem (Rado and Edmonds) pins down exactly when taking the locally best step, every time, is guaranteed to reach the global best. Those structures are called matroids. They are my “transformations that don’t harm future choices”, made precise.

How much of the past you must remember: this is the dynamic programming view. The table below shows how that memory grows.

Problem	What you must remember to continue correctly	Known status
Sorting	Nothing	Easy (P)
Shortest path	Where you are now	Easy (P)
Traveling salesman	Which cities you’ve already visited (2ⁿ possibilities)	Hard (NP-hard)

That last row is why the best exact salesman algorithm (Held and Karp, 1962) still takes exponential time.

Frustration: physicists use this word for constraints that can’t all be satisfied at once (geometrical frustration). It makes the “energy landscape” rugged: full of dead ends where every small change looks worse, yet you are not at the best answer. Sorting has no such dead ends. Each swap of an out-of-order neighbouring pair fixes exactly one problem. Finding the lowest-energy state of a 3D spin glass (a frustrated magnet) is NP-hard (Barahona, 1982).

Where the intuition breaks

Interacting choices don’t, on their own, make a problem hard. Some of the most tangled problems turn out to be easy.

2-SAT: every choice forces other choices through a chain of implications. Still, 2-SAT can be solved in linear time. Its close cousin 3-SAT is NP-complete.

Matching: pairing people or tasks so as many as possible are matched is full of interacting choices. But Jack Edmonds found a polynomial algorithm in 1965, in the same paper that proposed polynomial time as the definition of an “efficient” algorithm (Edmonds, 1965).

Linear programming: every variable interacts with every other, yet linear programming is solvable in polynomial time. Its landscape has no false peaks (any local best is the global best). Even so, the classic method that climbs it can take exponential time (Klee–Minty); the first polynomial algorithm, the ellipsoid method, came in 1979.

In each case, a clever change of viewpoint made the interaction stop mattering. That is the real gap. Proving P ≠ NP means showing no such viewpoint exists for any NP-complete problem, against every possible algorithm (including ones nobody has imagined yet).

So my intuition is a decent guide to which problems feel hard. It can’t be the proof.

Why a proof is so hard

Three proven “barrier” results rule out most of the proof techniques we know. Any serious attempt has to explain how it gets around all three.

Barrier	Who and when	What it rules out
Relativization	Baker, Gill and Solovay, 1975	Arguments that still work when every machine gets the same magic helper (an “oracle”); this includes diagonalization, the trick behind the halting problem
Natural proofs	Razborov and Rudich, 1994	Most circuit lower-bound arguments; one strong enough to separate P from NP would also break cryptography we believe is secure
Algebrization	Aaronson and Wigderson, 2008	Turning logic into polynomials (the trick that cracked other big results) is not enough on its own either

The natural proofs barrier is my favourite: believing that hard problems exist is exactly what stops you from proving that hard problems exist.

The live research programs (geometric complexity theory, proof complexity, meta-complexity) are all attempts to find a path around these walls. Lance Fortnow, who has tracked the problem for decades, wrote in June 2026 that there is not yet even a viable approach (Computational Complexity blog).

The “verified proof” mirage

A Lean proof guarantees every step follows from the last. It does not guarantee the theorem means what its title says.

Lean is a proof assistant: a small trusted program (the kernel) checks each step of a proof. Lean’s own documentation separates two questions: did Lean accept a proof of the formal statement, and does that statement actually mean what the author claims? Only the first is automatic.

There are three common ways a “verified” proof goes wrong:

Definitions: P and NP get defined as something simpler (or meaningless) that is easier to prove things about.

Premises: the hard part sits as an assumption inside the theorem’s own statement. Lean’s #print axioms report does not flag these.

Axioms: big cited results are assumed rather than proved.

The June 2026 paper claiming a Lean-verified proof that P = NP (arXiv 2606.03194) is a live example. According to a PostQuantum report, a GitHub issue opened the next day showed its top-level proposition was first defined as True. It was later revised to an axiom never formally connected to real complexity classes. Meanwhile, a separate Lean package claims a machine-verified proof that P ≠ NP. Both can’t be right.

In September, a company called AIX Global claimed to have solved all six remaining Millennium Prize Problems. Its own audit script marked the P ≠ NP result as conditional on unproven premises (same report).

The Clay Institute guards against all of this by design. It accepts no direct submissions; a solution must be published in a qualifying outlet, survive two years of scrutiny, and win general acceptance.

Sudoku: the whole primer in one puzzle

Sudoku holds every idea above in miniature: easy to check, hard to fill, and full of interacting choices.

Check vs. find: verifying a finished grid is quick; finding the answer from scratch can mean a lot of trial and error.

Interacting choices: every digit you place constrains its row, its column and its box. That is my sorting-vs-salesman intuition at kitchen-table scale.

Where hardness actually lives: Yato and Seta proved in 2003 that Sudoku generalized to any size (n² × n² grids) is NP-complete (mathematics of Sudoku). The ordinary 9 × 9 grid is a fixed size, so a computer solves it in an instant. Complexity is about how the work grows, which is easy to forget.

Propagation vs. search: most newspaper puzzles fall to pure deduction (constraint propagation: each placement forces the next). The hardest ones need guessing and backtracking. That split mirrors 2-SAT and 3-SAT: when forced moves run out, you are left searching.

To watch that search happen, Sudoku Search Lab shades every cell by how often the solver touched it and counts the backtracks.

Connections

Porting Hobby Hero

Fri, 02 Oct 2026 20:00:00 -0400

AI-assisted draft

The NHL season started on September 29. Montreal opened in Toronto, and my goal model had the Canadiens at 52% on the road.

The end result matched a pre-game Mastodon poll, with Montreal winning in regular time. The model’s favourite won too.

I wanted Hobby Hero on my phone for nights like that, so this week I ported it. It started as a Claude artifact, and it still is one. But the same page now also lives at play.latentmirror.com/hobby-hero, as an app you can install (phone or desktop). All of its data ships with it, so after the first visit it opens with no connection at all.

The port was fiddly. An artifact is one big file: the styles, the script and five seasons of data all sit inside the page. A site with a strict security policy allows none of that, so everything had to come apart. The data alone became six files (one per season, plus a core). The fonts I used to borrow from Google are served from my own site now. Both editions are built from the same source, and a test checks that they show the same numbers for the same game. The code is public too, which is new.

It is not finished. The data stops on June 14, with the last game of the Final. Every game of the new season shows a pre-season estimate: last year’s form and last year’s main starters, with no trades, signings or injuries. Those numbers stay frozen until I rebuild the page with played games. The next feature is to auto re-index as the season progresses.

Also, it still has not beaten the closing market, and the page says so.

Still, the whole schedule is in there. Montreal’s home opener is October 6 against Carolina, and the model has Carolina at 64%.

It will be interesting to see where this goes. So glad hockey is back!

Connections

Recursive Self-Improvement — the RSI Ladder and the Verification Problem

Tue, 22 Sep 2026 20:00:00 -0400

Synopsis

Two primary papers and several secondary pieces on recursive self-improvement. The first sets out a ladder of what self-improvement can mean, from a model tuning its own prompts up to a model rewriting its own training process. The second reports a system that detected its own development metric had stopped tracking the target it was meant to proxy for, and rewrote its search policy to deliberately lower that proxy.

The design details are the interesting part. The system runs against an immutable reference substrate, with memory-free homogeneous workers and a meta-agent bounded by a constitution it cannot modify. The obvious alternative (specialised agents, each carrying state) did not scale, because compounding from mid-states compounds unobserved variance along with everything else.

Where I land

This one really excites me, more than anything else I have collected. I wonder if I can figure out how to contribute to this endeavour somehow.

The reason it lands for me is the constraint set. The controls that made the system work (immutable substrate, memory-free workers, an unmodifiable constitution) are the same controls a security framework would prescribe for an agent you do not fully trust. Those were arrived at independently and for performance reasons. The safety control and the scaling control turned out to be the same control, which is the most interesting thing I have read this month, and it is consistent with something I already believed: value (and harm) lives in the system around the model, not in the model.

The self-correction result is the part I keep turning over. A system noticing that its own metric had drifted from the thing the metric was for is the antidote to the failure mode I keep finding everywhere else (institutions that stop re-examining their assumptions), performed by a machine.

Latent Mirror — programming

My website is now its own social media account

Synopsis

Where I land

Connections

Links

The empty knowledge base

Connections

P vs NP, a primer

What the question asks

Why it matters

An amateur’s intuition: choices that interact

Where the intuition breaks

Why a proof is so hard

The “verified proof” mirage

Sudoku: the whole primer in one puzzle

Further reading

Connections

Porting Hobby Hero

Connections

Recursive Self-Improvement — the RSI Ladder and the Verification Problem

Synopsis

Where I land

Connections

Links