ravachol70

# The Witness Algorithm: Privacy Protection in a Fully Transparent System
By **Vlad Gluhovsky** and **Gavin Wood**

# Introduction

Being based upon a quasi-Turing-complete (quasi because it's actually bounded) virtual machine, Ethereum is an extremely versatile system. However one of its greatest strengths---universal auditability---seems to lead to a fatal flaw, namely an inescapable lack of privacy. Here we demonstrate an algorithm in order to prove that this is not the case.

The algorithm could be used to make an Ethereum contract which, given two sets of addresses sources, `src`, and destinations, `dest`, will guarantee exactly one of two possible eventualities:

- For each address in `src`, the controller of that address controls a corresponding address in `dest` (though the two cannot be related *a priori*).

ravachol70

Here you come knocking down the street with that cheeky bit of humblebrag
written all over your face;
such a mighty shame and a big disgrace,
all over the place.

You say "don't knock it 'til you try it #humblebrag;
it's blowing up all over the space -- taking over, all over..."
#humblebrag

Now that you wrap it all up in a tidy bit of fantasy,

ravachol70

Ithakrash, [12 Jan 2019 20:03:32]:
ευέλικτο υπολογισμό = a sort of computation ?

Luk, [12 Jan 2019 20:03:55]:
ευέλικτο υπολογισμό = flexible calculation

Ithakrash, [12 Jan 2019 20:04:46]:
a calculation that is flexible = a computation

I think that makes sense, logically. I might throw that one in.

ravachol70

mathematical category: complex variables

Truth is axiomatic to the problem space. 
No space ⊢ No possibility of multi-colinearity,
#ekphrasis or synthesis. All codes
refactor into blatant, brutal complexes. #praxis
The nature of the inchoate statistics, in the vernacular:
symbolic, logical and mathematical explication about the common knowledge.

The common trope or dispatch of the « information » ...

ravachol70

package akka.tutorial.first.java;
 
import akka.actor.ActorRef;
import akka.actor.UntypedActor;
import akka.actor.UntypedActorFactory;
import akka.actor.ActorSystem;
import akka.actor.Props;
 
public class Hello {
   

ravachol70

import tropos.actor.UntypedActor;
import tropos.actor.UntypedActorFactory;
import tropos.actor.ActorSystem;
import tropos.actor.Props;

ravachol70

/**
 *  Coffee
 *
 *  Just a very simple example of deploying a contract at a vanity address
 *  across several chains.
 *
 *  See: https://blog.ricmoo.com/contract-addresses-549074919ec8
 *
 */

ravachol70

module Category where

open import Agda.Primitive public
  using (Level ; _⊔_ ; lzero ; lsuc)

open import Agda.Builtin.Equality public
  using (_≡_ ; refl)


record Category ℓ ℓ′ : Set (lsuc (ℓ ⊔ ℓ′)) where

ravachol70

{-# LANGUAGE DataKinds               #-}
{-# LANGUAGE PolyKinds               #-}
{-# LANGUAGE TypeOperators           #-}
{-# LANGUAGE UndecidableInstances    #-}
{-# LANGUAGE UnsaturatedTypeFamilies #-}

import GHC.TypeLits
import Prelude hiding (Functor, Semigroup)

type Main = (Fizz <> Buzz) <$> (0 `To` 100)

ravachol70

Completion
It's a piece of your life going nowhere. Your time is limited. Do something about it. Make it happen. Get on with it.

Why do you want to go back to the old life?

The truth is that we don't have all the answers and that sometimes we can't even understand why the life we've lived so far has happened.

For me, it's something I struggle with at times. It's a reminder that we aren't always where we want to be. It's something I have no control over.

It's something that I have to accept. But I also try to accept that this is me and that this is where I am and that it can go back to where it's going.