G. wrote:
CFJ 2737 blandly and generally forbade infinite processes by calling
them "at odds with ordinary language". However, the rulings were silent
on exactly where, in any given situation, we decide this departure
between finite and infinite language occurs. In other words, where is
the chain broken?
In CFJ 2737, it's pretty clear that pledges (at the time) did not
trigger legal events (e.g. explicit actions), as pledging to do
something wasn't actually doing it. So it's reasonable that forbidding
self-calling pledges was considered an extension of ISID (e.g. it's the
same as forbidding "I cast an infinite number of votes").
On the other hand, CFJ 3121 deals with explicitly-triggered events in
the rules (where a promise can trigger another promise). However, the
precedent here blandly refers to CFJ 2737, without noticing the crucial
difference: the Rules here DO make it possible for a promise to trigger
another promise.
I accept that it's a potential interpretation, though one I disagree
with, to directly forbid self-calling (direct recursion), although no
rule actually does forbid self-calling. (In fact, original drafts of
the promise rule show that forbidding nested promises was considered,
but dropped on purpose to allow it, so the "legislative will" at the
time was to allow such things, for what it's worth).
Now, examine the two promises (Ping and Pong) in the current case.
Pong, a legal process, is not self-referential, and knows nothing about
the conditions of Ping. And Ping knows nothing of Pong. No single step
in Ping or Pong is IMPOSSIBLE. But, if we are to apply CFJ 2737, we
would say that "the whole" is somehow impossible. So, the question
before the court is to determine *where* the breakdown occurs (hence the
set of CFJs).
The first ruble transfer? Nothing wrong with that. Calling a promise
from another promise? Nothing wrong there, either. And so on. If we
say "it just fails" and nothing happens (i.e. not even the first ruble
transfer occurs), ask this: if we replaced the conditions of Pong with
"this promise is destroyed if it has been cashed 5 times", the process
becomes finite, therefore "allowed": but why should this change in Pong
affect the first operation of Ping, before Pong is even called?
Because the CFJ 2737 precedent considers the chain as a whole. It
doesn't nullify recursion in general, only unterminated recursion
(unless the rules explicitly say "recursion via <method> is allowed
to be unterminated").
Quite simply, any attempt to apply CFJ 2737 "automatically and
generally" (that is, "fairly") to any loop, thus stopping the loop from
doing anything, is in effect asking Agora to solve the Halting Problem!
Asking Agora to potentially do the impossible/impractical is nothing
new; if the potential becomes actual, then it can punt by having someone
judge UNDETERMINED. (If we replaced the conditions of Pong with "this
promise is destroyed if it has been cashed 5 times or the Riemann
hypothesis is true", then things would be murky regardless of CFJ 2737.)
The other approach, of course, is to say, on a meta-level (one level
removed from the process) we recognize that a particular trigger has
"fallen into a loop" and select an arbitrary point to hit Ctl-C ("hey,
the loop works once, but not twice. or three times"). But the
arbitrary nature of this (again, who gets the ruble?) is undesirable.
There may be various options that stop this chain. For example, one
could say (in the manner of Go) that a "board position" (gamestate)
can't "repeat" (e.g. once the ruble transfer loops, that's it).
However, it would be trivially possible to do redo this loop to create
sequentially-numbered golems (for example) so as to create a propagating
state that does repeat (we have not done so out of respect for
recordkeepors) so this in itself is an equally arbitrary choice.
The thinking behind CFJ 2737 was that the start of the infinite chain is
nullified, regardless of how exactly the chain loops.
