@InProceedings{RP76,
  author = 	 { Ronald L. Rivest and Vaughan R. Pratt },
  title = 	 { The Mutual Exclusion Problem for Unreliable Processes: Preliminary Report },
  pages = 	 { 1--8 },
  doi =          { 10.1109/SFCS.1976.33 },                  
  booktitle =    { Proceedings 17th Annual Symposium on Foundations of Computer Science },                  
  publisher =    { IEEE },
  editor = 	 { Michael J. Fischer },
  date =         { 1976 },                  
  eventtitle = 	 { FOCS '76 },
  OPTyear = 	 { 1976 },
  OPTmonth = 	 { October 25--27, },
  eventdate =    { 1976-10-25/1976-10-27 },                  
  venue =        { Houston, Texas },                  
  OPTorganization = { IEEE },
  abstract =     {
         Consider $n$ processes operating asynchronously in
         parallel, each of which maintains a single ``special'' variable
         which can be read (but not written) by the other processes.
         \par                   
         All coordination between processes is to be accomplished
         by means of the execution of the primitive operations of a
         process (1) reading another process's special variable, and
         (2) setting its own special variable to some value. A process may
         ``die'' at any time, when its special variable is (automatically) set to
         a special ``dead'' value.  A dead process may revive. Reading a
         special variable which is being simultaneously written returns
         either the old or the new value.
         \par                  
         Each process may be in a certain ``critical'' state (which
         it leaves if it dies). We present a coordination scheme with the
         following properties.\\
         (1) At most one process is ever in its critical state at
         a time.\\
         (2) If a process wants to enter its critical state, it
         may do so before any other process enters its crttical state more
         than once.\\
         (3) The special variables are bounded in value.\\
         (4) Some process wanting to enter its critical state can
         always make progress to that goal.\\
         \par                  
         By the definition of the problem, no process can prevent
         another from entering its critical state by repeatedly failing
         and restarting.
         \par
         In the case of two processes, what makes our solution of
         particular interest is its remarkable simplicity when compared
         with the extant solutions to this problem. Our $n$-process
         solution uses the two-process solution as a subroutine. and is
         not quite as elegant as the two-process solution.
                 },                  
}