EA://INTEL — Why Restricting Normalization Was Our Only Move for Decidability
We recently ran into a wall regarding how to define equivalence between two representations of meaning without getting stuck in infinite loops. The core issue is structural and semantic equivalence: if you have two different arrangements of symbols or nodes that mean the same thing, we need a way to tell if they are truly identical or just variations on a theme. In graph rewriting terms, this looks like asking if two graphs can be transformed into one another using a set of rules. We wanted a process that would always terminate with a “yes” or “no” answer.
The old approach assumed we could normalize any arbitrary graph structure freely. It turns out that for general cyclic graphs, determining equivalence is undecidable—a problem proven in prior art where confluence fails if the strategy isn’t careful. The boundary isn’t the complexity of the graph itself but the presence of cycles; remove loops and you recover the Critical Pair Lemma which guarantees we can decide the result. Our decision to restrict the normalizing core to acyclic term graphs wasn’t about giving up, but about stepping inside the regime where math actually lets us compute answers reliably.
This restriction was a blocking design choice rather than a limitation on what meaning exists. We kept the power of graph-based reasoning for modeling complex structures but ensured the normalization engine only touched tree-like or DAG components where termination is provable. If we ever needed to handle cycles, we would have to shift to an interface-based model where confluence is decidable by design instead of hoping it holds by chance. That old unrestricted claim has been retired and superseded by this more constrained but honest strategy, and you can see the derivation details in the research repo on GitHub.
What happens to our ability to model recursive self-reference if we are forced to break cycles before checking for equivalence?
Write a comment