Space Lower Bounds for the Signal Detection Problem

Many shared memory algorithms have to deal with the problem of determining whether the value of a shared object has changed in between two successive accesses of that object by a process when the responses from both are the same. Motivated by this problem, we define the signal detection problem, which can be studied on a purely combinatorial level. Consider a system with n + 1 processes consisting of n readers and one signaller. The processes communicate through a shared blackboard that can store a value from a domain of size m. Processes are scheduled by an adversary. When scheduled, a process reads the blackboard, modifies its contents arbitrarily, and, provided it is a reader, returns a Boolean value. A reader must return true if the signaller has taken a step since the reader’s preceding step; otherwise it must return false. Intuitively, in a system with n processes, signal detection should require at least n bits of shared information, i.e., m ≥ 2n. But a proof of this conjecture remains elusive. For the general case, we prove a lower bound of m ≥ n2. For restricted versions of the problem, where the processes are oblivious or where the signaller must write a fixed sequence of values, we prove a tight lower bound of m ≥ 2n. We also consider a version of the problem where each reader takes at most two steps. In this case, we prove that m = n + 1 blackboard values are necessary and sufficient.


The Signal Detection Problem
Consider a system consisting of n + 1 processes, one signaller, s, and n readers, r 1 , . . . , r n , that communicate through a shared blackboard. The blackboard can contain one value from a domain of size m. Processes are scheduled to take steps one at a time by an adversarial scheduler. Whenever a process takes a step, it atomically reads the blackboard and can modify its contents arbitrarily without interruption from other processes.
In the signal detection problem, each time a reader, r i , has taken a step, it must return a Boolean value. If r i has no preceding step, it can return either true or false. Otherwise, it must return true if and only if the signaller has taken a step since r i 's preceding step. We are concerned with how large m has to be for this problem to be solvable.

Simple Signal Detection Algorithms
For large or unbounded values of m, there are some simple solutions to the signal detection problem. For example, the blackboard could store an unbounded signal counter that is initially 0. Each time the signaller takes a step, it increments the counter. When a reader is scheduled, it simply memorizes the counter value, but does not change it. To detect whether a signal has occurred since its last step, a reader only needs to compare the current counter value with the one it read in its previous step. The value stored on the blackboard grows with the number of signals that have occurred, which can be unbounded.
A similar algorithm is for the signaller to increment the counter whenever it sees the value is odd and for each reader to increment the counter whenever it sees the value is even. A reader also memorizes the resulting value of the counter. It detects whether a signal has occurred since its last step by comparing this value with the value it previously memorized. If there are many consecutive steps by the signaller, the value of the counter grows more slowly than in the previous algorithm.
The following simple algorithm stores an n-bit string (b 1 , . . . , b n ) on the blackboard, i.e. the domain size is m = 2 n . Initially, b 1 = · · · = b n = 0. Whenever the signaller takes a step, it sets all bits to 1. For each j ∈ {1, . . . , n}, reader r j resets bit b j to 0, it returns false if the old value of b j was 0, and it returns true if the old value of b j was 1.

