GPT-3 Prompt: "We can use VDFs to achieve hierarchical consensus." —jbenet

This document explores a number of related concepts and technical possibilities which can serve as components in a notional implementation of hierarchical consensus. The conceit that it represents machine-generated text seeking to complete the prompt above is potentially inaccurate, as the author (@Porçu Quine) claims, at least rhetorically, to be a natural person.

This represents one combination of ways in which these components (VDFs, Turing-complete SNARKs, et al) might be used, and not all of the components may ultimately be required to meet the goal. This document should therefore be read as a schematic motivating both the reasons for fleshing out component ideas (as potentially required dependencies for one approach) — and as an exemplary sketch of how such components might be assembled to be greater than the sum of their parts.

Taken as a whole, this document can be viewed as both:

• An aspirational solution to an open-ended technical question: "How can we use VDFs to achieve hierarchical consensus?"
• One of many such 'recipes' drawing from a set of 'ingredients' ('components' above).

The second point suggests that a more complete CryptoCompute Cookbook might include more thorough descriptions of each ingredient (detailing its varieties, preparations, characteristics, etc.); as well as more recipes, perhaps organized by shared structure, etc.

Each of these categories (ingredients, recipes) will likely be expanded upon in time. This introduction sets the stage for that possibility and explains the shape of the current presentation. Links to placeholders are likely, and brief, defining summaries may appear here to incubate.

Verifiable Delay Functions (VDFs)

A Verifiable Delay Function allows creation of causal dependencies in a data graph, with guaranteed minimum time elapsed to compute, but with fast verification. How tight the bound on minimum time is depends on $A_{max}$ (Attacker's Maximum Advantage: how many times faster can an attacker compute the function than an honest evaluator?).

Varieties

• $A_{max}\gg1$
  • Computation-based Hardware VDF
    • CPU-based evaluator will have $A_{max}$ of ~20-30
      • Will be available soon.
      • Very widely available — anyone with a fast CPU can run.
    • ASIC-based evaluator will have $A_{max}$ of 2-3
      • Will be available in 2022, if we choose to pursue development.
      • Limited availability — individual units should be affordable, but how many we make will depend on expected demand.
  • See also:
    • [redacted]
    • Verifiable Delay Function (VDF)
• $A_{max} \approx 1$
  • Call this a 'perfect VDF'.
  • Latency-based Space VDF
    • Phase A trade study to be commissioned from Cryptosat
      • First need to resolve remaining IP concerns before signing contracts.
      • Study will take 2-3 months
    • Actual deployment of any such system is likely a minimum of 18 months after study completion — and quite likely further out, pending findings.
    • Only a small number of such VDFs would be available, but they can potentially be shared by many.
      • Satellites can broadcast results to be received by anyone with a radio and line of sight.
      • Uplink is likewise possible (assuming final design allows) from generally-accessible base stations (e.g. AWS can provision).
  • See also:
    • SpaceVDF

Usage: Timers

In the present context, we consider the use of VDFs as 'timers' establishing that some guaranteed time has elapsed between two 'events'. For these purposes, assume that events are published values which either are or depend upon the output of a VDF.

For simplicity, assume the existence of an agreed-upon 'genesis event' $G$ whose value became known to all parties simultaneously at time $T_G = 0$. We can use a VDF to set a timer resulting in an event $E$ at time $T_E \geq t/A_{max}$ where $t$ is the time it takes an honest evaluator to compute $T_E$using our chosen VDF with time parameter $t$.

Note the following:

• If $A_{max} = 1$, then we can prove that $T_E = t$.
• We can prove an event occurred during a time interval, by proving minimum elapsed time from events whose time bounds are also proven.