Tesla Coils and Corpses 15-Aug-2014

[Brian Warner]

Notes from the weekly crazy-new-topics dev chat (aka "Tesla Coils and
Corpses") for Friday 15-Aug-2014.

Attendees: zooko, warner (scribe), nejucomo, daira, arthur, taylor,
amiller

Topics: anti-centralization for cryptocurrency mining, thermodynamic
reversibility versus irreversible transactions, Noether programming
language rebugging/rewinding features

(notes are sketchy, my apologies)


Can we separate the mining reward vs votes-for-consensus?

https://s3-us-west-2.amazonaws.com/chainbook/The+Anatomy+of+a+Money-like+Informational+Commodity.pdf

arthur: give miners a slightly superlinear award (n log n) to disclose
that they're working together

but superlinear miners get more capital, grow bigger

Pools/centralized miners will have close coordination (they hear about
each other's results quickly). That's part of their advantage over
individual miners. One aspect of this advantage is avoiding wasted work
done on stale blocks as newer blocks propagate across the network.

https://blog.ethereum.org/2014/07/11/toward-a-12-second-block-time/

PulsarCoin: first miner to report an externally-generated value that
everyone else will eventually see too. distance to pulsars? discovering
new pulsars?

distributed relativistic timestamping service

taylor: simultaneity depends upon timing, maybe use an asymmetric
prover/verifier pair

hash committments as qubits: opening == measuring

http://www.scottaaronson.com/papers/moneyfull.pdf

Enforcing single-use of nonces by representing them as qubits, so they
collapse upon use?

arthur: irreversible transactions requires irreversible computation?
thus expending heat.

Is the blockchain computation purely functional? is there mutation? It's
mostly append-only, but the HEAD pointer is basically destructive
mutation. If we assume away double-spends, do we get single-assignment
dataflow?

the HEAD pointer needs to be entangled with the earth somehow

anticentralization by requiring knowledge of entire blockchain for
mining? memory-hard PoW function using the entire history as state?

Reversible ("adiabatic") computation means you can't forget anything.
You can compute a hash function adiabatically. But to search for a
collision, you test a bunch of failed guesses, and you'd be obligated to
remember all of them. Trading storage for heat

"omniscient debugger": doesn't forget anything

Noether will have trail stacks: store new value and the one it replaced,
so you can unwind things efficiently. This is needed to provide error
handling anyways. Nondeterministic operations must record more
information.

The Noether spec is mostly complete, in Daira's head, but not written
down. But she keeps adding things to the spec. Yay feature creep! :)

Invariants don't need to be checked on every turn. once a violation is
discovered, you can rewind back to the last correct turn and then step
forward until the first turn that violates the invariant. This is
visible to the debugger but not to external callers.

nathan asks: could we automatically create test cases from this?

At the beginning of the turn, the invariants are passing, then it
receives a message, then by the end of the turn the invariants are
failing. Test case is the original state plus the message.

But the initial state may be unconstructable, at least through the
public API: it is the result of evolution (constrained by the invariant
checks, but may involve hidden state that can't be directly set by the
constructor). So it's undecidable if you can use the public API to
construct an object in that state. But maybe just present the state to
the author and let them decide how / whether to set up an object in that
state, for the test.