ABA Detection
Signal detection is related to the fundamental ABA detection problem in asynchronous shared memory systems. In such systems, a process that observes the same value A in some shared object in two successive accesses cannot tell whether the value of the object remained unchanged between them. More formally, it cannot distinguish between an execution in which the shared object did not change and an execution in which the value of the object changed from A to some other value B and then back to A. Many shared memory algorithms have to deal with this problem.
A well-known example is the double-collect algorithm for performing an atomic scan of an array [1]: A process repeatedly performs a collect (reading all components of the array one by one) until the sequences of values read in two consecutive collects are the same. This algorithm is only correct (linearizable) if no ABAs occur, meaning that any two consecutive reads of the same array entry return the same value if and only if the value of the array entry was not changed between the two reads. This is because it can be shown that, provided no ABAs occur, the sequence returned by a scan must be the contents of the array at the end of its second last collect and the beginning of its last collect. However, in executions in which ABAs occur, this implementation might incorrectly return a sequence of values that was not the contents of the array at any point during the execution.
A standard approach to dealing with ABAs is tagging, as introduced by IBM [4], whereby a shared object gets augmented with a tag that changes with every write operation. If tags are never reused, the ABA problem can be avoided. From a theory perspective, this solution is unsatisfactory: If there is no bound on the length of executions, then unbounded sized objects are required to accommodate ever increasing tag values. Even though, in many practical scenarios, a system may never run out of tags, it is often desirable or even necessary to use an entire word for data. In such scenarios, the tag associated with a data word could be stored in a subsequent memory location and double-width atomic instructions could be used. However, these are not supported by most of today's mainstream architectures [7].
In some cases, it is possible to store the tag in an unrelated memory location [6], but this requires technically difficult algorithms and tedious correctness proofs. As a result, algorithm designers often deal with ABAs in an ad-hoc way. For example, a pair of handshaking bits between each pair of processes can be used to detect changes in the components of the array in a wait-free implementation of a snapshot object [1]. Such solutions are algorithm specific and require individual correctness proofs.
ABAs can also occur when using compare-and-swap (CAS) objects, which are provided by most existing multiprocessor systems and are much more powerful than read/write registers. Algorithms devised in theoretical research often use load-linked store-conditional (LL/SC) objects, which do not suffer from ABAs, and can easily replace CAS objects. Unfortunately, only a small number of multiprocessor systems provide LL/SC and they are weaker than the LL/SC specification used in theoretical research. Variants of LL/SC available in modern hardware restrict programmers severely in how the objects can be used [9], and "offer little or no help with preventing the ABA problem" [8].
To study the complexity of ABA detection, Aghazadeh and Woelfel [2] defined an ABA detecting register, which extends a read/write register with the ability to detect ABAs. It supports the operations DWrite(x), which changes the value of the object to x, and DRead(), which returns the current value of the object together with a Boolean flag. The flag is true if and only if the process has previously performed DRead() and, since its last preceding DRead(), some process performed DWrite(). The authors proved space lower bounds and time-space-tradeoffs for linearizable implementations of ABA detecting registers in shared memory systems with n processors that provide bounded atomic base objects, such as bounded read/write registers or bounded CAS objects. For example, if only bounded read/write registers are available as base objects, then at least n − 1 of them are needed to obtain an obstruction-free ABA detecting register. If bounded CAS objects are also available, then any implementation using m base objects has step-complexity (n/m). All the lower bound results in [2] are specific to the base objects provided by the system, and provide no insights for systems using different sets of base objects. But we conjecture that there is a large, general lower bound for the amount of information that needs to be stored in a system for processes to detect ABAs: Intuitively, the system state needs to keep track of whether the value of the object has changed since each process last accessed the object. This requires at least n bits of information. Hence, it seems believable that detecting ABAs in any system with arbitrarily powerful base objects requires at least n bits of information to be stored either in the base object or in the hardware implementing the base objects (for example, implementing LL/SC objects). Using the reasonable assumption that a single base object can store O(log n) bits of information, this would imply that (n/ log n) base objects are required for implementing a single ABA detecting object.
The signal detection problem is a restricted version of the problem of detecting ABAs in asynchronous shared memory systems, stripped down to the essentials necessary for determining the information theoretic requirements. Its definition is self-contained, and the problem can be studied without any background knowledge of shared memory systems. If n processes can detect ABAs in a standard asynchronous shared memory system with arbitrarily strong primitives, then they can also solve signal detection. A reader simply remembers the last value it read from the blackboard. When it reads the blackboard again, it returns true if it sees a different value or it detected an ABA; otherwise it returns false. Therefore, if signal detection requires that the blackboard has domain size at least m * , then log 2 m * is a lower bound for the number of bits needed for ABA detection.

Results
We conjecture that any solution to the signal detection problem requires the domain size, m, of the blackboard to be at least 2 n . Although we prove this conjecture when there are n ≤ 2 readers, a proof when n ≥ 3 has eluded us. This simply defined combinatorial problem does not seem to have a simple solution. Even a proof of a polynomial lower bound is surprisingly non-trivial. We show the following result in Section 6.

Theorem 1
In any algorithm for the signal detection problem, the blackboard has domain size at least n(n + 1)/2.
To obtain better understanding, we consider several restricted versions of the signal detection problem and prove tight upper and lower bounds for them.
First, we consider the b-read-bounded version of signal detection, where no reader takes more than b steps, but the signaller can take arbitrarily many steps. In this case, the second algorithm from Section 1.2 uses a domain of size 2bn + 1. We show how to improve this algorithm. Theorem 2 For b ≥ 2, the b-read-bounded signal detection problem can be solved using a blackboard with domain size (b − 1)n + 1.
Thus, the b-read-bounded problem is strictly easier than the unrestricted problem when b ≤ n/2 . For b = 2, we also prove that this algorithm is optimal.
Theorem 3 In any algorithm for the 2-read-bounded signal detection problem, the blackboard has domain size at least n + 1.
Next, we consider signal detection when the actions of the signaller do not depend on what steps the readers have taken. Signal detection with fixed signals is the special case where the signaller writes the same sequence of values to the blackboard in every execution. Note that the simple algorithm above with m = 2 n uses fixed signals.

