Comparing consent and block cain

They both do the same service, getting separated nodes to agree on the tree structure. Consent uses trusted miner, and so the checksum is not part of the equation.
What ese?

We delete, we return the resource to the top level node, and the segment tree is not infinite.  But ripple does something similar, they can be viewed as a finite block chin. Trusted miners can agree that the past is the past, even untrusted miners can sign a contract and agree to deletes.

The problem is new entrants, they have no proof. So, new to the fintech business, you have a due diligence problem in a trusted miner situation.  But both trusted and untrusted have a scaling option, they can sign a contract to put the past into recoverable storage, shard by past quiescence.  If your account is dormant, you still have the do-re-me, but you have an extra stance in the access queue, you have t reactivate a position in the active ledger. Make it  fee, if you want to stay in the active ledger, the pay the fee, oherwise it is cold storage.  Then your active ledger is just that, extremely fast and liquid. Look at the chin, how often does it crawl all the way beck to the top and reconfigure?

S&L does it different

All the information from the past is buried in the accumulated bit error account, a single integer.  No one really has any good knowledge about where it went, but the spread sheet function can prove that is was bound for five years at five thousand  trades a day. Ownership of the spare coins is assigned based on the coherence between savings and loans, on either side, your balance is optimum when you account increases the deposit to loan match, to the extent that you whiten the trade pace.  So, everyone does their own mining by minding their S to L.

S&L is still the same service, making sure everyone agrees on the same tree, the pit boss applies interest swaps to make it so.  In the S&L case, the it  boss insures everyone lines up to the same matched compact graph  which is the implicit generator of trade space. So all parties agree, within observation, error, what the tree looks like, and that tree is the standard yield curve, as seen at the surface only.

All of this is very similar, all of it in closely related theory of queuing on arbitrary networks, but specifically, directed graphs. And all of them have one condition that all agree is abnormal, jamming in the queues. 

There is a commonality all through this stuff. Linux memory allocation has the same segmentation issues, it runs a similar segmentation tree, and has to equivalently queue searches from independent threads.