From d2c8a361f1c7fae75bc847b97a2fac6fd33ea0e7 Mon Sep 17 00:00:00 2001 From: Inphi Date: Thu, 30 May 2024 20:57:33 +0000 Subject: [PATCH] deploy: cec87c7fa2b88b5e89d8f67d7783363f8b352c40 --- .../fault-proof/stage-one/fault-dispute-game.html | 14 +++++++------- print.html | 14 +++++++------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/experimental/fault-proof/stage-one/fault-dispute-game.html b/experimental/fault-proof/stage-one/fault-dispute-game.html index 2ee0c23c1..c3455a71a 100644 --- a/experimental/fault-proof/stage-one/fault-dispute-game.html +++ b/experimental/fault-proof/stage-one/fault-dispute-game.html @@ -231,7 +231,7 @@

Fault D

Overview

The Fault Dispute Game (FDG) is a specific type of dispute game that verifies the -validity of a root claim by iteratively bisecting over output roots and execution traces of single +validity of a root claim by iteratively bisecting over output roots and execution traces of single block state transitions down to a single instruction step. It relies on a Virtual Machine (VM) to falsify invalid claims made at a single instruction step.

Actors, i.e. Players, interact with the game by making claims that dispute other claims in the FDG. @@ -258,8 +258,8 @@

Execution Tra Every execution trace has a unique starting state, , that's preset to a FDG implementation. We refer to this state as the ABSOLUTE_PRESTATE.

Claims

-

Claims assert an output root or the state of the FPVM at a given instruction. This is represented as -a Hash type, a bytes32 representing either an output root or a commitment to the last VM state in a +

Claims assert an output root or the state of the FPVM at a given instruction. This is represented as +a Hash type, a bytes32 representing either an output root or a commitment to the last VM state in a trace. A FDG is initialized with an output root that corresponds to the state of L2 at a given L2 block number, and execution trace subgames at SPLIT_DEPTH + 1 are initialized with a claim that commits to the entire execution trace between two consecutive output roots (a block n -> n+1 state transition). As we'll see later, there can be multiple @@ -297,14 +297,14 @@

