Concurrent Programs as Strategies in Games

Abstract

Running a newly written concurrent program feels, to the Programmer, like a contest with the Computer, in which the Computer is a devilish opponent trying its level best to execute the program in such a way that the program specification is violated. We make this into mathematics and into the basis of concurrent programming.We show how to interpret each program as a strategy in a two-person game. The program specification becomes the condition that a play wins for player 0 (“Programmer”). In real programs, each program will denote a strategy equipped with an “internal state automaton” which guides the choice at each stage of the packet of instructions to be next submitted to the computer by player 0 (or “Programmer”) for eventual execution by player 1 (or “Computer”).The principal new idea we contribute is to raise both Programmer and Computer to be first class citizens, independent Players in the game of computation (“computational game”) played by Programmer against Computer. Unlike existing semantics, these plays explicitly list both Programmer’s and Computer’s previous moves. Positions, that is, sequences of past moves, entirely replace the conventional execution sequences of states (or sequences of executed instructions) used in previous semantics of concurrency. We contend that: 1) these plays are the “correct” way to represent computational behavior 2) that all informal reasoning about concurrency is more easily and more completely represented by using these plays rather than execution sequences 3) finally, that all reasoning about concurrency should be carried out in systems reflecting these plays rather than reflecting execution sequences. We define several different strategy models, based on: abstract strategies, strategies induced by automata, strategies within one computational game tree, strategies on computational state trees, and strategies guided by the minimal state Nerode equivalence automaton. Strategies have a natural topology in which the strategy operations are continuous. The explicit state structure gives an additional “fine structure” not present in previous Scott domain semantics for concurrency. This fine structure allows Programmer to take into account the many possible behaviors of Computer, and this plays an essential role in applying our paradigm for program development .Our paper is a leisurely tour of the basic notions. We discuss Park’s example, and show how clear, and straightforwardly mathematical, the issues surrounding fairness become when Computer is assigned an independent role as player. We will treat in later papers the corresponding program logics, natural deduction systems, typed lambda calculi, and categories. We give a hint here of the new concurrent program development and verification methodology: see [A.Yakhnis,Ph.D. Diss., 1990], [V. Yakhnis, Ph.D. Diss., 1990], [A. and V. Yakhnis 1990, in prep.].KeywordsComputational StateState StrategyExecution SequenceConcurrent ProgramStrategy OperationThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.