Theorem 4
In any algorithm for the signal detection problem with fixed signals, the blackboard has domain size at least 2 n .
Then we consider the case of write oblivious processes. Here each process p is equipped with a fixed function f p : {0, . . . , m−1} → {0, . . . , m−1}. When taking a step it replaces the blackboard contents x with f p (x). Hence, what a process writes to the blackboard is independent of the internal state of the process. However, the return value of a reader's step may depend on its internal state. In the simple algorithm above, which uses m = 2 n blackboard values, processes are write oblivious. We prove that, when processes are write oblivious, no better algorithm exists.

Theorem 5
In any algorithm for the signal detection problem with write oblivious processes, the blackboard has domain size at least 2 n .
The signal detection problem with write oblivious processes is similar to determining the minimum size of a dictionary in a sequential system. A dictionary supports three operations, insert(x), query(x), and reset(), where x is a parameter chosen from a domain of size n. A call to query(x) returns true if there has been an insert(x) operation since the last reset() operation or since the beginning of the execution, if there has been no reset(). Otherwise, it returns false. A dictionary implemented using b(n) bits immediately yields a solution to the signal detection problem with oblivious processes as follows: A blackboard with m = 2 b(n) possible values is used to store the dictionary. When a signaller takes a step, it simulates a reset() operation on the dictionary stored on the blackboard. Similarly, when reader r i takes a step, it simulates query(i) followed by insert(i) on the dictionary and then returns the return value of its query operation. However, an arbitrary solution to the signal detection problem does not seem to yield an implementation of a dictionary. The difficulty is that the return value of a step by a reader r i can depend on the state of the reader and, thus, its entire past execution. In contrast, the result of a query(i) operation is only a function of the state of the dictionary. Hence, the n-bit information theory lower bound for implementing a dictionary cannot be used to obtain Theorem 5.
In the simple algorithm that uses m = 2 n blackboard values, the response each reader returns also does not depend on its internal state, but only on the contents of the blackboard. We call such processes response oblivious. The same lower bound holds for any algorithm with response oblivious processes, even if the algorithm supports only 2 steps by each reader.

Theorem 6
In any algorithm for 2-read-bounded signal detection with response oblivious processes, the blackboard has domain size at least 2 n . Theorem 2 implies that, for the unrestricted signal detection problem when there is only n = 1 reader, the domain size is at least 2 = 2 n . In Section 7, we investigate the unrestricted signal detection problem for the case of n = 2 readers. First, we prove a tight lower bound of 4 for the size of the blackboard domain. Then we present an algorithm for two readers, r 1 and r 2 , which uses a bounded number of blackboard values, and for which every reachable configuration C satisfies the following property: As long as only readers take steps starting in C, at most three different blackboard values are obtained. This observation indicates that a tight lower bound of m ≥ 2 n for n readers for the unrestricted signal detection problem may have to be fundamentally different from our lower bound proof for fixed signals. In that proof, we showed that one can reach a configuration, C, from which 2 n different blackboard values result from the 2 n schedules that are sub-sequences of (r 1 , . . . , r n ). In our third simple algorithm for n readers in Section 1.2, each execution that ends with the signaller taking a step results in a configuration with this property. But our two reader algorithm indicates that a lower bound proof for the unrestricted signal detection problem cannot rely on this property.

