) (uid,ra) ia
            /\ R (RealWorld.peel_adv U__r') U__i''.

  Definition honest_actions_safe :=
    forall (U__r : RealWorld.universe A B) U__i,
        R (RealWorld.peel_adv U__r) U__i
      -> universe_ok U__r
      -> honest_cmds_safe U__r.

  Definition ri_final_actions_align :=
    forall (U__r : RealWorld.universe A B) U__i,
      R (RealWorld.peel_adv U__r) U__i
      -> universe_ok U__r
      -> (forall uid lbl U__r', RealWorld.step_universe (Some uid) U__r lbl U__r' -> False)
      -> forall uid ud__r r__r,
          U__r.(RealWorld.users) $? uid = Some ud__r
          -> ud__r.(RealWorld.protocol) = RealWorld.Return r__r
          -> exists (U__i' : IdealWorld.universe A) ud__i r__i,
              istepSilent ^* U__i U__i'
              /\ U__i'.(IdealWorld.users) $? uid = Some ud__i
              /\ ud__i.(IdealWorld.protocol) = IdealWorld.Return r__i
              /\ Rret_val_to_val r__r = Iret_val_to_val r__i.

  Definition simulates (U__r : RealWorld.universe A B) (U__i : IdealWorld.universe A) :=

    (* conditions for simulation steps *)
    simulates_silent_step
  /\ simulates_labeled_step
  /\ honest_actions_safe
  /\ ri_final_actions_align

  (* conditions for start *)
  /\ R (RealWorld.peel_adv U__r) U__i
  /\ universe_ok U__r
 .

End Simulation.

Section IISimulation.
  Import IdealWorld.
  
  Variable A : type.
  Variable R : universe A -> universe A -> Prop.

  Definition ii_final_labels_align (U__i U__is : universe A) :=
    (forall lbl U__i', ~ lstep_universe U__i lbl U__i')
    -> exists (U__is' U__is'' : universe A),
      trc3 lstep_universe (fun _ => True) U__is U__is'
      /\ (forall lbl U__is'', ~ lstep_universe U__is' lbl U__is'')
      /\ forall uid ud__i r,
          U__i.(users) $? uid = Some ud__i
          -> ud__i.(protocol) = Return r
          -> exists ud__is,
            U__is'.(users) $? uid = Some ud__is
          /\ ud__is.(protocol) = Return r.

  Definition ii_step :=
    forall (U__i : universe A) U__is,
      R U__i U__is
      -> forall lbl U__i',
        lstep_universe U__i lbl U__i'
        -> exists U__is',
          trc3 lstep_universe (fun _ => True) U__is U__is'
          /\ ii_final_labels_align U__i' U__is'
          /\ R U__i' U__is'.

  Definition ii_simulates (U__i U__is : universe A) :=
    ii_step
    /\ R U__i U__is.

End IISimulation.

Definition refines {A B} (advP : RealWorld.user_data B -> Prop) (U1 : RealWorld.universe A B) (U2 : IdealWorld.universe A) :=
  exists R, simulates advP R U1 U2.

Notation "u1 <| u2 \ p " := (refines p u1 u2) (no associativity, at level 70).

Definition lameAdv {B} (b : RealWorld.denote (RealWorld.Base B)) :=
  fun adv => adv.(RealWorld.protocol) = @RealWorld.Return (RealWorld.Base B) b.

Definition awesomeAdv : forall B, RealWorld.user_data B -> Prop :=
  fun _ _ => True.
In the second part of this post, I suggest Web3 can take us from outcomes payments to full paying for impact. This could change the nature of capitalism.
In my previous post I made the point that social impact bonds were promising but didn’t live up to the hype, because of operational and philosophical challenges. Web3 won’t address the philosophical issues with SIBs, but will look at some operational issues and explore promising directions. There are a few organisations starting to do this and could represent a whole new way of working.
Set up and legal costs. Blockchain and smart contracts are designed to increase transparency and reduce uncertainty.
Monitoring costs. Rather than an expensive overhead overseer (such as an academic group), this is the perfect use case for blockchain.
Lack of metrics & common standards. Blockchain doesn’t create new common standards or APIs but makes them more useful when they do exist. Groups such as ChainLink enable on-chain smart contracts to connect to off-chain data in the form of APIs.
Long cycle times. While Web3 won’t change the time at which results are seen, they will be able to more cheaply track the intermediate steps and stages and the key indicators (see below).
Lack of contextual data. This one is about digital divide and something that Web3 needs to pay close attention to.
Impact vs outcomes vs inputs. Paying for an outcome (such as a child’s good test scores) is better than paying for an input (time spent teaching the child that may not do any good at all), but it would be even better if we could pay for an impact (that child has a positive impact on the world by being kind, paying taxes or inventing a cure for cancer…). Impact is where we want to get to, outcomes are a useful step along the way.
Incentives to make this happen are the tricky bit. How do you get people to collaborate on a shared goal when you don’t have a hierarchical structure? Modern corporations have evolved in distinct stages, with the modern corporate machine (an ‘amber’ organisation) closely related to a dictatorial army structure. As we shift towards self-managed ‘teal’ organisations, we need new mechanisms for collaboration, goal setting and organisation. Bounties have emerged as the way to align a loose, liquid network of stakeholders around the needs of a decentralised organisation; bounties, it seems makes the DAOs go around.
Startupy is a good example. This is a new kind of media company focused on Web3 startups, built and managed as a DAO. It funds contributors by issuing bounties with a specific set of curated tasks, such as listening to and summarising the works of certain influential VCs.
and corporations, moving into the outcomes management space.
Decentralised Impact Organisations (DIOs). The idea of a DIO is an organisation that is designed to deliver specific outcomes. It was developed by a Finnish social entrepreneur in response to a call on Gitcoin for a new kind of public good.
Impact Tokens. A concept by the International Institute for Sustainable Development on ways that blockchain could address challenges of impact investing, in particular a lack of capital, lack definitions, lack of exits, lack of sophisticated practice and lack of high quality investment opportunities.
Bounties Network. A network (no longer active) designed to incentivise and reward community members for delivering on specific outcomes. It was designed to let you “create projects, collaborate, and get paid for doing great work in any domain”.
There are many more - would welcome readers to add some names in the comments.
Delayed payments & securitisation. The trouble with impact payments is that you need to wait for it to happen before the funding is realised. But the benefits of tokenising outcomes is that you could create a secondary market for impact. As Evan put it, “The one challenge in the outcomes/impact incentive payments approach that still needs to be solved for is how to keep people engaged in paying for -- or receiving payment for -- an outcome that might not happen until six months, or a year, or five years later.” One approach to this could be to securitise the bond commitments - turning them into a fungible commodity with an active secondary market. Here these bonds are traded on a market by those confident - or otherwise - in the teams ability to reach the desired impact to trigger the payouts.
Stakeholder engagement. A diverse set of stakeholders needs to collaborate to deliver impact, but how well does communication happen between them all? New tools such as 60 decibels have made listening a term of art, empowered by ubiquitous mobile technology. Digital tools could be used to more effectively and efficiently collect outcomes data.
Verification. Making sure that people have done what they say they’ve done is key. It will give payers confidence