Received-SPF: pass (sog-mx-2.v43.ch3.sourceforge.com: domain of gmail.com
	designates 209.85.160.175 as permitted sender)
	client-ip=209.85.160.175; envelope-from=etotheipi@gmail.com;
	helo=mail-gh0-f175.google.com; 
Message-ID: <4FE0C103.3070304@gmail.com>
Date: Tue, 19 Jun 2012 14:12:19 -0400
From: Alan Reiner <etotheipi@gmail.com>
User-Agent: Mozilla/5.0 (X11; Linux i686 on x86_64;
	rv:12.0) Gecko/20120428 Thunderbird/12.0.1
MIME-Version: 1.0
To: Gregory Maxwell <gmaxwell@gmail.com>
References: <CAF7tpEyEWCbcB+jSpWOMyeZUBjQ=FbVEC8kLt3j2Yzv3YJOgiA@mail.gmail.com>
	<4FE0B7EB.6000100@gmail.com>
	<CAAS2fgRFFtdsuaS+ZoFLYcnUxLBufA8aMV=_sHca5ZOi-3viTw@mail.gmail.com>
In-Reply-To: <CAAS2fgRFFtdsuaS+ZoFLYcnUxLBufA8aMV=_sHca5ZOi-3viTw@mail.gmail.com>
Content-Type: multipart/alternative;
	boundary="------------070000040605000202080204"
Cc: bitcoin-development@lists.sourceforge.net
Subject: Re: [Bitcoin-development] Ultimate Blockchain Compression w/
 trust-free lite node
Precedence: list

This is a multi-part message in MIME format.
--------------070000040605000202080204
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit

On 06/19/2012 01:59 PM, Gregory Maxwell wrote:
> On Tue, Jun 19, 2012 at 1:33 PM, Alan Reiner<etotheipi@gmail.com>  wrote:
>>   One app developer updates their
>> RB tree code which updated the RB-tree optimizations/rebalancing, and
>> now a significant portion of the network can't agree on the correct
>> root.  Not only would that be disruptive, it would be a disaster to
>> track down.
> This is why good comprehensive tests and a well specified algorithim
> are important. The tree update algorithm would be normative in that
> scheme. Worrying that implementers might get it wrong would be like
> worrying that they'd get SHA256 wrong.

The point is not that they get it *wrong*, it's that the implement it 
*differently*.  Given a set of 100 TxOuts, there's a seemingly-infinite 
number of ways to construct a binary tree.  Put them in in a different 
order, and you get a different tree. *They're all correct and legal* in 
terms of satisfying expectations of insert, delete and query runtime -- 
but they will produce different root hashes.   And the differences in 
underlying structure are completely transparent to the calling code.

I'm extremely uncomfortable with the idea the you can have all the nodes 
in the tree, but have to replay X years of blockchain history just to 
get the same tree configuration as someone else.  However, a trie 
configuration is history-independent -- given an unspent-TxOut list, 
there's only one way to construct that tree.  That's an important 
property to me.

I can't tell if you're joking about Judy structures: I've never heard of 
them.  But I'll look into it anyway...


--------------070000040605000202080204
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 8bit

<html>
  <head>
    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
  </head>
  <body text="#000000" bgcolor="#FFFFFF">
    On 06/19/2012 01:59 PM, Gregory Maxwell wrote:
    <blockquote
cite="mid:CAAS2fgRFFtdsuaS+ZoFLYcnUxLBufA8aMV=_sHca5ZOi-3viTw@mail.gmail.com"
      type="cite">
      <pre wrap="">On Tue, Jun 19, 2012 at 1:33 PM, Alan Reiner <a class="moz-txt-link-rfc2396E" href="mailto:etotheipi@gmail.com">&lt;etotheipi@gmail.com&gt;</a> wrote:
</pre>
      <blockquote type="cite">
        <pre wrap=""> One app developer updates their
RB tree code which updated the RB-tree optimizations/rebalancing, and
now a significant portion of the network can't agree on the correct
root.  Not only would that be disruptive, it would be a disaster to
track down.
</pre>
      </blockquote>
      <pre wrap="">
This is why good comprehensive tests and a well specified algorithim
are important. The tree update algorithm would be normative in that
scheme. Worrying that implementers might get it wrong would be like
worrying that they'd get SHA256 wrong.</pre>
    </blockquote>
    <br>
    The point is not that they get it <b>wrong</b>, it's that the
    implement it <b>differently</b>.  Given a set of 100 TxOuts,
    there's a seemingly-infinite number of ways to construct a binary
    tree.  Put them in in a different order, and you get a different
    tree.  <b>They're all correct and legal</b> in terms of satisfying
    expectations of insert, delete and query runtime -- but they will
    produce different root hashes.   And the differences in underlying
    structure are completely transparent to the calling code.<br>
    <br>
    I'm extremely uncomfortable with the idea the you can have all the
    nodes in the tree, but have to replay X years of blockchain history
    just to get the same tree configuration as someone else.  However, a
    trie configuration is history-independent -- given an unspent-TxOut
    list, there's only one way to construct that tree.  That's an
    important property to me. <br>
    <br>
    I can't tell if you're joking about Judy structures: I've never
    heard of them.  But I'll look into it anyway...<br>
    <br>
  </body>
</html>

--------------070000040605000202080204--