Event systems (NuPrl library)

1. Towards Programming with Knowledge Expressions. R. Kurhi-Suonio (1986)

   • explores the use of knowledge expressions in the design of distributed algorithms
   • a knowledge-motivated abstraction tool is suggested to be useful in supporting stepwise refinement of distributed algorithms

2. Programming Simultaneous Actions Using Common Knowledge. Yoram Moses, M. R. Tuttle (1988)

   • applies knowledge for designing fault-tolerant protocols in distributed systems
   • defines a large class of problems requiring coordinated simultaneous actions in synchronous distributed systems
   • gives a method for transforming specifications of these problems in protocols that are (in some specific way) optimal in all runs

3. Modeling Knowledge and Action in Distributed Systems. Joseph Y. Halpern, Ronald Fagin (1989)

   • knowledge-based protocols provide a natural way of describing how actions should take place in a distributed system
   • presents the formal model, definitions for knowledge-based programs and implementations

4. Knowledge and Common Knowledge In a Distributed Environment. Joseph Y. Halpern, Yoram Moses (1990)

   • communication in a distributed system is seen as the act of transforming the system's state of knowledge
   • argues that the states of knowledge of groups of processors are useful for design/analysis of distributed systems
   • distributed knowledge as knowledge distributed among agents
   • common knowledge as facts that are publicly known
   • in practical systems common knowledge cannot be attained, but some weaker variants of common knowledge are attainable