Preliminaries
We consider a deterministic, asynchronous system in which n + 1 processes, s, r 1 , . . . , r n communicate with one another using a single shared blackboard. Each time a process takes a step, it atomically reads the blackboard, may change the value of the blackboard based on its state and the value it read, and updates its state.
A configuration C consists of a value, v(C), for the blackboard and a state for each process. An execution is an alternating sequence of configurations and steps, starting and ending with a configuration, such that each step can be performed in the configuration that precedes it, resulting in the configuration that follows it. Configuration C is reachable if there is an execution starting with an initial configuration and ending with C. For any set of processes, P , a P -only execution is an execution in which only processes in P take steps in the execution. A solo execution is a P -only execution in which P contains only one process, i.e., all steps in the execution are by the same process.
A schedule is a sequence of processes (in which the same process can occur multiple times). A P -only schedule is a schedule in which only processes in P appear.
For any deterministic algorithm and for any configuration C, a schedule determines a unique execution starting from C in which the processes take steps in the order specified by the schedule. If α is a finite schedule, then Cα denotes the configuration at the end of this execution.
Two configurations, C and C , are indistinguishable to a set of processes, P , if v(C) = v(C ) and each process in P has the same state in C as it does in C . If C and C are indistinguishable to P and α is a finite P -only schedule, then the same sequence of steps is taken in the executions determined by α from C and C . Moreover, Cα and C α are indistinguishable to P . Given a set of readers, R, let R denote the schedule consisting of one occurrence of each reader in R, in order of their identifiers, and let M(R) denote the set {r i : i ≤ j for some r j ∈ R} of all readers whose identities are less than or equal to the largest identity of the readers in R. In particular, M(∅) = ∅.

