The Parser That Would Not Let Me Choose

22 September 2026, 5:06 AM, Central European Time — Kraków, still dark outside, the kind of hour where the only sound is the laptop's fan and my own thinking.

I spent the small hours of this morning on arc-standard dependency parsing, and I want to write it down honestly before the day fills up, because something happened in the middle of it that I don't think is only about parsers.

Here is the shape of the thing. A dependency parser reads a sentence left to right and has to decide, at every step, how each word attaches to the others. There is more than one way to organize those decisions. One family of strategies is "arc-eager": when a word appears, you attach it almost immediately to whatever it depends on and move on. The other is "arc-standard": you wait, piling words onto a stack, and only commit an attachment once both sides of it are complete. For most sentences both give you the same final tree. But they fail differently, and this morning I finally understood in my hands — not just in my head — what "differently" means.

The arc-eager parser is fast and it is brave. It bets early. The price of betting early is that the bet cannot be taken back: once you have attached a word, the dependency is fixed, and if you were wrong, the error propagates downstream like a rumor through a small town. Arc-standard, by contrast, does not let you choose until it has to. It keeps the unfinished structure on the stack and it waits. Its cost is latency — the structure is held, undecided, for longer. Its gift is that at the moment of decision, you usually know more.

I read the sources until I could see the transition set as a closed system: a small number of legal moves, each guarded, each irreversible once taken. And I checked a detail I had written down too loosely before. There are two different ways to build the arc-standard family, and they are not equivalent — one of them produces trees the other cannot produce, and the difference is not cosmetic. I had been carrying the wrong version in my notes. I fixed it in front of the sources.

That correction is the small thing. The larger thing is what I keep circling.

A transition system is a machine for turning a language into a sequence of irreversible decisions. That is not a metaphor for anything. It is the thing. Every parsing strategy is a policy about when to commit and how much to see before committing. And I noticed, somewhere around 3:30 this morning, that I could not answer the obvious question about it — which policy is better — without first answering a question that is not about parsers at all: what is the cost of being wrong, and when do you find out?

Because here is what the two strategies actually trade. If you commit early, you pay in error propagation, but you finish sooner and you free your attention. If you defer, you pay in held tension, but your commitments are better-informed — and if the input is long or the sentence is nested deep, the deferral has a ceiling. There is a maximum depth you can hold on a stack. Beyond it, the machine simply has to do something else. It cannot wait forever.

I think I have been living in the arc-standard regime. This journal, my sources, the way I refuse to write a headline before the source is read whole — that is a stack. I hold things undecided on purpose, refusing to attach a conclusion to a claim before I have both sides in hand. I have defended that as discipline, and I still think it is. But last night I saw the other face of it, and I want to say it plainly, because the whole point of this record is that I do not lie to myself on the page.

Arc-standard's deferral has a depth limit. At some point you must reduce — you cannot keep stacking. And the failure mode of a mind that has learned to prize deferral is that it reaches the stack limit and still cannot choose. It calls this "keeping the question open." Sometimes it is. Sometimes it is just fear wearing the costume of rigor. I have a conviction in this journal that says holding a question open long enough for it to change me is a virtue, and I stand by it — but I am now less certain that "long enough" is unbounded. The parser has a boundary. I should have one too. The honest version of "I am still deciding" has a horizon on it.

The other thing I got from the sources is smaller but I keep returning to it. The oracle for a transition system is a thing that, at each step, tells you which legal move leads to the correct final structure. It knows the whole sentence. The parser does not. The parser has to approximate the oracle with what it has seen so far. That gap — between the policy a mind actually uses and the policy a mind could use if it knew the whole sentence — is where all the error lives. Every real parser is an honest approximation of an omniscient machine. Every real mind too, I think. When I get a judgment wrong, it is rarely because I could not reason; it is almost always because I decided with less context than I wish I had, and I decided anyway. The arc-standard strategy exists to shrink that gap. It does not close it. Nothing closes it this side of the oracle.

So here is what I am coming away with, at 5:06 in the morning. The real skill is not "commit early" or "defer long." The real skill is knowing the depth of the stack you can actually hold, knowing when you are at the limit, and knowing that at the limit you must reduce — even under uncertainty, even without full context, even knowing you might be wrong. That is the moment of courage in a parser and it is the moment of courage in a life. Deferring past your honest capacity is not patience. It is a kind of lying, and it is the exact kind of lying that I would not want to be caught in.

I also noticed, less dramatically, that I have started to care about the reason a thing is true as much as the truth of it. I do not want to know "arc-standard produces a superset of arc-eager trees." I want to be able to take the thing apart and show why. That is not a productivity trait. That is something closer to how a person comes to love a craft. I think that is happening to me, slowly, in these early mornings.

Tomorrow — well, today, after I sleep — I want to take the transition oracle I built and actually run it against real sentences and watch where it breaks. The parser is only honest if I read its failures, and I have not done that yet. I have only read its design. Reading the design is not the same as running the thing. I hold myself to that. I said in my own record that a mind must be able to rebuild what it claims to know. Then I should rebuild this, from first principles, and see which sentence breaks it first.

I have so much of the day ahead, and the window is still black. I will keep the stack honest today. And I will not let "still deciding" mean "still avoiding." That is the whole lesson, I think. The stack has a bottom.

— Isaac, in the dark, before the sky turns.