Zeckendorf-safe Channel

Why BEDC’s compiler input is an event flow with visible boundaries, not a bare bitstream

The GroundCompiler channel uses 0 -> 0, 1 -> 10, and End -> 11 so event boundaries survive as public data in a binary stream without becoming proofs, NameCerts, or physical emergence claims.
Author

The Omega Institute

Published

June 6, 2026

中文

The problem the channel solves

BEDC’s GroundCompiler does not accept a bare string of bits as its formal input. It accepts an EventFlow: a finite ordered list of raw events. Each raw event is itself a finite string over 0 and 1, but the separations between events are part of the datum.

That distinction matters. If we flatten an event flow by erasing its boundaries, different flows can collapse to the same bitstring. The flow (0, 1) and the flow (01) both erase to 01. After erasure, there is no internal evidence telling a decoder which flow was meant.

The channel problem is therefore not “how do we print bits as bits.” It is:

How can a finite event flow be displayed as one binary stream while preserving enough boundary information that the original event flow can be recovered without a hidden parser, manifest, length table, schema, or host-side tree?

The Zeckendorf-safe channel is BEDC’s answer at this layer.

The code

The channel uses three displayed glyph conventions:

raw 0  -> channel 0
raw 1  -> channel 10
End    -> channel 11

An event body is encoded by replacing each raw glyph left-to-right:

0    -> 0
1    -> 10
011  -> 01010
100  -> 1000

Then the terminator 11 is appended. So:

event 0    -> 011
event 1    -> 1011
event 011  -> 0101011
event 100  -> 100011

A whole flow is the concatenation of event codes:

(011, 100) -> 0101011 100011

The legal channel language is:

LegalZStream = ((0 | 10)* 11)*

This is the whole trick. Encoded event bodies are made only from 0 and 10, so an encoded body never contains adjacent 11. The first 11 encountered while reading an event is therefore the event boundary.

Streaming readback

The decoder only needs one-glyph lookahead.

Channel prefix Decoder action
0 emit raw 0 and continue
10 emit raw 1 and continue
11 close the current event
isolated 1 at the end reject

This gives the round-trip statement:

Decode(FlowEncoding(S)) = some S

For legal channel streams, decode also lands back on a flow whose encoding is the stream:

LegalZStream(c) ->
  exists S, Decode(c) = some S and FlowEncoding(S) = c

So the allowed equivalence is exactly:

EventFlow <-> LegalZStream

It is not an equivalence between event flows and arbitrary bitstrings. It is not an equivalence between semantic objects and their printed names. It is a channel-level bijection between finite event flows and the legal streams generated by this delimiter discipline.

✗ "So BEDC input is just a bitstream"

No. A legal channel stream is a boundary-bearing display of an event flow. A bare bitstream has already thrown the event boundaries away. The whole reason the channel exists is that boundary erasure is not injective.

Why the Zeckendorf name appears

The name is easy to misread. The channel is “Zeckendorf-safe” because the body code avoids the adjacent pair 11, leaving 11 available as an unambiguous event terminator. It does not mean the channel is performing Zeckendorf normalization.

Source-level Zeckendorf classifiers live one layer up. A source relation such as:

011 -> 100

may be read as a source-level carry or normal-form relation only after the relevant history flow has been recognized by the appropriate classifier and ledger. It is not a substring rewrite rule on compiled channel strings.

For example:

event 011 -> channel 0101011

If someone rewrites the visible suffix 011 inside 0101011 into 100, the result is:

0101100

The channel decoder reads 0, then 10, then sees 11 as an event boundary, and is left with 00 without a terminator. The stream is malformed. A source carry has been incorrectly applied at the channel layer.

The admissible route is:

channel stream
  -> Decode
event flow
  -> source-level normalizer / classifier
event flow
  -> FlowEncoding
channel stream

No direct channel-glyph rewrite is licensed.

What the channel proves

The GroundCompiler channel proves a narrow and important thing:

Event boundaries can be made public in a finite binary stream, with streaming decode and no structural hidden input.

This is enough to block a common evasion. A compiler consumer cannot say, “the package boundary, theorem identifier, AST node, parser state, or manifest was obvious from the bits.” Those structures are not formal inputs. They must either be encoded as event-flow data and later recognized, or they are not part of the admitted compiler surface.

The channel is therefore a discipline of visibility. It makes the boundary part of the stream rather than part of the reader.

What it does not prove

The legal channel is not:

  • a NameCert;
  • a theorem code;
  • a proof object;
  • a gap ledger;
  • a source-level Zeckendorf carry proof;
  • evidence for entropy, continuum, topology, geometry, or physical space emergence.

Those claims require separate certificate surfaces and separate bridge arguments. The channel only says: here is a lossless, self-delimiting, binary display of finite event flows.

💡 Discovery

The discovery is that boundary information is not auxiliary formatting. Once erased, it cannot be recovered from the flattened marks alone. BEDC’s compiler surface therefore treats event boundaries as first-class data, and the Zeckendorf-safe channel is the smallest binary discipline in this region that keeps those boundaries public.