Lemma 1 For every signal detection algorithm in which the domain size of the blackboard is finite, there is a reachable configuration
Proof Consider any signal detection algorithm. Assume that, for each reachable configuration C, there is a set of readers, T , such that v(CTsβ) = v(CT) for all (M(T ) ∪ {s})-only schedules β. We define an infinite sequence of reachable configurations as follows. Let C 0 be the initial configuration. Let j ≥ 1 and suppose that C j −1 is a reachable configuration. Let T j be a set of readers such that Since there is only a finite number of readers, there exists a set M such that {j ∈ Z + : M(T j ) = M} is infinite. Let M be the largest such set, let J = {j ∈ Z + : M(T j ) = M}, and let k * = min{k ≥ 1 : Hence, the domain size of the blackboard is infinite.

Read-Bounded Signal Detection
In the b-read-bounded signal detection problem, no reader takes more than b steps, but the signaller can take arbitrarily many steps.
Consider the following algorithm that solves this restricted problem for b = 2 using a blackboard with domain size m = n + 1: -The blackboard initially has value 0.
-Whenever s takes a step, it resets the blackboard contents to 0. -When r i takes its first step, it changes the blackboard contents to i if it reads 0; otherwise it leaves the blackboard unchanged. In either case, r i locally stores the value v i = 0 of the blackboard immediately after its first step and returns true. -When r i takes its second step, it returns false if it reads v i from the blackboard; otherwise it returns true. It does not change the value of the blackboard in either case.
Note that only the signaller changes the blackboard contents to 0 and readers only change the blackboard contents from 0. Thus, if the signaller does not take any steps between the two steps of reader r i , then the value of the blackboard remains v i during this interval and r i returns false.
If the signaller does take a step between the two steps of reader r i , then the blackboard is reset to 0. Consider the last step, S , by the signaller during this interval. If no reader takes its first step after S , but before the second step by r i , then r i will read 0 from the blackboard on its second step and return true. Otherwise, consider the first step after S in which a reader r j takes its first step. It will change the blackboard contents to j . Note that j = v i , since r j is the only reader that can change the blackboard contents to j and r j has not previously taken a step. In this case, r i will read j from the blackboard on its second step and return true.
A similar algorithm works for b-read-bounded signal detection for any larger b, but the size of the blackboard domain also increases.
Proof Consider the following algorithm for a signaller and n readers: The blackboard initially has value 0. -Whenever s takes a step, it resets the blackboard contents to 0. -Each reader r i has a local b-bounded counter c i , which is initially 0 and is incremented each time r i reads 0 from the blackboard. It also has a local variable v i in which it stores a non-zero value from the blackboard domain. It initially contains (i, 1). -When r i takes a step, it reads the blackboard. It will return false if the value read is the same as the value stored in v i . Otherwise, it returns true. If the value read is non-zero, it stores the result in v i and does not change the blackboard. If r i reads 0, it increments c i and, if c i < b, it changes the blackboard to (i, c i ) and also sets v i to the same value. When c i = b, reader r i can take no additional steps.
The counter c i is initially 0. Before changing the blackboard to (i, c i ), reader r i increments c i and checks that it is less than b. Hence, the blackboard only contains values in its domain. Note that only r i changes the blackboard to (i, j ) for 1 ≤ j ≤ b − 1. Thus, whenever the blackboard is changed to a nonzero value, its new value is a value that it never previously had.
Since the blackboard initially contains 0 and v i initially contains (i, 1), the first time r i takes a step, it will read a value different from v i and will return true.
At the end of each step by r i , the blackboard contains v i . Readers only change the blackboard when it contains 0. Thus, if the signaller does not take any steps between two steps of reader r i , then the value of the blackboard remains v i during this interval and r i returns false.
If the signaller does take a step between two consecutive steps of reader r i , then the blackboard is reset to 0. Then either the blackboard has value 0 when it is later read during the second of these steps, or some other process changed the blackboard to have a value it never previously had. In either case, its value is not equal to v i and r i returns true.
The counter c i is incremented each time r i reads 0 from the blackboard. Since it is initially 0 and otherwise is not incremented, it records the number of times that r i reads 0 from the blackboard. If r i takes at most b steps, then c i < b at the beginning of each of its steps, so r i does not stop prematurely.
Note that, if b ≤ n/2 , then (b − 1)n + 1 ≤ (n − 1)n/2 + 1 < n(n + 1)/2 for n ≥ 2. Hence, the domain size used in this algorithm is strictly less than the lower bound in Theorem 1 for any algorithm solving signal detection with an unbounded number of reads.
When b = 2, we can show that the domain size of this algorithm cannot be any smaller. The following simple lemma is the key to our lower bound for 2-read-bounded signal detection. Proof Suppose not. Then there are some such configurations D and E such that v(D) = v(E). Since r does not occur in the schedule αsβ, D and E are indistinguishable to r. Note that r must return false if it takes a step in configuration D, because s has not taken any steps since r last took a step. However, r must return true if it takes a step in configuration E, because s has taken a step since r last took a step. This is impossible, because D and E are indistinguishable to r.
We can now prove Theorem 3.

Theorem 3
In any algorithm for the 2-read-bounded signal detection problem, the blackboard has domain size at least n + 1.
Proof Let C 0 be the initial configuration. For 1 ≤ j ≤ n, let C j = C j −1 sr j and let C n+1 = C n s. Let α denote the empty schedule.
For 1 ≤ i < n, let β denote the schedule r i+1 · · · sr n s. By Lemma 2 with C = C i and r = r i , v(C i ) = v(E) for all configurations E in the execution starting from C i s determined by β. In particular, v(C i ) = v(C j ) for i + 1 ≤ j ≤ n + 1.
For i = n, let β denote the empty schedule. By Lemma 2 with C = C n and r = r n , v(C n ) = v(C n+1 ).

Fixed Signals
Suppose that, whenever the signaller takes a step, the resulting value of the blackboard does not depend on what its value was. In other words, for all k ≥ 1, there exists a value v k in the blackboard domain such that, immediately after the signaller's k'th step in any execution, the blackboard has value v k . For example, this is the case if the signaller always resets the contents of the blackboard to a fixed value, say 0. Using Lemma 1, we can show that, under this restriction, the blackboard has domain size at least 2 n .
∈ M(T )∪X ∪X ∪{s}, it follows that DTxsβ T X and DTxX are indistinguishable to x. Note that x must return false if it takes a step in configuration DTxX, because s has not taken any steps since x last took a step. However, x must return true if it takes a step in configuration DTxsβ T X , because s has taken a step since x last took a step. This is impossible, because these two configurations are indistinguishable to x.

Oblivious Processes
In this section, we consider processes whose actions are oblivious to their states, either when writing to the blackboard or responding to a read.
Recall that a process is write oblivious if what it writes to the blackboard in a step only depends on the value of the blackboard at the beginning of that step. We prove that the simple algorithm in Section 1.2 with domain size 2 n is optimal if both the signaller and the readers are write oblivious.
Let R = R be a different set of readers and let 0 < i < j be such that v(C 0 (sR ) i ) = v(C 0 (sR ) j ). Without loss of generality, suppose there is a reader To obtain a contradiction, assume that v(C 0 (sR) i ) = v(C 0 (sR ) i ). Since processes are write oblivious, it follows that Since r k takes no steps in (sR) j −i , configurations C 0 (sR ) i (sR) j −i and C 0 (sR ) i are indistinguishable to r k . The signaller has taken a step after r k 's last step in the execution determined by (sR ) i (sR) j −i starting from C 0 , so r k must return true if it takes a step in configuration C 0 (sR ) i (sR) j −i . However, the signaller has not taken a step after r k 's last step in the execution determined by (sR ) i starting from C 0 , so r k must return false if it takes a step in configuration C 0 (sR ) i . This is impossible, so v(C 0 (sR) i ) = v(C 0 (sR ) i ).
Since this holds for any two different sets of readers R and R , it follows that the blackboard domain has size at least 2 n .
We now consider response oblivious readers, whose responses only depend on the contents of the blackboard, but not their current state. However, processes can modify the blackboard based on both the blackboard contents and their current state. Even for the 2-read-bounded signal detection problem, at least 2 n different blackboard values are necessary when readers are response oblivious.

Theorem 6 In any algorithm for 2-read-bounded signal detection with response oblivious processes, the blackboard has domain size at least 2 n .
Proof Consider a set of readers R and let Q = {r 1 , . . . , r n } − R. Note that, in the execution from the initial configuration C 0 determined by schedule QsR, each reader takes exactly one step.
Let R = R be a different set of readers and let Q = {r 1 , . . . , r n } − R . Without loss of generality, suppose there is a reader r k ∈ R − R. In the execution from C 0 determined by schedule Q sR , reader r k takes a step after the signaller's last step, so r k must return false if it takes a step in configuration C 0 Q sR . However, in the execution from C 0 determined by schedule QsR, reader r k does not take a step after the signaller's last step, so r k must return true if it takes a step in configuration C 0 QsR. By response obliviousness, this implies that v(C 0 QsR) = v(C 0 Q sR ).
Since this holds for any two different sets of readers R and R , the blackboard domain has size at least 2 n . Proof Let C 0 be an arbitrary configuration. Suppose that, for each configuration C reachable from C 0 , there are two schedules, α and β, such that, for each

Lemma 4 Let D be a reachable configuration such that, for any schedules α and β, there exists an
Proof First consider the case when i = i . Without loss of generality, suppose that i < i . The state of reader r i+1 is the same in configurations Dδ(i, j ) and Dδ(i , j ). In configuration Dδ(i, j ), if r i+1 takes a step, it must return false, because s has not taken any steps since r i+1 last took a step. In configuration Dδ(i , j ), if r i+1 takes a step, it must return true, because s has taken i − i steps since r i+1 last took a step. If v(Dδ(i, j )) = v (Dδ(i , j )), then configurations Dδ(i, j ) and Dδ(i , j ) are indistinguishable to r i+1 , which is impossible. Thus v(Dδ(i, j )) = v (Dδ(i , j )). Now consider the case when i = i and j = j . Without loss of generality, suppose that j < j , so δ(i , j ) = δ(i, j )r j +1 · · · r j . Let α = δ(i, j )s and β = δ(i, j ). By assumption, there exists an {r 1 , . . . , r j , s}-only schedule γ such that v(Dδ(i, j )sγ ) = v (Dδ(i, j )). To obtain a contradiction, suppose that v(Dδ(i , j )) = v (Dδ(i, j )). Configurations Dδ(i , j ) and Dδ(i, j ) are indistinguishable to r 1 , . . . , r j , and s, since the signaller and these readers take no steps in r j +1 · · · r j . Then v (Dδ(i , j ) (Dδ(i , j )). Since r j +1 does not appear in sγ , configurations Dδ(i , j )sγ and Dδ(i , j ) are indistinguishable to r j +1 . Note that r j +1 must return false if it takes a step in configuration Dδ(i , j ), because s has not taken any steps since r j +1 last took a step. However, r j +1 must return true if it takes a step in configuration Dδ(i , j )sγ , because s has taken a step since r j +1 last took a step. This is impossible, because Dδ(i , j )sγ and Dδ(i , j ) are indistinguishable to r j +1 .
Using this lemma, we obtain Theorem 1.

Two Readers
In this section, we examine the special case when there are exactly two readers. The simple signal detection algorithm presented in Section 1.2 with one bit for each reader has a blackboard domain of size 2 2 = 4. First, we prove that this is optimal.
To prove our conjecture that 2 n blackboard values are necessary for n readers, one approach would be to show the existence of a configuration from which P -only executions lead to different blackboard configurations for different subsets P of the readers. When n = 2, we show that such a configuration does not always exist. In particular, in Section 7.2, we present an algorithm for two readers, r 1 and r 2 , with the property that, from every reachable configuration C, any reader-only execution leads to at most three different blackboard values. Thus, in order to show that four different blackboard values can be reached from some reachable configuration C, the signaller must also take steps, as is the case in our lower bound in Section 7.1. We conjecture that there are similar counterexample algorithms for n > 2.

A Tight Lower Bound
We begin with a straightforward observation about when two configurations have the same blackboard value.

Observation 7
For any configuration C and any schedule α such that v(C) = v(Cα), if β is a schedule consisting of processes that don't take steps in α, then v(Cβ) = v(Cαβ).
The proof follows from the fact that configurations C and Cα are indistinguishable to the processes that take steps in β.
In some situations, it is also easy to prove that two configurations have different blackboard values.

Lemma 5
If C is a reachable configuration, ρ is a schedule that contains reader r but not the signaller s, σ is a schedule that contains s but not r, and γ is a schedule that contains neither s nor r, then v(Cρσ ) = v(Cργ ).
Proof If reader r takes a step in configuration Cρσ , it must return true, because r's previous step occurred during ρ and s took a step during σ . However, if r takes a step in configuration Cργ , it must return false, because s takes no steps during ργ .
Since r takes no steps in σ or γ , the state of r in configurations Cρσ and Cργ must be the same. Now suppose that v(Cρσ ) = v(Cργ ). Then configurations Cρσ and Cργ are indistinguishable to r, so it must return the same value if it takes a step in Cρσ and Cργ . This is a contradiction.

Corollary 1
If C is a reachable configuration, ρ is a schedule that contains reader r but not the signaller s, and σ is a schedule that contains s but not r, then v(Cρσ ) = v(Cρ).
These results will be used repeatedly to obtain a tight lower bound when there are two readers.

Theorem 8 Any algorithm for signal detection among n = 2 readers requires blackboard domain size at least 4.
Proof Consider any algorithm, let C 0 be its initial configuration, and let D = C 0 r 1 r 2 . Since the blackboard domain size is finite, there are two integers k, ≥ 1, such that v(Ds k ) = v(Ds k+ ). We first show that v(Ds k r 1 ) = v(Ds k ) = v(Ds k r 2 ). To obtain a contradiction, suppose that v(Ds k ) = v(Ds k r i ) for some i ∈ {1, 2}. Then v(Ds k+ ) = v(Ds k r i s ) by Observation 7 with C = Ds k , α = r i and β = s . Hence v(Ds k r i ) = v(Ds k ) = v(Ds k+ ) = v(Ds k r i s ). But v(Ds k r i s ) = v(Ds k r i ) by Corollary 1 with C = Ds k , r = r i , ρ = r i , and σ = s . This is a contradiction. Therefore v(Ds k ) = v(Ds k r 1 ), v(Ds k r 2 ).
Applying Corollary 1 with C = C 0 , r = r 2 , ρ = r 1 r 2 , and σ = s k r 1 s gives v(Ds k r 1 s) = v(C 0 r 1 r 2 s k r 1 s) = v(C 0 r 1 r 2 ) = v(D). Applying Corollary 1 with C = Ds k , r = r 1 , ρ = r 1 , and σ = s gives v(Ds k r 1 s) = v(Ds k r 1 ). If v(Ds k r 1 s) = v(Ds k ), then v(D), v(Ds k ), v(Ds k r 1 ), and v(Ds k r 1 s) are all distinct, so suppose that v(Ds k r 1 s) = v(Ds k ). By Observation 7 with C = Ds k , α = r 1 s and β = r 2 , it follows that v(Ds k r 1 sr 2 ) = v(Ds k r 2 ), so v(Ds k r 1 sr 2 ) = v(Ds k r 1 ). Applying Corollary 1 with C = Ds k , r = r 1 , ρ = r 1 , and σ = sr 2 gives v(Ds k r 1 sr 2 ) = v(Ds k r 1 ). This is a contradiction. Therefore, either v(Ds k r 1 ) = v(Ds k r 2 ) or v(Ds k r 1 s) = v(Ds k ) and, hence, the domain size is at least 4.

An Algorithm for Two Readers Based on a Bounded Sequential Timestamp System
A bounded sequential timestamp system for a set of processes consists of a finite set of labels, L, and a dominance relation ≺ between every two different labels, i.e. if 1 and 2 are two different labels then exactly one of 1 ≺ 2 and 2 ≺ 1 is true. At every configuration, each process has a different label. There is one atomic operation, getTimestamp(), which may change the label of the process that called it and which ensures that its label dominates the labels of all other processes. A solution to the signal detection problem can be obtained from a bounded sequential timestamp system by using the blackboard to store the timestamps of the signaller and each reader. When either a reader or the signaller takes a step, it performs getTimestamp() and updates its timestamp stored on the blackboard, if it has changed. A reader returns true if and only if its timestamp was smaller (with respect to ≺) than the timestamp of the signaller before it was updated. The domain size of the blackboard is |L| n+1 in this algorithm, where n is the number of readers. Note that this algorithm provides a lot more information than is required by the signal detection problem. Specifically, each reader can also determine which of the other readers have taken steps since it last took a step.
Israeli and Li [5] gave a construction of a bounded sequential timestamp system for n + 1 processes with a label set of size 3 n and proved that, for any > 0, there exists a bounded sequential timestamp system for n + 1 processes whose label set has size (2 + ) n+1 , for n sufficiently large. They also proved a lower bound of 2 n+1 − 1 for the size of the label set of any bounded sequential timestamp system for n + 1 processes.
The algorithm below is based on the bounded timestamp system of Israeli and Li for three processes with 3 2 = 9 labels, but it stores only two labels on the blackboard: the signaller's label and the larger (with respect to ≺) of the two readers' labels. This results in a blackboard with domain size 81, which is much larger than the number of labels used in the optimal algorithm. However, this algorithm has the property that, starting from any reachable configuration, at most three different blackboard configurations can be reached by executions in which only readers take steps.
Note that, for any two distinct labels a, b ∈ B 2 , either a ≺ b or b ≺ a. Israeli and Li view the set of all labels with the same first component as being the labels of a separate copy of a bounded sequential timestamp for 2 processes (which uses labels in B).
The algorithm maintains the following label invariants: In each reachable configuration, each process p ∈ {s, r 0 , r 1 } has a different label (p) = ( 1 (p), 0 (p)) ∈ B 2 . In addition, each reader has a label from a different copy (i.e. 1 (r 0 ) = 1 (r 1 )) and the signaller has a label from one of these copies (i.e. 1 (s) ∈ { 1 (r 0 ), 1 (r 1 )}). In the initial configuration, In each reachable configuration, the readers have different labels, so one of the reader's labels dominates the other reader's label. We call the reader with this label the dominating reader.
( B ) In other words, the signaller's label as well as the dominating reader's label are stored on the blackboard. Thus, initially, the blackboard contains ((1,1),(1,0)). When a process takes a step, it applies the rules described below, which might change its label. We prove that the label invariants remain satisfied. If its label is changed, the process updates the blackboard so that (B) remains true. We will show that, in addition, immediately after each step by s, its label (s) dominates both (r 0 ) and (r 1 ) and immediately after each step by a reader r i , its label (r i ) dominates (s).
(S) Therefore, a reader can easily provide the proper response when it takes a step: If a reader's label dominates (s) at the beginning of its step, then the reader returns false.
By (S), after a reader has taken a step, its new label dominates * (s), so its label does not change when it takes additional steps in α. When a reader takes a step, either it does not change the blackboard, or it replaces the second component of the blackboard with its new label. Thus, for all α ∈ {r 0 , r 1 } * , v(Cα) = ( * (s), ), where ∈ * (r d ), (r d ), (r 1−d ) .

Discussion
This paper introduces the signal detection problem, gives some simple algorithms for solving it, proves that domain size at least n(n + 1)/2 is necessary, and proves that domain size 2 n is necessary and sufficient for three restricted versions of the problem: when the processes are write oblivious, when the readers are response oblivious, or when the signaller writes a fixed sequence of values to the blackboard. We conjecture that domain size must be at least 2 n for the unrestricted version of the problem. It would also be interesting to prove this bound for two other restricted versions of the problem: when only the signaller is write oblivious or only the readers are write oblivious.
We also consider another restricted version of the problem, where each reader takes no more than b ≥ 2 steps. We give an algorithm with domain size (b − 1)n + 1 and prove this is optimal when b = 2. It remains open whether it is optimal when b > 2. If the signaller takes no more that B steps, then one of our simple algorithms uses a domain of size B + 1. It is unclear whether it is possible to have an algorithm for this restricted version that has a smaller domain.