Subgame

  • Output Roots
  • Execution Trace Commitments
    • -

    At and above the split depth, all subgame roots correspond to output roots, or commitments to the full +

    At and above the split depth, all subgame roots correspond to output roots, or commitments to the full state of L2 at a given L2 block number. Below the split depth, subgame roots correspond to commitments to the fault proof VM's state at a given instruction step.

    Game Tree

    The Game Tree is a binary tree of positions. Every claim in the DAG references a position in the Game Tree. The Game Tree has a split depth and maximum depth, SPLIT_DEPTH and MAX_GAME_DEPTH respectively, that are both preset to an FDG implementation. The split depth defines the maximum depth at which claims about -output roots can occur, and below it, execution trace bisection occurs. Thus, the Game Tree contains +output roots can occur, and below it, execution trace bisection occurs. Thus, the Game Tree contains positions, where is the MAX_GAME_DEPTH (unless , in which case there's only 1 position).

    The full game tree, with a layer of the tree allocated to output bisection, and sub-trees after an arbitrary split depth, looks like:

    @@ -319,7 +319,7 @@

    Position

  • is a function returning the index of the position at its depth (starting from the left).

    • Positions at the deepest level of the game tree correspond to indices in the execution trace, whereas claims at the -split depth represent single L2 blocks' output roots. +split depth represent single L2 blocks' output roots. Positions higher up the game tree also cover the deepest, right-most positions relative to the current position. We refer to this coverage as the trace index of a Position.

    @@ -361,7 +361,7 @@

    Moves

    A Move is a challenge against an existing claim and must include an alternate claim asserting a different trace. Moves can either be attacks or defenses and serve to update to DAG by adding nodes and edges targeting the disputed claim.

    -

    Moves within the fault dispute game can claim two separate values: output roots and execution trace +

    Moves within the fault dispute game can claim two separate values: output roots and execution trace commitments. At and above the SPLIT_DEPTH, claims correspond to output roots, while below the split depth, they correspond to execution trace commitments.

    Initially, claims added to the DAG are uncontested (i.e. not countered). Once a move targets a claim, that claim diff --git a/print.html b/print.html index ddd5b2569..02dca707e 100644 --- a/print.html +++ b/print.html @@ -6527,7 +6527,7 @@

    Fault D

    Overview

    The Fault Dispute Game (FDG) is a specific type of dispute game that verifies the -validity of a root claim by iteratively bisecting over output roots and execution traces of single +validity of a root claim by iteratively bisecting over output roots and execution traces of single block state transitions down to a single instruction step. It relies on a Virtual Machine (VM) to falsify invalid claims made at a single instruction step.

    Actors, i.e. Players, interact with the game by making claims that dispute other claims in the FDG. @@ -6554,8 +6554,8 @@

    Execution Tra Every execution trace has a unique starting state, , that's preset to a FDG implementation. We refer to this state as the ABSOLUTE_PRESTATE.

    Claims

    -

    Claims assert an output root or the state of the FPVM at a given instruction. This is represented as -a Hash type, a bytes32 representing either an output root or a commitment to the last VM state in a +

    Claims assert an output root or the state of the FPVM at a given instruction. This is represented as +a Hash type, a bytes32 representing either an output root or a commitment to the last VM state in a trace. A FDG is initialized with an output root that corresponds to the state of L2 at a given L2 block number, and execution trace subgames at SPLIT_DEPTH + 1 are initialized with a claim that commits to the entire execution trace between two consecutive output roots (a block n -> n+1 state transition). As we'll see later, there can be multiple @@ -6593,14 +6593,14 @@

    Subgame

  • Output Roots
  • Execution Trace Commitments
    • -

    At and above the split depth, all subgame roots correspond to output roots, or commitments to the full +

    At and above the split depth, all subgame roots correspond to output roots, or commitments to the full state of L2 at a given L2 block number. Below the split depth, subgame roots correspond to commitments to the fault proof VM's state at a given instruction step.

    Game Tree

    The Game Tree is a binary tree of positions. Every claim in the DAG references a position in the Game Tree. The Game Tree has a split depth and maximum depth, SPLIT_DEPTH and MAX_GAME_DEPTH respectively, that are both preset to an FDG implementation. The split depth defines the maximum depth at which claims about -output roots can occur, and below it, execution trace bisection occurs. Thus, the Game Tree contains +output roots can occur, and below it, execution trace bisection occurs. Thus, the Game Tree contains positions, where is the MAX_GAME_DEPTH (unless , in which case there's only 1 position).

    The full game tree, with a layer of the tree allocated to output bisection, and sub-trees after an arbitrary split depth, looks like:

    @@ -6615,7 +6615,7 @@

    Position

  • is a function returning the index of the position at its depth (starting from the left).

    • Positions at the deepest level of the game tree correspond to indices in the execution trace, whereas claims at the -split depth represent single L2 blocks' output roots. +split depth represent single L2 blocks' output roots. Positions higher up the game tree also cover the deepest, right-most positions relative to the current position. We refer to this coverage as the trace index of a Position.

    @@ -6657,7 +6657,7 @@

    Moves

    A Move is a challenge against an existing claim and must include an alternate claim asserting a different trace. Moves can either be attacks or defenses and serve to update to DAG by adding nodes and edges targeting the disputed claim.

    -

    Moves within the fault dispute game can claim two separate values: output roots and execution trace +

    Moves within the fault dispute game can claim two separate values: output roots and execution trace commitments. At and above the SPLIT_DEPTH, claims correspond to output roots, while below the split depth, they correspond to execution trace commitments.

    Initially, claims added to the DAG are uncontested (i.e. not countered). Once a move targets a claim, that claim