5. A Little Knowledge Goes a Long Way: Knowledge-Based Derivations and Correctness Proofs For a Family of Protocols. Joseph Y. Halpern, L. D. Zuck (1992)

   • derives a knowledge-based protocol for the sequence transmission problem
   • known protocols for this problem ( as the alternating bit protocol, Stenning's protocol) are all instances of the derived knowledge-based protocol
   • the correctness proof for the knowledge-based protocol leads to uniform correctness proofs for all these protocols

6. Implementing Distributed Knowledge-Based Protocols. M. S. Mazer (1991)

7. Reasoning About Knowledge. Joseph Y. Halpern, Ronald Fagin, Yoram Moses, Moshe Y. Vardi (1995)

8. Knowledge-Based Programs. Joseph Y. Halpern, Ronald Fagin, Yoram Moses, Moshe Y. Vardi (1996)

   • focuses on the problem of knowledge-based program implementability: in a given context, is there any implementation of a specific knowledge-based program, and if yes, is this implementation unique?
   • shows that there are contexts in which some knowledge-based programs may be represented by no/one/many systems
   • finds the complexity of determining whether a given knowledge-based program has a unique representation, or any representation at all, in a given finite-state context
   • gives a sufficient condition for a knowledge-based program to be represented in a unique way in a given context

9. Implementing Knowledge-Based Programs. Moshe Y. Vardi (1996)

   • focuses on the problem of knowledge-based program implementation: given a context and a knowledge-based program, decide for some protocol whether it is an implementation of the knowledge-based program
   • provides a condition which is necessary and sufficient to guarantee that a given knowledge-based program is implemented by a given protocol
   • finds the complexity of determining whether a given knowledge-based program is implemented by a given protocol in a given finite-state context

10. Knowledge Based Programs: On the Complexity of Perfect Recall in Finite Environments. Ron van der Meyden (1996)

    • presents a variant of the framework of Fagin et al. that facilitates the study of optimizing the implementations of a given knowledge-based program
    • all results apply to finite-state environments and synchronous systems of agents with perfect recall, and atemporal knowledge-based programs
    • under the above assumptions, it is shown that one cannot expect to always obtain finite-state implementations as there are environments in which knowledge-based programs may generate behaviors PSPACE-complete; still, PSPACE-complete is the most complex behavior under the above assumptions
    • shows that with respect to perfect recall semantics for knowledge, determining the existence of finite-state implementations of knowledge-based programs is undecidable

1. A predicate transformer approach to knowledge and knowledge-based protocols. Beverly Sanders (1991)

2. Finite State Implementations of Knowledge-Based Programs. Ron van der Meyden (1996)

   • identifies 2 natural cases in which it is possible to automatically construct finite-state implementations of atemporal knowledge-based programs; the cases are:
     1. agents are aware only of their current observation and the current time
     2. agents have perfect recall and all communication is by synchronous broadcast
   • these are steps towards a theory of automated synthesis of protocols from knowledge-based specifications

3. Constructing Finite State Implementations of Knowledge-Based Programs with Perfect Recall. Ron van der Meyden (1997)

   • gives on overview of the previous work on knowledge-based program implementation:
     1. with respect to perfect recall semantics for knowledge, finite-state implementations of knowledge-based programs do not always exist
     2. determining the existence of such implementations is undecidable
     3. a sufficient condition that guarantees that such a finite-state implementation exists has been identified
     4. this sufficient condition is also undecidable
   • shows that there is an approach to the optimization of implementation that gives a finite-state implementation exactly when this sufficient condition holds
   • further contribution to a theory of automated synthesis of protocols from knowledge-based specifications

4. Using counterfactuals in knowledge-based programming. Joseph Y. Halpern, Yoram Moses (1998)

5. Synthesis from Knowledge-Based Specifications. Ron van der Meyden, Moshe Y. Vardi (1998)

   • focuses on the problem of synthesis of reactive systems with incomplete information wrt specifications in the logic of knowledge and time
   • argues that for synthesis of reactive systems with incomplete information it is desirable to have a knowledge-based specification, since it can refer to the uncertainty the program has about the environment's behavior
   • shows that synthesis with incomplete information wrt specifications in the logic of knowledge and time has the same worst-case complexity as synthesis with complete information

6. A Program Refinement Framework Supporting Reasoning about Knowledge and Time. Kai Engelhardt, Ron van der Meyden, Yoram Moses (2000)

   • adds a logic of quantified local propositions to a previously developed temporal refinement framework; the logic of local propositions is a generalization of the logic of knowledge
   • this framework is used for program refinement and supports both temporal reasoning and reasoning about the knowledge of a single agent
   • the framework provides a formal setting for development of knowledge-based programs
   • discusses 2 of the problems with existing theories about knowledge-based programs:
     1. lack of compositionality
     2. knowledge-based programs only have implementations of high computational complexity
     based on On refinement and temporal annotations. Ron van der Meyden, Yoram Moses (2000)

7. A Refinement Theory that Supports Reasoning about Knowledge and Time for Synchronous Agents. Kai Engelhardt, Ron van der Meyden, Yoram Moses (2001)

   • provides a semantic framework for program refinement that supports both temporal reasoning and reasoning about knowledge of multiple agents, but ...
   • makes the rigid synchrony assumption: all agents and the environment proceed in lockstep
   • derives the two-phase commit protocol

1. Constructive Mathematics and Automatic Program Writers. Robert Constable (1971)

2. A Logic for Correct Program Development. Joseph Bates (1981)

   • proposes the idea that correct program development should not be based on reasoning about code, but on constructive existence proofs
     1. reasoning about specifications
     2. constructively proving that specifications have acceptable implementations
   • specifications are written in an imperative notation og generalized assignment
   • proposes a logic for formal refinement of specifications (PRL); this logic is based on intuitionistic reasoning
   • it is argued that hierarchical, and not linear proofs are appropiate when reasoning is developed and presented with machine aid
   • presents a mecahnism of extracting correct code from valid proofs
   • advocates correct program construction rather than program verification; the aim is to obtain executable code only by means of correct formal development
   • affirms that proof and program should be developed as a unit, and that the appropiate time for machine aid is during program development
   • program refinement is seen as the constructive proof of its specification
   • the PRL presented is confined to the study of imperative program segments whose only noticeable effects when executed are to modify the values of global variables

3. Writing Programs That Construct Proofs. Robert Constable, T. Knoblock, J. Bates (1984)

4. Extracting Efficient Code from Constructive Proofs. James Sasaki (1985)

5. The Semantics of Evidence. Robert Constable (1985)

   • explains the meaning of constructive logic
     • in predicate calculus, a sentence is true if its truth value is true
     • in constructive logic each sentence is associated a set of elements comprising evidence for it; a sentence is true in a model if there is evidence for it; proofs are expressions denoting evidence
     • this interpretation of proofs is useful for relating computation and logic, since computational problems involve using evidence of sentences being true in specific models
   • the logic used is a standard kind of predicate calculus
   • the meaning of a formula is given with respect to a model and a state; a state here is similar to an environment binding variables to values
   • for any formula, model and state it is associated a set of elements named evidence>; evidence is defined recursively on the structure of the corresponding formula
   • it is proved that for every sentence B, model m and state s, B holds in m and s iff the evidence set associated with B, m and s is not empty (a statement is true in a model exactly when there is evidence for it)
   • proofs are notations for evidence
     • syntax and correctness conditions are given for proof expressions
     • sequents are defined as a proves A from H, for a proof expression, A formula and H list of bindings of the form x:A', meaning that x is a proof expression for formula A'
     • rules have the form of Post productions and there use if for defining relationships a is a proof expression for A inductively; the usual introduction and eliminations rules are given
     • a semantics for proof expressions wrt models is given
     • it is proved that, relative to a model structure m, a proof a for formula A is actually evidence for A in m (member of the evidence set)
   • with the exception of one rule that proves the law of the excluded middle, all proof expressions are given meaning in terms of recursively defined equations; this means that if the law of excluded middle is removed from the predicate calculus, then evidence is computable
     predicate logics without the law of excluded middle are constructive in the above sense; sometimes they are called intuitionistic logics

6. Proofs as Programs. J. Bates, Robert Constable (1985)

7. Constructive Automata Theory Implemented with the Nuprl Proof Development System. Christoph Kreitz (1986)

8. Logic-Based Knowledge Representations. Paul Jackson (1989)

9. Extracting Circuits from Constructive Proofs. David Basin (1991)

10. Formally Verified Synthesis of Combinational Circuits. David Basin, G. Brown, M. Leeser (1991)

11. Meta-Synthesis: Deriving Programs that Develop Programs. Christoph Kreitz (1992)

12. Nuprl and its Use in Circuit Design. Paul Jackson (1992)

13. Lectures on: Classical Proofs as Programs. Robert Constable (1992)

14. Aspects of the Computational Content of Proofs. J. L. Underwood (1994)

15. Classical Tools for Constructive Proof Search. James Caldwell, Judith Underwood (1996)

16. Moving Proofs-as_programs into Practice. James Caldwell (1997)

17. Automating Inductive Specification Proofs. Brigitte Pientka, Christoph Kreitz (1999)

18. Specifications and Proofs for Ensemble Layers. Jason Hickey, Nancy Lynch, Robbert van Renesse (1999)

19. Intuitionistic Tableau Extracted. James Caldwell (1999)

20. Writing Constructive Proofs Yielding Efficient Extracted Programs. Aleksey Nogin (2001)

21. Automated Complexity Analysis of Nuprl Extracted Programs. Ralph Benzinger (2001)