rchain-community / behavr Goto Github PK

Holistic Specifications for Robust Programs Sophia Drossopoulou Feb 2020 - how much overlap with behavioral types?

https://github.com/Agoric/agoric-sdk/blob/master/packages/ERTP/src/types.js

rchain-community/js2rho#4

https://github.com/rchain/pi4u/tree/master/Name-free%20combinators%20for%20concurrency%20rhocomb Latest commit
e5e10a2
16 hours ago

cc @Jake-Gillberg

On Apr 22, he referred me to https://github.com/rchain/pi4u/tree/master/AFreshProofTheoryForLADL :

That’s behind our current work by about 2 weeks. We’re incorporating this paper. That allows us to eliminate most of the contextualized resourced theory, but it has the consequence of adding meta-variables to our type judgments.

i am evaluating Kiama as an input format for the theories LADL takes as input by implementing the rho-combinator paper. The code for this implementation is here.

from DAO bug typing:

CT( get, set ) = <get( rtn )>?( <rtn>! | CT( get, set ) ) + <set( nv )>?( CT( get, set ) )

I'm not sure how to read that... in particular get( rtn ). Does + mean Mixture / separation? If so, then what does | mean? Does + mean Conjunction???

using

• rholang syntax for for quoting (@), lift / send and activity / input
• SLMC syntax for or, (maxfix X F) and forall

we get:

@(maxfix X
     forall m .
        m!(forall n. 0 or n!(X) or (maxfix Y { forall n' . for(n' <- b){ X or Y} }
              or (X | X ) ) ) 

I used KaTex to get:

$\phi_{info} = \q{ \rec{X} {\forall m . \lift{m}{\forall n. 0 \lor \lift{n}{X} \lor \rec{Y}{\forall n' . \act{n'}{b}{(X \lor Y)} } \lor (X | X ) }} }$

macros:

{
    "\\q": "\\ulcorner #1 \\urcorner",
    "\\lift": "#1 \\langle\\lvert #2 \\rvert\\rangle",
"\\act": "\\langle #1 ? #2 \\rangle #3",
 "\\rec": "\\mathrm{rec} #1 . ( #2 )"
}

rendered

@leithaus why is equal tested both ways? Did you mean to write subset or something?

 else if ((ProcessSet.equal ipSet gpSet) || (ProcessSet.equal gpSet ipSet))

https://github.com/leithaus/rhocaml/blob/master/mc.ml#L127

I transcribed it somewhat literally:

                        else if ((ipSet == gpSet) || (gpSet == ipSet)) ///@@@@?@?@?@?

https://github.com/rchain-community/behavr/blob/master/src/main/scala/rho/Model.scala#L125

@leithaus in the rholang interpreter, processes can be normalized, compared, and sorted. Any particular reason rho.ml doesn't implement structural equivalence by normalization and comparison?

Is rho calculus strongly normalizing?

cc @Jake-Gillberg whose Rho.scala does structural equivalence by way of normalization.

This was sort of news to me:

Our new MPST theory is a case of behavioural type system: it treats types as
simple processes that reduce and evolve along a typed computation; and since types are simpler
than programs, they can be analysed with simpler methods (e.g., finite model checking via our
parameter φ, cf. ğ6).

• Alceste Scalas and Nobuko Yoshida. 2019. Less is more: multiparty session types revisited. Proc. ACM Program. Lang. 3, POPL, Article 30 (January 2019), 29 pages. DOI:https://doi.org/10.1145/3290343

found via https://lobste.rs/t/formalmethods

cc @tgrospic @leithaus

IOU CONTRIBUTING, LICENSE

https://www.jetbrains.com/idea/download/?fromIDE=#section=linux

http://tpolecat.github.io/presentations/algebraic_types.html

no joy; https://docs.gradle.org/current/userguide/scala_plugin.html

We also exhibit nontrivial formulae encoding confinement and liveness properties for a reflective
higher-order variant of the π-calculus.
-- LADL

0 | @0!(0) | @0!(0) is equivalent to (0 | @0!(0)) | @0!(0) right?

both are equivalent to @0!(0) | @0!(0)

Either my transcription to scala is wrong or there's a bug in rhocaml.

Also from DAO bug typing:

type TB  = <getBalance>?( <rtn>! | TB )
  + <deposit>?( <ackDeposit>?TB )
  + <users.keys>( <ackWithdraw>?TB + <ackSend>?TB )

The line above says "... we simply disjoin the types of each case ..." which tells us how to read +. But logic.ml doesn't have disjunction. Ah... SLMC does:

| Or of formastnode * formastnode

IOU: README
context:

• https://github.com/leithaus/rhocaml
  • A reflective higher-order calculus L.G. Meredith Matthias Radestock
• http://ctp.di.fct.unl.pt/SLMC/