Where the WHERE goes

Languages all the way down

A condition like Chi(spec) is a claim about structure, so there must be a notion of what structure a specimen has. In SQL that comes from the schema. In f1r3lang it comes from a language definition — and it is a great deal more than a schema.

A Theory declaration has four rungs. The first names the grammar: what terms exist. The second adds equations — the invariants every codebase currently maintains by hand, in comments the type system cannot read: this is a list, but order doesn't matter; compare this string case-insensitively. Pattern matching then happens up to those equations, so nobody ever writes a normalisation function or hits the bug where two spellings of one value meet. The third rung adds rewrites — rules that make the data move on its own. The slogan is: the data can wiggle.

The fourth rung makes a definition a module: a theory takes other theories as parameters, renames what it inherits, and combines with its siblings over a shared ancestor rather than beside one — so parallel composition is "commutative monoid, carrier renamed," and associativity arrives with the parameter instead of being restated. Sharing is a claim the compiler holds you to: two theories that arrived by different routes are two things, and if they share a name, that is a diagnostic rather than a silent override. Definitions live in Module declarations and import by address, not path — a language definition published on chain has an address, and importing it is the same act whether it came from the next directory or another party's node.

From one declaration, the toolchain generates the parser, the printer, substitution, and the rewrite engine. And the connection back to the language is one sentence: a channel's type is a language definition. Sending on a channel means sending a term of that language — two agents can exchange programs in a domain-specific language built for the purpose, and the recipient knows exactly what it received.

A guard returns a truth value, and the communication fires or does not. That is one choice, not the only one. Let the condition return a value — a probability, a rate, a cost — and read it as how much this candidate happens rather than whether.

The reassurance first: when the values are plain Booleans, nothing changes. No existing program acquires a new meaning. A developer who never grades a condition never encounters any of this.

A developer who does gets the same program text as three artefacts. Over Booleans it is what it always was: code committing transactions. Over rates it becomes a stochastic simulation of a population of itself — running it many times gives the distribution of outcomes, which is how you ask "if this contract is deployed a thousand times against that environment, what happens?" in the language the system is written in, with no separate model to drift. And in the measured example — a forager with a finite budget, deciding whether to open specimens — the graded clause is the learning rule: the belief update turns out to be a correctly conditioned, unconditionally stable gradient step. Machine learning fell out; none was imported.

The graded readings run in a separate simulator, off the consensus path, by design. And one honest fence: a restricted fragment admits a complex-valued, quantum-style reading — a real construction for circuit-shaped programs, not a claim that f1r3lang is a quantum language.