EXPSPACE-Completeness of the Logics K4xS5 and S4xS5 and the Logic of Subset Spaces, Part 2: EXPSPACE-Hardness
Peter Hertling, Gisela Krommes

TL;DR
This paper establishes that the satisfiability problems for the product logics K4xS5, S4xS5, and the logic of subset spaces are all EXPSPACE-complete, refining previous lower bounds to match known upper bounds.
Contribution
The paper proves that these three logic satisfiability problems are EXPSPACE-hard, completing their complexity classification as EXPSPACE-complete.
Findings
All three problems are EXPSPACE-hard under logspace reduction.
These problems are in EXPSPACE, thus are EXPSPACE-complete.
The results improve previous lower bounds from NEXPTIME and PSPACE.
Abstract
It is known that the satisfiability problems of the product logics K4xS5 and S4xS5 are NEXPTIME-hard and that the satisfiability problem of the logic SSL of subset spaces is PSPACE-hard. We improve these lower bounds for the complexity of these problems by showing that all three problems are EXPSPACE-hard under logspace reduction. In another paper we show that these problems are in ESPACE. This shows that all three problems are EXPSPACE-complete.
| For | the following | is an abbreviation |
| expression | of the following formula | |
| , | ||
| , | ||
| , |
| For | the following | is an abbreviation |
| expression | of the following formula | |
| , | ||
| , | ||
| , |
| For | the following | is an abbreviation |
|---|---|---|
| expression | of the following formula | |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsRough Sets and Fuzzy Logic · Advanced Algebra and Logic
0.1pt
-Completeness of the Logics and and the Logic of Subset Spaces,
Part 2: -Hardness
Peter Hertling and Gisela Krommes
Fakultät für Informatik
Universität der Bundeswehr München
85577 Neubiberg, Germany
Email: [email protected], [email protected]
Abstract
It is known that the satisfiability problems of the product logics and are -hard and that the satisfiability problem of the logic of subset spaces is -hard. We improve these lower bounds for the complexity of these problems by showing that all three problems are -hard under logspace reduction. In another paper we show that these problems are in . This shows that all three problems are -complete.
Keywords: bimodal product logics, subset space logic, satisfiability problem, complexity theory, -completeness
1 Introduction
In this article we are concerned with the complexity of the bimodal product logics and and with the subset space logic , a bimodal logic as well. To the best of our knowledge, the complexity of , of , and of were open problems. The main results of this article can be summarized in the following theorem.
Theorem 1.1**.**
The logics , , and are -hard under logspace reduction.
Actually, we are considering the satisfiability problems of these three logics, and we are going to show that the satisfiability problems of these logics are -hard. Of course, this assertion is equivalent to the theorem above because is closed under complements. This paper is a continuation of the paper [8], in which we show that these problems are in . Both results together imply the following theorem.
Theorem 1.2**.**
The logics , , and are -complete under logspace reduction.
Let us recap the history of the questions and results concerning the complexity of these problems. The following text is almost identical with a corresponding text in [8]. In [15, Question 5.3(i)] Marx posed the question what the complexity of the bimodal logic is. This question is restated and extended to the logic in [13, Problem 6.67, Page 334]. There it is also stated that “M. Marx conjectures that these logics are also EXPSPACE-complete”. That it is desirable to know the complexity of and similar logics is mentioned by Parikh, Moss, and Steinsvold in [17, Page 30] and by Heinemann in [6, Page 153] and in [7, Page 513].
For the complexity of the satisfiability problems of the logics and the best upper bound known is [13, Theorem 5.28], that is, they can be solved by a nondeterministic Turing machine working in doubly exponential time. The best lower bound known for the satisfiability problems of these two logics is -hardness [13, Theorem 5.42]; compare also [13, Table 6.3, Page 340]. It is known as well that for any -satisfiable formula there exists a cross axiom model of at most doubly exponential size [5, Section 2.3]. This shows that the complexity of the satisfiability problem of is in as well. The best lower bound known for is -hardness [12, 11].
In this paper we improve the lower bounds -hardness resp. -hardness for the satisfiability problems of these three logics to -hardness. In [8] we show a matching upper bound by showing that these problems are in . This shows that they are -complete. Thus, Marx’s conjecture for and stated above is true.
The main part of the paper is the -hardness proof of the satisfiability problem of the logic in Section 4. In order to show this, we shall use Alternating Turing Machines [2]. In this respect, we follow the example of Lange and Lutz [14] who used Alternating Turing Machines in order to establish a sharp lower bound for the complexity of a certain dynamic logic. As any language in is recognized by an Alternating Turing Machine (ATM) working in exponential time, it is sufficient to show that any language recognized by an Alternating Turing Machine working in exponential time can be reduced in logarithmic space to the satisfiability problem of . We will present such a reduction in Section 4. For this purpose we will construct an formula that describes the computation of an exponential time bounded Alternating Turing Machine. In Section 3 we shall introduce Alternating Turing Machines. In that section we will also introduce certain formulas that we shall call ‘shared variables’ that we use in order to overcome the problem that ordinary propositional variables are persistent (see Subsection 3.1) in . Their usage is illustrated by an implementation of a binary counter in . The -hardness of the satisfiability problems of and of is then shown by reductions. In Section 5 we show that the satisfiability problem of can be reduced in logarithmic space to the satisfiability problem of . And in Section 6 we show that the satisfiability problem of can be reduced in logarithmic space to the satisfiability problem of . These reductions are much easier than the reduction of a language recognized by an Alternating Turing Machine working in exponential time to the satisfiability problem of presented in Section 4.
As there may be some interest in a direct proof of the -hardness of the satisfiability problem of the logic , in an appendix we present such a proof by presenting a direct logspace reduction of any language recognized by an Alternating Turing Machine working in exponential time to the satisfiability problem of . Although the overall structure of this proof is rather similar to the structure of the reduction of ATMs to the satisfiability problem of , there are some important differences. For illustration purposes, we also present an implementation of a binary counter in in the appendix.
2 Notations and Preliminaries
This paper is a continuation of [8]. We are going to use the same terminology as in that paper. In order not to repeat the definition of a lot of basic notions we would like to ask the reader to consult the first sections of [8] for the needed basic notions from complexity (see the end of the introduction of [8]), for the syntax of bimodal formulas (Subsection 2.1 in [8]), for - and -product models and -commutator models as well as for cross axiom models (Subsection 2.2 in [8]), for the notions of -satisfiability of bimodal formulas, for (Subsection 2.3 in [8]), and for some basic notions and observations concerning transitive relations and equivalence relations, in particular for the definition of the relation induced by a relation on the equivalence classes with respect to an equivalence relation (Subsection 3.1 in [8]).
As in [8] the -equivalence class of a point in an -commutator model, for , or a cross axiom model will be called the cloud of that point. Finally, for reducing one language to another one we use the logarithmic space bounded reduction as in [16].
3 Preparations for the Reduction of Alternating Turing Machines to
A string is an element of the language recognized by an Alternating Turing Machine iff there exists a so-called accepting tree of on input . In such a tree each node represents a configuration of . Our idea is to construct a formula depending on such that the models of this formula have the tree structure of an accepting tree of on input , where now the nodes of the tree are clouds such that the formulas satisfied in some cloud describe a configuration of . In this way the induced relation between the clouds serves as a simple temporal operator.
In the following subsection we describe how information is stored and transmitted in a model of such a formula. In particular we introduce certain formulas that we call shared variables that can transmit information in the -direction and by which we can overcome the problem in the logic that all propositional variables are persistent. As a first application of this, in Subsection 3.2 we demonstrate how one can implement a binary counter in the logic . In Subsection 3.3 we recall the definition of Alternating Turing Machines.
3.1 Shared Variables
We have to make sure that various kinds of information are stored in a suitable way in any model of the fomula. We also need to copy and transmit various bits of information, both in the -direction (we always depict this as the vertical direction) as well as in the -direction (we always depict this as the horizontal direction). This will be done by two kinds of formulas.
- •
On the one hand, we need formulas that have the same truth value in the vertical () direction but can change their truth values in the horizontal () direction. In the case of the logic , for this purpose we can simply use propositional variables as they are persistent anyway.
- •
On the other hand, we need formulas that have the same truth value in the horizontal () direction but can change their truth values in the vertical () direction. Such formulas will be called shared variables and will be defined now.
Definition 3.1** (Shared Variables).**
For let be special propositional variables, and let be another special propositional variable , different from all . The shared variables are defined as follows:
[TABLE]
Note that
[TABLE]
See Figure 1 for a model of a single shared variable (in the figure we have omitted the index ) in changing its value from to [math] and back from [math] to . In this model the information is stored at the white points which we call information points. The gray points are auxiliary points that ensure that we obtain a model for the shared variables. Note that the information points differ from the auxiliary points in the value of the propositional variable , which is true at all information points, independent of the value of stored there, and false at all auxiliary points. Thus, the value of the propositional variable allows us to distinguish between the information points and the auxiliary points.
Although the shared variables are formulas we are going to use them as if they were variables. The propositional variables and the propositional variable that are used in their definition will not be used in any other way. As a first example of the application of shared variables, in the following section we demonstrate how, using shared variables, one can implement -bit binary counters in . Binary counters are going to play a key role in the simulation of Alternating Turing Machines in .
3.2 Binary Counters in
Fix some natural number . We wish to implement in a binary -bit counter that counts from [math] to . That means, we wish to construct an -satisfiable formula with the property that any model of it contains a sequence of pairwise distinct points such that, for each , at the point the number is stored in binary form in a certain way. To describe the implementation of the counter we first introduce some notation.
- •
For a natural number , we define the finite set by
[TABLE]
that is, is the set of the positions of ones in the binary representation of (where the positions are counted from the right starting with [math]).
- •
We will also need the bits of the binary representation of , for . They are defined by
[TABLE]
- •
For natural numbers with and the binary representation of length of is the string
[TABLE]
Table 1 lists expressions that we use as abbreviations of formulas.
The idea of the construction is as follows.
- •
We store the counter values in a vector of shared variables. To this end we embed the sequence of points in a sequence of clouds such that the cloud contains the point and such that the vector of shared variables satisfied at (and hence at all points in ) encodes the number .
- •
Let be the number encoded by . If contains no [math] then has reached its highest posible value, the number . Otherwise let be the position of the rightmost [math]. We determine the position with the aid of the formula . In order to increment the counter we have to keep all at positions unchanged and to switch all at positions . We do this in two steps:
First me make an -step from the point to a point where we store the number in a vector of usual propositional variables by demanding that
[TABLE] 2. 2.
Then we make a -step from the point to a point in the cloud and demand that
[TABLE]
Note that in the value of is copied from to its -successor since in propositional variables are persistent.
Altogether we demand that for the number
[TABLE]
- •
Additionally we need a formula to ensure that the starting value is [math], that is we demand
[TABLE]
We now define the counter formula, for . Remember that is a vector of formulas where is defined by ; compare Definition 3.1.
[TABLE]
Proposition 3.2**.**
For all , the formula is -satisfiable. 2. 2.
For all , for every cross axiom model of and for every point in this model with there exist a sequence of points and a sequence of points such that
- •
for , ,
- •
for , and and .
Proof.
For the following let us fix some .
We construct a cross axiom model with a point satisfying as follows; see Figure 2.
We define
[TABLE]
where
[TABLE]
As the relation is supposed to be an equivalence relation we can define it by defining the -equivalence classes. These are the sets
[TABLE]
for all , and
[TABLE]
We define the relation by:
[TABLE]
It is straightforward to check that is reflexive and transitive. The cross property is satisfied as well. Thus, is a cross axiom frame. We define the valuation by
[TABLE]
for .
It is obvious that all of the propositional variables and are persistent. Thus, is a cross axiom model. We claim . Before we show this we show the following claim, for all and for all ,
[TABLE]
In order to show this it is sufficient to show for all , for all , and for all
[TABLE]
Let us fix some . Note that, for all , we have , hence
[TABLE]
Furthermore, for all . Since for all and we have we obtain for all and . Hence,
[TABLE]
This shows that, for any , the shared variable is true in the cloud if, and only if, there exists some with . As for all and any is -equivalent to some , we have , for all . Actually, for we even have as does not have any -successors besides itself. Thus, the shared variable is true in the cloud if, and only if, there exists some with . As the only elements are the elements with and as , we obtain for and for ,
[TABLE]
We have shown the claim (3.1).
We claim that . Indeed, it is obvious that
[TABLE]
Due to and (3.1) we obtain
[TABLE]
Let us assume that for some and some we have . It is sufficient to show that
[TABLE]
From we conclude , hence, there exist with and with . Thus, . Then we have . Now, implies and . Note that this implies . We have , and since we have
[TABLE]
It is sufficient to show
[TABLE]
and
[TABLE]
By definition of we have for all
[TABLE]
and hence on the one hand . Due to (3.1), we have on the other hand . This proves the first claim. For the second claim we observe that by definition of also . Since we also have by (3.1) that and hence .
Thus, we have constructed a cross axiom model for . 2. 2.
Suppose there is a cross axiom model of the formula and some point with . We show by induction that the claimed sequences of points and with the claimed properties and additionally with , for , and with , for , exist. In addition, we show that there exist points with and , for . Note that the sequences and are supposed to form a “staircase” as in Figure 3.
By definition, . By induction hypothesis, let us assume that for some with there exist and with
[TABLE]
with
[TABLE]
for , and with
[TABLE]
for , and that there are with and , for . Since , the set is nonempty. With we have
[TABLE]
Due to as well as this implies
[TABLE]
Thus, there must exist points and satisfying as well as ,
[TABLE]
and
[TABLE]
We have to show
[TABLE]
and
[TABLE]
Due to the fact that is an element of the same cloud as , and has the same value in all points in a cloud we obtain
[TABLE]
Together with
[TABLE]
this implies
[TABLE]
(the values of the leading bits of are copied to the leading bits and the other bits are defined explicitly by so that the binary value of is ). From and the fact that in propositional variables are persistent we obtain . Using we obtain . Finally, the cross property applied to and implies that there exists a point with and . Using additionally and we obtain and . This ends the proof of the second assertion. ∎
3.3 Alternating Turing Machines
The concept of an Alternating Turing Machine (ATM) was set forth by Chandra and Stockmeyer [3] and independently by Kozen [10] in 1976, with a joint journal publication in 1981 [2]. We are going to use a variant of ATMs with a single tape as in [14]. This is justified by the fact that one-tape ATMs can efficiently simulate multi-tape ATMs; see [3, Proposition 3.4]. For an even more efficient simulation of multi-tape ATMs by one-tape ATMs see [18].
An ATM is a nondeterministic Turing machine where some configurations are “or” configurations that accept if at least one of their successors does, while other configurations are “and” configurations that accept if all of their successors accept. The mode of each configuration (“and” vs. “or”) is determined by the state of the configuration. There are two special states called and . All other states are either universal states or existential states.
For a relation and any we write .
Definition 3.3**.**
An alternating Turing Machine is a quintuple
[TABLE]
where
- •
, the set of states of , is the disjoint union of the following four sets:
- –
, a finite set, its elements are called existential states,
- –
, a finite set, its elements are called universal states,
- –
, a one-element set, its element is called accepting state,
- –
, a one-element set, its element is called rejecting state,
- •
is a nonempty finite set, called the input alphabet,
- •
is a finite set containing a blank symbol , we call the tape alphabet,
- •
is the initial state,
- •
is the transition relation,
and where satisfies the condition
[TABLE]
A configuration of an alternating Turing machine is an element of
[TABLE]
where is the current state of the finite control, is the current position of the tape head (that is, the number of the cell on which the tape head is positioned), and the function represents the current tape content and satisfies the condition for all but finitely many . A configuration represents an instantaneous description of at some point in a computation. The initial configuration of on input with for is
[TABLE]
where is defined by
[TABLE]
That means that at the start of the computation the tape head is positioned on cell no. [math], and the input string is contained in the cells with the numbers to while all other cells contain the blank .
For two configurations and we write and say is a successor of , if, according to the transition relation , the configuration can be reached from the configuration in one step (this is defined in the usual way). The reflexive-transitive closure of is denoted . A computation or computation path of on input is a sequence , where . In the following we will only consider ATMs such that there exists a function such that for any and any possible input string , any computation path of on input has length at most , that is, if is a computation path of on input then . In this case we say that works in time . For such machines we can define the language recognized by as follows: for
[TABLE]
An accepting tree of on input is a finite rooted and labeled tree each of whose nodes is labeled with a configuration of such that the following five properties hold true:
- I.
The root of the tree is labeled with the initial configuration of on input . 2. II.
If is the label of an internal node of the tree then the labels of its successors are configurations satisfying (note that this implies that the state of is an element of ). 3. III
If is the label of an internal node of the tree then the labels of its successors are pairwise different configurations. 4. IV.
If is the label of an internal node of the tree and the state of is an element of then for every configuration with there exists a successor node labeled with . 5. V.
If is the label of a leaf of the tree then the state of is equal to .
Note that these conditions imply that, if is the label of a node of the tree and the state of is an element of , then this node is an internal node, hence, it has a successor. Let the height of a rooted tree be the length of the longest path in the tree. It is clear that if there is an accepting tree of on input then its height is at most .
The time complexity class is the class of all languages such that there exist an alternating Turing machine with and a polynomial such that works in time . We will make use of the fundamental fact [3, Corollary 3.6].
For technical purposes we will also need the following notion. A partial tree of on input is a finite rooted and labeled tree each of whose nodes is labeled with a configuration of that satisfies the same four properties I, II, III, and IV as an accepting tree of on input and instead of the property V the following weaker property:
- .
If is the label of a leaf of the tree then the state of is different from .
It is clear that any accepting tree of on input is a partial tree of on input . Usually we will write a partial tree of on input as a triple where is the set of nodes of the tree , where is the set of edges of the tree (note that the root of the tree is uniquely determined by and : it is the only node that does not have an incoming edge), and where is the labeling of the tree. Let be the reflexive-transitive closure of . We will often need the following data associated with any computation node :
- •
The time of . This is the number of edges of the unique path in from to . Note that .
- •
The configuration of . This is the configuration with which the node is labeled.
- •
The state of the configuration .
- •
The position of the tape head in the configuration .
- •
The symbol in the cell in the configuration .
- •
The predecessor of in the tree , for .
- •
The symbol that has been written in the computation step that lead to this node , for . Note that this is the symbol now contained in the cell on which the tape head was positioned in the previous configuration.
4 Reduction of Alternating Turing Machines Working in Exponential Time to
In this section we prove the following theorem.
Theorem 4.1**.**
The satisfiability problem of is -hard under logarithmic space reduction.
As explained before, we are going to show this by showing that any language recognized by an Alternating Turing Machine working in exponential time can be reduced in logarithmic space to the satisfiability problem of .
In the following subsection we will first describe the idea of the reduction and then define the reduction function in detail. In Subsection 4.2 we will show that it can be computed in logarithmic space. In the final two subsections we are going to show that it is corrrect. First we show that in case the formula is -satisfiable by explicitly constructing a cross axiom model for . In the last section we show that if is -satisfiable then is an element of .
4.1 Construction of the Formula
Let be an arbitrary language over some alphabet , that is, . We are going to show that there is a logspace computable function mapping strings to strings such that, for any ,
- •
is a bimodal formula and
- •
is -satisfiable if, and only if, .
Once we have shown this, we have shown the result. In order to define this desired reduction function , we are going to make use of an Alternating Turing Machine for . Since , there exist an Alternating Turing Machine and a univariate polynomial such that accepts , that is, , and such that the time used by on arbitrary input of length is bounded by . We can assume without loss of generality , , that the coefficients of the polynomial are natural numbers and that, for all , we have and . In the following, whenever we have fixed some , we set
[TABLE]
Let us consider an input word of length , for some , and let us sketch the main idea of the construction of the formula . The formula will describe the possible computations of on input in the following sense: any cross axiom model of will essentially contain an accepting tree of on input , and if then there exists an accepting tree of on input and one can turn this into a cross axiom model of . In such a model, any node in an accepting tree of on input will be modeled by a cloud (that is, by an -equivalence class) in which certain shared variables (we use the notion “shared variables” in the same sense as in Subsection 3.1) will have values that describe the data of the computation node that are important in this computation step. Which data are these? First of all, we need the time of the computation node. We assume that the computation starts with the initial configuration of on input at time [math]. Since the ATM needs at most time steps, we can store the time of each computation node in a binary counter counting from [math] to . Since during each time step at most one additional cell either to the right or to the left of the previous cell can be visited, we can describe any configuration reachable during a computation of on input by the following data:
- •
the current content of the tape, which is a string in ,
- •
the current tape head position, which is a number in .
We assume that in the initial configuration on input the tape content is (remember that we use for the blank symbol) and that the tape head scans the blank to the left of the first symbol of , that is, the position of the tape head is . If a cloud in a cross axiom model of describes a computation node of on input then in this cloud the following shared variables will have the following values:
- •
a vector giving in binary the current time of the computation,
- •
a vector giving in binary the current position of the tape head,
- •
a vector giving in unary the current state of the computation (here “unary” means: exactly one of the shared variables will be true, namely the one with being the current state),
- •
a vector giving in unary the symbol that has just been written into the cell that has just been left, unless the cloud corresponds to the first node in the computation tree — in that case the value of this vector is irrelevant (here “unary” means: exactly one of the variables will be true, namely the one with being the symbol that has just been written),
- •
a vector giving in unary the symbol in the current cell (here “unary” means: exactly one of the shared variables will be true, namely the one with being the symbol in the current cell).
The formula has to ensure that for any possible computation step in an accepting tree starting from such a computation node there exists a cloud describing the corresponding successor node in the accepting tree. In this new cloud, the value of the counter for the time has to be incremented. This can be done by the technique described in Subsection 3.2 for implementing a binary counter. In parallel, we have to make sure that in this new cloud also the vectors , , , and are set to the right values. For the vectors , , and these values can be computed using the corresponding element of the transition relation of the ATM. For example, has to be decremented by one if the tape head moves to the left, and it has to be incremented by one if the tape head moves to the right. Also the new state (to be stored in ) and the symbol written into the cell that has just been left (to be stored in ) are determined by the data of the previous computation node and by the corresponding element of the transition relation .
But the vector is supposed to describe the symbol in the current cell. This symbol is not determined by the current computation step but has either been written the last time when this cell has been visited during this computation or, when this cell has never been visited before, the symbol in this cell is still the one that was contained in this cell before the computation started. How can one ensure that is set to the right value? If the current cell has never been visited before, we have to make sure that the value is set to the correct value describing the inital content of this cell. Otherwise, we make use of the cross property. The point in the new cloud whose existence is enforced by the formula must have a cross point in any cloud corresponding to any previous computation node. The idea is that one of these cross points picks up the right value in the right cloud. We are going to make sure that the cloud is identified that corresponds to the configuration after the previous visit of the same cell during the computation. Then in the cloud corresponding to this configuration the value of will tell us the symbol that has been written into the current cell during the previous visit. In order to identify the correct cloud of the step after the previous visit of the current cell and to copy the value of the symbol, the formula will ensure that any cloud describing a computation node will contain a point in which the following (persistent!) propositional variables have the following values:
- •
a vector giving in binary the current time of the computation,
- •
a vector giving in binary the current position of the tape head, that is the position of the current cell,
- •
a vector giving in unary the symbol in the current cell, (here “unary” means: exactly one of the variables will be true, namely the one with being the symbol in the current cell).
- •
a vector giving in binary the time one step after the previous visit of the cell, if it has been visited before (“time-apv” stands for “time after previous visit”); otherwise this vector will have the binary value [math].
Now we come to the formal definition of the formula . The formula will have the following structure:
[TABLE]
The formula will contain the following propositional variables:
[TABLE]
For and natural numbers we define
[TABLE]
These formulas are the shared variables we talked about above. We are now going to define the subformulas of . We will use the abbreviations introduced above, in Table 1, and in Table 2.
The models of the formula will contain certain “information” points that will realize an accepting tree of on input if, and only if, . Besides these information points there will also be other, “auxiliary”, points (and an -equivalence class not containing any information points) whose sole purpose is to make the mechanism of shared variables work. In several formulas we need to distinguish between the information points and the other, auxiliary, points. It turns out that this can be done simply by the truth value of the propositional variable .
The following formula makes sure that in each of the vectors of shared variables that describe in a unary way the current state respectively the written symbol respectively the current symbol, exactly one shared variable is true:
[TABLE]
The vector will satisfy the same uniqueness condition automatically.
The following formula ensures that the variables in the cloud corresponding to the first node in a computation tree get the correct values. The computation starts at time [math] with the tape head at position and in the state and with the blank symbol in the current cell.
[TABLE]
The following formula ensures that the vector stores the time after the previous visit of the same cell, if it has been visited before. If it has never been visited before, this vector gets the binary value [math].
[TABLE]
We explain this formula. The time after the previous visit of the current cell is certainly at most as large as the current time . When during the computation at an earlier time a cell has been visited that is different from the current one then one plus the time of that visit is certainly not the time after the previous visit of the current cell. When during the computation at an earlier time the current cell has been visited then the time of that visit is a strict lower bound for the time after the previous visit of the current cell. Together these conditions ensure that gets the correct value.
The following formula ensures that the vector stores (in unary form) the symbol in the current cell.
[TABLE]
We explain this formula. If the current cell has never before been visited (this is the case iff the vector has the binary value [math]) then the vector is forced to store in unary format the initial symbol in the current cell. This is either a symbol of the input string or the blank . If the current cell has been visited before (this is the case iff the vector has a binary value strictly greater than [math]) then in the cloud corresponding to the time stored in the vector describes the symbol that has been written into the current cell during the previous visit. Therefore, this value is copied into the vector .
Next, we wish to define the formula that describes the computation steps. We have to distinguish between the two cases whether the tape head is going to move to the left or to the right. If in a computation step the symbol is written into the current cell, if the tape head moves to the right, and if the new state after this step is the state , then the following formula guarantees the existence of a point and its cloud with suitable values in the shared variables and in the persistent propositional variables.
[TABLE]
We explain this formula. The procedure is quite similar to the one of the formula in Subsection 3.2 for a binary counter. The first three lines of the formula make sure that there is a point in the same cloud as the current point such that in this new point the binary value of the persistent variable vector is larger by one than the binary value of the shared variable vector and that in this new point the binary value of the persistent variable vector is larger by one than the binary value of the shared variable vector . The last two lines ensure the existence of a -successor of this new point in which the shared variable vectors , , , , and get the correct new values.
If in a computation step the symbol is written into the current cell, if the tape head moves to the left, and if the new state after this step is the state , then the following formula guarantees the existence of a point and its cloud with suitable values in the shared variables and in the persistent propositional variables.
[TABLE]
This formula is very similar to the previous one with the exception that here the binary counter for the position of the tape head is decremented.
The computation is modeled by the following subformula. Remember that is the disjoint union of the sets , , , .
[TABLE]
Finally, the subformula is defined as follows.
[TABLE]
We have completed the description of the formula for . It is clear that is a bimodal formula, for any . We still have to show two claims:
The function can be computed in logarithmic space. 2. 2.
For any ,
[TABLE]
The first claim will be shown in the following section. The two directions of the second claim will be shown separately in Subsections 4.3 and 4.4.
4.2 LOGSPACE Computability of the Reduction
For the first claim, we observe that there are three kinds of subformulas of :
subformulas that do not depend on the input string at all, 2. 2.
subformulas that depend only on the length of the input string but not on its symbols , 3. 3.
subformulas that depend on the particular symbols of the input string .
The subformula is of the first type. Therefore, it can be written using only a constant amount of workspace. And there is only one subformula of the third type, the subformula . All other subformulas are of the second type. All of them contain vectors of propositional variables of length at most or conjunctions or disjunctions of length at most , where . And all of these vectors and lists of conjunctions or disjunctions have a very regular structure. This applies also to the only subformula of the third type. This regular structure makes it possible to write down these formulas using a fixed (that means: independent of the input string ) number of counters that can count up to . But such counters can be implemented in binary using not more than space. Hence, given a string , the whole formula can be computed using not more than logarithmic space.
4.3 Construction of a Model
We come to the second claim. First, we show the direction from left to right. Let us assume . We will construct a cross axiom model with a point such that . There exists an accepting tree of on input , where is the set of nodes of , where is the set of edges, and where the function labels each node with a configuration (remember the discussion about the description of configurations at the beginning of Subsection 4.1). Let be the root of . The set is defined to be the (disjoint) union of the following three sets , , and . We define
[TABLE]
For the definition of we use the following set as an index set:
[TABLE]
We define
[TABLE]
where is a special element not contained in . We extend the binary relation on to a binary relation on by
[TABLE]
We define the set by
[TABLE]
As the relation is supposed to be an equivalence relation we can define it by defining the -equivalence classes. These are the sets
[TABLE]
for all , and the set
[TABLE]
We define the relation by:
[TABLE]
It is straightforward to check that is reflexive and transitive. The cross property is satisfied as well. Thus, is an cross axiom frame. Finally, we define the valuation as follows.
[TABLE]
and
[TABLE]
for ,
[TABLE]
for ,
[TABLE]
for ,
[TABLE]
for . It is obvious that all propositional variables are persistent. Thus, we have defined a cross axiom model . We claim that . For an illustration of an important detail of the structure see Figure 4.
We start with some preliminary observations. First, for any cloud, any shared variable has the same truth values in all points in the cloud. Secondly,
[TABLE]
for all . So, the points in are the “information” points. On the other hand, as the cloud does not contain any elements from , for all points we have , hence,
[TABLE]
for all and all . That means, the truth value of any shared variable in the cloud is false. We claim that in the other clouds all shared variables have the values indicated by their names, namely,
[TABLE]
for and ,
[TABLE]
for , and , and
[TABLE]
for and . This can be checked similarly as the corresponding claim (3.1) in the proof of Proposition 3.2. We prove the assertions about and leave the proofs of the other assertions to the reader. Let us fix some . Note that, for all , we have , hence
[TABLE]
Furthermore, for all . Since for all and we have we obtain for all and . Hence,
[TABLE]
This shows that, for any , the shared variable is true in the cloud if, and only if, there exists some with . As for all and any is -equivalent to some , we have , for all . Actually, for we even have as does not have any -successor besides itself. Thus, for any , the shared variable is true in the cloud if, and only if, there exists some with . The elements have the form for some . On the one hand, we observe that, for and , . On the other hand, for we have
[TABLE]
Thus, we have shown the desired claims:
[TABLE]
for , and , and
[TABLE]
for and .
It is clear from the definition of the valuation that in the points in the variable vectors , , , and have the values indicated by their names:
[TABLE]
for satisfying .
Now we are prepared to show . Our observations about the values of the shared variable vectors , , and show
[TABLE]
(remember that is false in all points of the cloud ). Similarly, our observations about the values of the shared variable vectors , , , and imply
[TABLE]
As the state of any node in the accepting tree of on input is different from , our observations about the value of the vector (in any cloud for the shared variable is true if, and only if, , and in the cloud all shared variables are false) shows
[TABLE]
Next, we show
[TABLE]
As the variable is true only in the elements of , it is sufficient to show for all with
[TABLE]
We distinguish between the two cases whether the cell under the tape head in the configuration has been visited on the path from to before is reached or not.
First let us assume that the cell has not been visited before. Then , hence and , that is, the formulas in the first two lines are true in . And if we have then, due to , the point is a point on the path from to . Our assumption (that the cell has not been visited before is reached) implies . Hence the formula in the third line is true in as well.
Now, let us assume that the cell has been visited on the path from to before is reached. Let be the last node on the path from to with . Let and . Then and . As , the formula in the first line above is true, that is, . For the formula in the second line, let us assume . Then is a node on the path from to with . Hence, , hence, , hence, , hence, . For the formula in the third line, let us assume . Then is a node on the path from to with , that is, with the property that in this node the same cell is visited as in the node . As is the last node on the path from to with this property, we have , hence, , hence .
Next, we show
[TABLE]
It is sufficient to show for all , . There are two cases to be considered. In each of them, due to the presence of the variable , we need to consider only points . Let us consider elements with . It is sufficient to show . We distinguish between the two cases considered in this formula. First, let us assume . We have to show that in this case
[TABLE]
According to our observations about the value of , the cell under the tape head in the configuration has not been visited on the path from to . Thus, the symbol is still the initial symbol in the cell . Let us call this symbol . Then , and
[TABLE]
On the other hand, . We have shown the assertion.
Now, let us assume
[TABLE]
We have to show that in this case
[TABLE]
The assumption implies that the cell has already been visited on the path from to and that where and is the last node on the path from to with . The assumption implies . But then in the point the vector encodes in unary the symbol that was written into the cell in the computation step from to . If we call this symbol , this means . This is still the symbol in the cell when is reached, hence, . So, we have indeed shown
[TABLE]
Finally, we show
[TABLE]
It is sufficient to show
[TABLE]
for all . We will separately treat the conjunctions over the set and over the set . Let us fix a pair and let us assume that is a point with . We have to show that there is an element such that or that there is an element such that . As in the cloud the truth value of any shared variable is false, the assumption implies that there exists some with . Furthermore, and . As is an accepting tree and the state of is an element of , the node is an inner node of , hence, it has a successor . Let us assume that is the element of the transition relation that leads from to (the case that this element is of the form is treated analogously). We claim that then
[TABLE]
Let us check this. Let us assume that, for some and for some ,
[TABLE]
The number is an element of because is an inner point of the tree and the length of any computation path is at most , and the number is an element of because the computation starts in cell and because during each computation step the tape head can move at most one step to the left or to the right. We obtain and . We claim that the two points and have the properties formulated in the formula . Indeed, we observe and as well as . The facts
[TABLE]
imply
[TABLE]
We obtain
[TABLE]
and with
[TABLE]
we obtain as well
[TABLE]
Finally, our observations about the values of the shared variable vectors , , and about the vector imply that also
[TABLE]
(remember that is the element of the transition relation that leads from the node to the node ). This ends the treatment of the conjunctions over the set in the formula . Let us now consider a pair . Let us assume that is a point such that . We have to show that for all elements we have and for all elements we have . Let us consider an arbitrary element (the case of an element is treated analogously). As in the cloud the truth value of any shared variable is false, the assumption implies that there exists some with . Furthermore, and . As and is an accepting tree, in there is a successor of such that the element leads from to . Above, we have already seen that this implies
[TABLE]
Thus, we have shown for all . This ends the proof of the claim .
4.4 Existence of an Accepting Tree
We come to the other direction. Let . We wish to show that if is -satisfiable then . We will show that any cross axiom model of essentially contains an accepting tree of the Alternating Turing Machine on input . Of course, this implies .
Let us sketch the main idea. We will consider a cross axiom model of . And we will consider partial trees of on input as considered in Subsection 3.3, for any . First, we will show that a certain very simple partial tree of on input “can be mapped to” the model (later we will give a precise meaning to “can be mapped to”). Then we will show that any partial tree of on input that can be mapped to the model and that is not an accepting tree of on input can be properly extended to a strictly larger partial tree of on input that can be mapped to the model as well. If there would not exist an accepting tree of on input then we would obtain an infinite strictly increasing sequence of partial trees of on input . But we show that this cannot happen by giving a finite upper bound on the size of partial trees of on input .
Let be a string such that the formula is -satisfiable. We set . Let be a cross axiom model and a point such that . The quintuple
[TABLE]
will be important in the following. Points in that cannot be reached from by finitely many and -steps (in any order) can be deleted from with no harm: the resulting smaller quintuple will still be a model of . Hence, we will assume without loss of generality that every point can be reached from by finitely many and -steps (in any order). Note that now the cross property implies that for any there exists some with and . Hence, if is a formula with then, for all , we have . For every , let be the -equivalence class of . Remember that for every -equivalence class and every shared variable for and a natural number , the truth value of this shared variable is the same in all elements of the -equivalence class.
Partial trees of on input as introduced in Subsection 3.3 will play an important role in the following. We will write a partial tree of on input similarly as in Subsection 3.3 as a triple , but with the difference that we will describe configurations as at the beginning of this section: the labeling function will be a function of the form . If is a partial tree of on input with root then a function is called a morphism from to if it satisfies the following four conditions:
, 2. 2.
, 3. 3.
, 4. 4.
(\forall v\in V)\,\pi(v)\models\begin{array}[t]{l}\bigl{(}B\wedge(\underline{\alpha}^{\mathrm{time}}=\mathrm{bin}_{N}(\mathit{time}(v)))\\ \wedge(\underline{\alpha}^{\mathrm{pos}}=\mathrm{bin}_{N+1}(\mathit{pos}(v)))\wedge\alpha^{\mathrm{state}}_{\mathit{state}(v)}\wedge\alpha^{\mathrm{read}}_{\mathit{read}(v)}\bigr{)}.\end{array}
We say that can be mapped to if there exists a morphism from to . Below we shall prove the following lemma.
Lemma 4.2**.**
If a partial tree of on input can be mapped to and is not an accepting tree of on input then there exists a partial tree of on input that can be mapped to and that satisfies .
Before we prove this lemma, we deduce the desired assertion from it. Let
[TABLE]
Then, due to Condition III in the definition of a “partial tree of on input ”, any node in any partial tree of on input has at most successors. As any computation of on stops after at most steps, any partial tree of on input has at most
[TABLE]
nodes. We claim that the rooted and labeled tree
[TABLE]
is a partial tree of on input and can be mapped to . Indeed, Condition I in the definition of a “partial tree of on input ” is satisfied because the node is labeled with the initial configuration of on input . Conditions II, III, and IV are satisfied because does not have any inner nodes. Condition is satisfied because , and this follows from (this is a part of ) and (this follows from ). Thus, is indeed a partial tree of on input . Now we show that can be mapped . Of course, we define by . We claim that is a morphism from to . We check the four conditions one by one.
The condition is true by definition. 2. 2.
The second condition is satisfied trivially because the tree does not have any edges. 3. 3.
The third condition in the definition of a “morphism from to ” is satisfied trivially because has only one node, its root. 4. 4.
On the one hand, we have , ,
, and .
On the other hand, the condition implies
[TABLE]
Thus, we have shown that is a partial tree of on input and that can be mapped to .
If there would not exist an accepting tree of on input then, starting with and using Lemma 4.2 we could construct an infinite sequence of partial trees of on input that can be mapped to such that the number of nodes in these trees is strictly increasing. But we have seen that any partial tree of on input can have at most nodes. Thus, there exists an accepting tree of on input . We have shown .
In order to complete the proof of Theorem 4.1 it remains to prove Lemma 4.2.
Proof of Lemma 4.2.
Let be a partial tree of on input that is not an accepting tree of on input and that can be mapped to . Let be a morphism from to . Then has a leaf such that the state is either an element of or of . First we treat the case that it is an element of , then the case that it is an element of .
So, let us assume that . We define . Then, because is a morphism from to , we have
[TABLE]
hence, due to ,
[TABLE]
Let us assume that there is an element such that (the other case, the case when there is an element such that , is treated analogously). We claim that we can define the new tree as follows:
- •
where is a new element (not in ),
- •
,
- •
\widetilde{c}(x):=\begin{cases}c(x)&\text{for all }x\in V,\\ c^{\prime}&\text{for }x=\widetilde{v},\text{ where c^{\prime}c(\widehat{v})}\\ &\text{in the computation step given by }((q,\eta),(r,\theta,\mathit{left}))\in\delta.\end{cases}
Before we show that is a partial tree of on input , we define a function that we will show to be a morphism from to .
As is an element of a partial tree of on input with , at least one more computation step can be done. As any computation of on input stops after at most steps, we observe that the number satisfies . Then . We set . The assumption that is a morphism from to implies . We conclude . As during each computation step, the tape head can move at most one step to the left or to the right and as the computation started in position the number satisfies . Then . We set . The assumption that is a morphism from to implies . We conclude . Furthermore, as is a morphism from to we have . Summarizing this, we have
[TABLE]
Due to there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
We claim that we can define the desired function by
[TABLE]
We have to show that is a partial tree of on input and that is a morphism from to . Condition I in the definition of a “partial tree of on input ” is satisfied because has the same root as , and the label of the root does not change. A node in is an internal node of if, and only if, it is either an internal node of or equal to . For internal nodes of Conditions II, III, and IV are satisfied by assumption (and due to the fact that the labels of nodes in do not change). The new internal node satisfies Condition II by our definition of . Condition III is satisfied for because has exactly one successor. And Condition IV does not apply to because . A node in is a leaf if, and only if, it is either equal to or a leaf in different from . For the leaves in different from Condition is satisfied by assumption (and due to the fact that the labels of nodes in do not change). For the new leaf in Condition says . This is true because on the one hand and on the other hand and (this follows from ). We have shown that is a partial tree of on input .
Now we show that is a morphism from to . The first condition in the definition of a “morphism from to ” is satisfied because . Let us look at the second condition and let us assume that satisfy . We distinguish between two different cases for and .
Case: . Then our assumption implies and . In this case the facts and as well as the assumption that is a morphism from to imply the desired assertion:
[TABLE] 2. 2.
Case: . Then our assumption implies . On the one hand, we have , on the other hand , hence, . With we obtain the desired assertion .
The third condition in the definition of a “morphism from to ” is satisfied for by assumption (and by and ). It is satisfied for because , because , and because . We come to the fourth condition. It is satisfied for by assumption (and due to and ). We still need to show that it is satisfied for . Remember . We need to show
[TABLE]
This assertion consists really of five assertions. We treat them one by one.
- •
The condition is satisfied because and and because is persistent.
- •
In the trees and we have , and in the tree we have . We wish to show . We have already seen and . As , we obtain
[TABLE]
The conditions as well as
[TABLE]
imply .
- •
In the trees and we have , and in the tree we have . We wish to show . We have already seen and . As , we obtain
[TABLE]
The conditions as well as
[TABLE]
imply .
- •
We have . And we have .
- •
Let in . We wish to show . As we know it is sufficient to show . We have already seen and . As we know we conclude . We have seen as well. Furthermore, we have . The first line in the formula implies , hence, . Let for be the uniquely determined node on the path from to with (hence , , and ). Then
[TABLE]
By the second condition in the definition of a “morphism from to ”
[TABLE]
By repeated application of the cross property and by starting with we conclude that for there exists some with . Let us consider . As we also have (remember that variables are persistent in ). Due to we obtain as well. Due to and the persistence of variables we obtain as well. Furthermore, we have . We distinguish between the two cases whether the cell has been visited on the path from to or not.
Let us first consider the case when the cell has not been visited on the path from to . Then, on the one hand, the symbol is still the initial symbol in the cell . On the other hand, for all we have and
[TABLE]
Together with and we conclude that for . The persistence of implies that for . Together with we conclude that the binary value of in must be [math]. Now the fact implies .
Let us consider the second case, the case when the cell has been visited on the path from to . Let be the last node on this path with . Then . On the one hand, then the symbol is the symbol that was written into the cell in the computation step from node to node , and by the third condition in the definition of a “morphism from to ” we have , hence, . On the other hand, from we get , hence, . From we get
[TABLE]
Together with we obtain . And similarly as in the first case, from
[TABLE]
for we obtain
[TABLE]
All this implies and . Then implies . With we conclude , hence, . That was to be shown.
Thus, is not only a partial tree of on input but can also be mapped to . This ends the treatment of the case .
Now we consider the other case, the case . We define . Let
[TABLE]
be the elements of where and , for . We claim that we can define the new tree as follows:
- •
where are new (not in ) pairwise different elements,
- •
,
- •
\widetilde{c}(x):=\begin{cases}c(x)&\text{for all }x\in V,\\ c^{\prime}_{m}&\text{for }x=\widetilde{v}_{m},\text{where c^{\prime}_{m} is the configuration that is reached from }\\ &\text{c(\widehat{v}) in the computation step given by }((q,\eta),(r_{m},\theta_{m},\mathit{dir}_{m}))\in\delta.\end{cases}
Before we show that is a partial tree of on input , we define a function that we will show to be a morphism from to . Since is a morphism from to ), we have
[TABLE]
hence, due to ,
[TABLE]
As in the case one shows that the numbers and satisfy and , and one defines
[TABLE]
As in the case one obtains
[TABLE]
Let us now consider some . If then, due to , there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
Similarly, if then, due to , there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
We claim that we can define the desired function by
[TABLE]
Similarly as in the case one shows that is a partial tree of on input . Note that also Condition IV is satisfied for . Finally, similarly as in the case one shows that is a morphism from to . This ends the treatment of the case . We have proved Lemma 4.2. ∎
5 Reduction of to
In this section we prove the -hardness of by showing the following result. Remember that according to Theorem 4.1 the satisfiability problem of is -hard.
Theorem 5.1**.**
The satisfiability problem of the bimodal logic can be reduced in logarithmic space to the satisfiability problem of the bimodal logic .
To prove this theorem we proceed in three steps:
We start with the definition of the reduction function. 2. 2.
We prove its correctness. 3. 3.
We show that the reduction function can be computed using not more than logarithmic space.
5.1 The Reduction Function
We show that the satisfiability problem of can be reduced to the satisfiability problem of . To this end we define a translation of bimodal formulas in the language to bimodal formulas in such that for all
[TABLE]
For the reduction we face two main problems.
The first problem is that in cross axiom models literals are persistent. To handle this we make sure that the translation contains a subformula postulating the persistence of literals. 2. 2.
The second problem is that in general cross axiom models do not satisfy right commutativity. To handle this we add to each cloud in a cross-axiom model a special “new point” serving as successor point for all points in a predecessor cloud that fail to have in the original model a successor point in this cloud. In order to distinguish the new points from the original ones we use a special propositional variable main which is false exactly at the new points.
We define the desired function in four steps:
Definition 5.2** (Translation ).**
For every let by the alphabetically first propositional variable that is not a subformula of . 2. 2.
Recursively, we define a function as follows:
[TABLE]
for all and for all . (Note that is equivalent to and that is equivalent to .) 3. 3.
For we define
[TABLE] 4. 4.
For we define a function by
[TABLE]
We claim that the function is indeed a reduction function from the satisfiability problem of to the satisfiability problem of .
Proposition 5.3**.**
The function satisfies, for all ,
[TABLE]
The next section is dedicated to the proof of Proposition 5.3. We treat both directions of the claimed equivalence separately.
5.2 Correctness
Lemma 5.4**.**
Let . Then
[TABLE]
Proof.
Let be –satisfiable. Then there are a cross axiom model and a point such that . Let , for , where is a suitable index set, be the -equivalence classes in . We construct an -commutator model for as follows. Let for be pairwise different “new” points that are not elements of . We define
[TABLE]
We define the equivalence relation on by demanding that the following sets for are the -equivalence classes of :
[TABLE]
for . Let be the relation on the set of clouds in induced by ; compare [8, Definition 4.1]. We define
[TABLE]
Finally we define
[TABLE]
We wish to show the following:
is an -commutator model, 2. 2.
.
We prove the first claim.
Clearly, is an equivalence relation.
The relations and are preorders (by assumption respectively by [8, Corollary 4.4]), hence, both of them are reflexive and transitive. It is clear that this implies that the relation is reflexive as well. For transitivity of , assume that and . If then the definition of implies that also and and as well as , hence, by transitivity of . This implies . If then we let be the indices with , , and . Note that in this case . We observe that and imply and . Transitivity of implies , hence, . Thus, is transitive as well. We have shown that is a preorder.
Next, we wish to show left commutativity. Let us consider some with and . Let be the indices with and . It is sufficient to show that there exists some with . The condition implies . If then the left commutativity of gives us an with , hence, with . If then , and does the job.
In order to prove right commutativity let us consider some with and . Let be the indices with and . It is sufficient to show that there exists some with . The condition implies . Hence, we obtain . This proves the first claim, that is an -commutator model.
We come to the second claim, .
From the definition of we obtain
[TABLE]
Exactly at the points in the propositional variable is false. From the fact that all -successors of points in this set are elements of this set as well, we conclude
[TABLE]
Next, we observe that for all and for all propositional variables we have by definition of
[TABLE]
Since all literals are persistent in and is true exactly at the points in we obtain
[TABLE]
Finally, we have to show . By induction on the structure of we show the stronger assertion:
[TABLE]
for all and for all . We distinguish the following cases:
- •
Case . We already mentioned that for all and for all we have .
- •
Case . Then the following four assertions are equivalent, the second and the third by induction hypothesis: (1) , (2) , (3) , (4) .
- •
Case . This case is treated in the same way.
- •
Case . We wish to show
[TABLE]
First, let us assume . Let us consider an arbitrary such that . It is sufficient to show that
[TABLE]
If then we obtain and . By induction hypothesis we obtain , hence . If then , hence in this case as well.
Now, for the other direction, let us assume . Consider some with (remember that this implies ). It is sufficient to show that
[TABLE]
But for we have . The condition implies . We obtain . Finally, by induction hypothesis we obtain .
- •
Case . This case can be treated in the same way as the previous case. In fact, it is sufficient to copy the argument for the case and to replace by , by , and by . ∎
Now we turn to the other direction of Proposition 5.3.
Lemma 5.5**.**
Let . Then
[TABLE]
Proof.
Let be –satisfiable. This implies that there exist an –commutator model and a point such that , that is
[TABLE]
We construct a cross axiom model for as follows. We construct as a rooted model, where all points are reachable from the point :
[TABLE]
We define the relations and on simply by
[TABLE]
Finally,
[TABLE]
for all .
First, we observe that and the reflexivity of and imply . We wish to show the following:
is a cross axiom model, 2. 2.
.
We prove the first claim.
It is obvious that the relation inherits reflexivity, symmetry and transitivity from and that the relation inherits reflexivity and transitivity from . Thus, the relation is an equivalence relation, and the relation is a preorder.
Next we wish to show that has the left commutativity property. So let us consider points with and . By definition of the relations and we obtain that also and . Since has the left commutativity property there is some point with and . The definition of and imply that there exists some with and . The left commutativity of and as well as imply that there exists some with and . So, we have and . In addition to that, implies , hence, . This, together with and , implies . Hence and as well as . This shows that has the left commutativity property.
Finally, we claim that propositional variables are persistent in . For all we have . Hence, all are persistent in . Furthermore, we have . Hence, is persistent in as well. Let us consider with . Due to the definition of there exists some with and . Then, implies, for all , . Note that and . So, if, and only if, . Due to the same holds true with replaced by . This shows that all are persistent in . We have shown that is a cross axiom model.
We come to the second claim, . Due to it is sufficient to prove for all and for all :
[TABLE]
We show this by induction on the structure of . We distinguish the following cases:
- •
Case . In this case the claim is true due to the definition of .
- •
Case or . In both cases the claim follows directly from the induction hypothesis.
- •
Case . Let us first assume , that is . We wish to show . Consider an arbitrary with . It is sufficient to show . Note that the definition of implies . Hence, we have . Furthermore, due to we have . We obtain . By induction hypothesis we obtain .
For the other direction let us assume that . We wish to show . Consider an arbitrary with . It is sufficient to show . If then implies , and implies . By induction hypothesis we obtain , hence, . If then we claim that , hence, . Indeed, the assumption implies that there exists some with and . Together with and left commutativity of and transitivity of we can conclude that there exists some with and . Hence, is reachable from . By definition of the assumption indeed implies .
- •
Case . This case can be treated similarly as the previous case. The details are left to the reader. ∎
5.3 LOGSPACE Computability of the Reduction Function
In this subsection we show that the satisfiability problem of the logic can be reduced in logarithmic space to the satisfiability problem of . We start with the following assertion.
Lemma 5.6**.**
The language of bimodal formulas is an element of .
Here, is the set of all languages that can be decided in logarithmic time by an alternating Turing machine with “random access” to the input; compare Buss [1, Page 124], Ibarra, Jiang, and Rivakumar [9], Clote [4, Def. 2.3]. Note that Buss [1, Pages 124, 125] has shown that a certain language of Boolean formulas is in . As our syntax of formulas is slightly different from the one used by Buss we cannot directly use his result. But Lemma 5.6 can be proved by arguments similar to the arguments used by Buss. Therefore, we omit the proof of Lemma 5.6. Actually, we need only the following corollary.
Corollary 5.7**.**
The language of bimodal formulas can be decided in logarithmic space.
Proof.
It is well-known that is a subset of ; see [4, Page 601]. ∎
Let be the alphabet over which bimodal formulas are defined. In order to prove the assertion we have to show that there is a logspace computable function such that, for all ,
[TABLE]
We define such a function by formulating an algorithm for computing it that works in logarithmic space.
So, let be the input string. According to Corollary 5.7 we can first check in logarithmic space whether is a bimodal formula or not, that is, whether is an element of or not. If not then the algorithm outputs (which is certainly not a bimodal formula). If, on the other hand, is a bimodal formula then we wish to compute and print as defined in Subsection 5.1.
First, we compute the smallest natural number such that is not a subformula of . We do this by starting with , increasing step by step, and checking in each step whether is a subformula of . Note that a string for some is a subformula of if, and only if, there exists an occurrence of the string as a substring of that is not followed by a [math] or a . This algorithm works in logarithmic space because can contain only less than many subformulas of the form . Thus, we need to check whether is a subformula of only for . For all these the binary representation can be stored in logarithmic space. Finally, we can also store the string in logarithmic space.
Now we wish to compute and output . It is straightforward to print . Next we wish to print . In order to do this we must identify all such that is a subformula of , and for each such we must print
[TABLE]
This can be done as follows. We read the string from left to right. Whenever we read an we use two binary counters in order to mark the beginning and the end of the subformula that begins with this occurrence of . Then we check, again using binary counters, whether the same subformula has appeared already further to the left in . If it has then we just move on. If it has not appeared before, then we print out , and then we move on. It is clear that all this can be done in logarithmic space.
Finally, we wish to output . In order to compute one has to replace every occurrence of “” by “”, and every occurrence of “” by “”, and one has to add an additional closing bracket after each subformula and each subformula of . Besides that, all other symbols from can simply be copied. The only nontrivial part here is the addition of a closing bracket after each occurrence of a subformula of the form or of . In order to do this, for each position in the string one has to count how many subformulas of the form or of end in this position and then one has to print so many additional closing brackets. So, how can one count how many subformulas of the form or of end in the current position in the string ? If the symbol in this position is an element of then no subformula ends in this position. The same is true if the symbol in this position is either [math] or and this is followed by a bit [math] or as well. There are only the following possible cases for the last symbol of a subformula.
- •
If the symbol in the current position is a bit, so [math] or , and this is not followed by a bit, then a subformula of the form for some ends in this position. Then we move to the left of the corresponding occurrence of and count the number of occurrences of and until we read a symbol not in .
- •
If the symbol in the current position is a closing bracket then we go to the left step by step until we have found the corresponding opening bracket . This can be done by using a binary counter that is increased by for each closing bracket and decreased by for each opening bracket. One stops when this counter is back to its initial value [math]. Once we have found the corresponding opening bracket we move to the left of it and count the number of occurrences of and until we read a symbol not in .
By using binary counters all this can be done in logarithmic space. This ends the description of the computation in logarithmic space of the described reduction function .
6 Reduction of to
The -hardness of follows from the -hardness of and from the following result.
Theorem 6.1**.**
The satisfiability problem of the bimodal logic can be reduced in logarithmic space to the satisfiability problem of the bimodal logic .
We start with the definition of the reduction function translating bimodal formulas in the language to bimodal formulas in such that for all :
[TABLE]
The problem that we face is that in general -models are not reflexive. To handle this we add to the original formula a formula that implies that all those instances of the reflexivity axiom scheme where is a subformula of must hold true in all reachable points.
Definition 6.2** (Translation ).**
For we define a function by
[TABLE]
We claim that the function is indeed a reduction function from the satisfiability problem of to the satisfiability problem of .
Proposition 6.3**.**
The function satisfies, for all ,
[TABLE]
Proof.
Let be –satisfiable. There are an -commutator model and a point such that . Since the relation in is reflexive we have for all that . Hence, , in other words, . Furthermore, satisfies the conditions for -commutator models because the relation in is transitive as well. Hence, is -satisfiable.
For the other direction of the equivalence let us assume that is -satisfiable. This implies that there exist a –commutator model and a point such that , that is
[TABLE]
We construct an –commutator model for as follows. We construct as a rooted model, where all points are reachable from the point :
[TABLE]
We define the relations and on simply by
[TABLE]
Finally,
[TABLE]
for all .
It is clear that , and it is straightforward to see that is an -commutator model. We claim that . By induction on the structure of we show the stronger assertion:
[TABLE]
for all and for all . We distinguish the following cases:
- •
Case . In this case the claim follows directly from the definition of .
- •
Case or . In both cases the claim follows directly from the induction hypothesis.
- •
Case . Let us first assume . We wish to show . Consider an arbitrary with . It is sufficient to show . Note that the definition of implies that or . In the first case, , the assumption directly implies . By induction hypothesis we obtain . In the second case, , we use the fact that and imply . Together with this implies , hence, . By induction hypothesis we obtain as well.
For the other direction let us assume that . We wish to show . Consider an arbitrary with . It is sufficient to show . But from and we conclude and . Hence, implies . By induction hypothesis we obtain .
- •
Case . This case can be treated similarly. For the direction “” one needs to use left commutativity. The details are left to the reader. ∎
Proof of Theorem 6.1.
Let be the alphabet over which bimodal formulas are defined. In order to prove the assertion we have to show that there is a logspace computable function such that, for all ,
[TABLE]
We define such a function by formulating an algorithm for computing it that works in logarithmic space.
So, let be the input string. According to Corollary 5.7 we can first check in logarithmic space whether is a bimodal formula or not, that is, whether is an element of or not. If not then the algorithm outputs (which is certainly not a bimodal formula). If, on the other hand, is a bimodal formula then we wish to compute and print as defined in Definition 6.2. The algorithm that prints works as follows.
It prints . 2. 2.
For each it prints the string
[TABLE]
Of course, for the second part, for every occurrence of the symbol in one has to determine the uniquely determined formula beginning in immediately to the right of this occurrence of . Then one has to print the string above. All this can be done using several binary counters. First one sets a binary counter called StartOfPsi to the value of the position to the right of the current occurrence of . In order to compute the correct value of a binary counter EndOfPsi that is supposed to be the position of the rightmost symbol in one proceeds as follows. Starting from the position StartOfPsi one reads the given string from left to right. As long as the read symbol is or or one continues reading. At some stage one will either read an or an opening bracket . If one reads an then EndOfPsi is set to the position of the rightmost bit, that is, the rightmost [math] or , such that between this symbol and the just read occurrence of there are only bits. If one reads an opening bracket then EndOfPsi is set to the position of the first closing bracket to the right of this opening bracket such that the string between these two brackets contains as many closing as opening brackets. Note that all this can be done in logarithmic space.
Finally, using the two binary counters StartOfPsi and EndOfPsi containing the positions of the first and the last symbol of it is clear that one can print the string “”, again using additional binary counters that use only logarithmic space. This ends the description of the computation in logarithmic space of the described reduction function . ∎
Appendix A Reduction of Alternating Turing Machines Working in Exponential Time to
In Section 4 we have shown that any language recognized by an Alternating Turing Machine working in exponential time can be reduced in logarithmic space to the satisfiability problem of . This shows that the satisfiability problem of is -hard under logspace reduction. In Section 5 we have shown that the satisfiability problem of can be reduced in logarithmic space to the satisfiability problem of . This proves the following theorem.
Theorem A.1**.**
The satisfiability problem of is -hard under logarithmic space reduction.
In this appendix we wish to given an alternative, “direct” proof of this theorem by showing directly that any language recognized by an Alternating Turing Machine working in exponential time can be reduced in logarithmic space to the satisfiability problem of . The proof is quite similar to the reduction of Alternating Turing Machines working in exponential time to the satisfiability problem of presented in Section 4. But, there are also some important differences between the two reductions. On the one hand, we are going to use certain “shared variables” as well, but the mechanism of shared variables in is much easier than in . On the other hand, the fact that in the left commutativity property and the right commutativity property hold true (while in only the left commutativity property has to hold true) causes problems that were not present in our treatment of in Section 4. Similarly as in that section, for we will model nodes in an accepting tree of an Alternating Turing Machine by clouds in an -product model. But the commutativity properties have the consequence that for every point in every cloud there exists a copy in every other cloud. The result is that in a cloud modeling a certain node on some path in an accepting tree there are also points that come from other nodes on other computation paths, perhaps even with the same time stamp. This makes the isolation of the correct points carrying the required information (in particular the information about the symbol to be read at a certain time on some computation path) more difficult. For details see Subsection A.2 where the reduction function is defined and explained.
In the first of the following five subsections we present an implementation of a binary counter in , similar to the implementation of a binary counter in in Subsection 3.2. In the second subsection we give an outline of the definition of the reduction function and then define the reduction function formally. In the third subsection we show that the reduction function can be computed in logarithmic space. The final two subsections are devoted to the correctness proof of the reduction. First we show that in the case the formula is -satisfiable by explicitly constructing an -product model for . In the last section we show that if is -satisfiable then is an element of .
A.1 Binary Counters in
Fix some natural number . We wish to implement in a binary -bit counter that counts from [math] to . That means, we wish to construct an -satisfiable formula with the property that any model of it contains a sequence of pairwise distinct points such that, for each , at the point the number is stored in binary form in a certain way.
Additionally, we need to copy and transmit various bits of information, both in the -direction as well as in the -direction This will be done by two kinds of formulas.
- •
On the one hand, we need formulas that have the same truth value in the vertical () direction but can change their truth values in the horizontal () direction. In the logic we can force certain propositional variables to be persistent by a suitable formula.
- •
On the other hand, we need formulas that have the same truth value in the horizontal () direction but can change their truth values in the vertical () direction. Such formulas will be called shared variables. In the logic they can be defined as follows. For let be special propositional variables. The shared variables are defined as
[TABLE]
Note that .
In the following we use the abbreviations introduced above, in Table 1, and in Table 3.
The idea of the construction is the same as in Subsection 3.2.
- •
We store the counter values in a vector of shared variables. To this end we embed the sequence of points in a sequence of clouds such that the cloud contains the point and such that the vector of shared variables satisfied at (and hence at all points in ) encodes the number .
- •
Let be the number encoded by . If contains no [math] then has reached its highest posible value, the number . Otherwise let be the position of the rightmost [math]. We determine the position with the aid of the formula . In order to increment the counter we have to keep all at positions unchanged and to switch all at positions . We do this in two steps:
First me make an -step from the point to a point where we store the number in a vector of usual propositional variables by demanding that
[TABLE] 2. 2.
Then we make a -step from the point to a point in the cloud and demand that
[TABLE]
Note that the value of is copied from to its -successor because by the formula
[TABLE]
we force the vector of propositional variables to be persistent.
Altogether we demand that for the number
[TABLE]
- •
Additionally we need a formula to ensure that the starting value is [math], that is we demand
[TABLE]
We now define the complete counter formula, for .
[TABLE]
Proposition A.2**.**
For all , the formula is -satisfiable. 2. 2.
For all , for every -commutator model of and for every point in this model with there exist a sequence of points and a sequence of points such that
- •
for , ,
- •
for , and and .
Proof.
For the following let us fix some .
We construct an -product model with a point in such that as follows; see Figure 6. We define an S4-frame by
[TABLE]
We define an S5-frame by
[TABLE]
Then the product frame with and with and defined as in [8, Definition 2.2] is an -frame. We define the valuation by
[TABLE]
for . This implies for all
[TABLE]
We claim
[TABLE]
Indeed, it is clear that the propositional variables are persistent, hence, we have
[TABLE]
It is also clear that
[TABLE]
Let us assume that for some and some we have
[TABLE]
It is sufficient to show that
[TABLE]
Indeed, implies and . Note that this implies , hence, and . In view of it is sufficient to show
[TABLE]
and
[TABLE]
Both claims follow from the facts that and that every point satisfies the formulas and . 2. 2.
The proof for -commutator models of the formula is very similar to the proof for cross axiom models of the formula in Proposition 3.2. For completeness sake we explicate it in detail. Suppose there are an -commutator model of the formula and a point with . We show by induction that the claimed sequences of points and with the claimed properties exist. In addition, we show that there exist points with and , for . Note that the sequences and are supposed to form a “staircase” as in Figure 3. By definition, . By induction hypothesis, let us assume that for some with there exist and with
[TABLE]
with
[TABLE]
for , and with
[TABLE]
for , and that there are with and , for . Since , the set is nonempty. With we have
[TABLE]
Due to as well as this implies
[TABLE]
Thus, there must exist points and satisfying as well as
[TABLE]
and
[TABLE]
We have to show
[TABLE]
and
[TABLE]
Due to the fact that is an element of the same cloud as , and has the same value in all points in a cloud we obtain
[TABLE]
Together with
[TABLE]
this implies
[TABLE]
(the values of the leading bits of are copied to the leading bits and the other bits are defined explicitly by so that the binary value of is ). From as well as we obtain . Using we obtain . Finally, the left commutativity property applied to and implies that there exists a point with and . Using additionally and we obtain and . This ends the proof of the second assertion. ∎
A.2 Construction of the Formula
Let be an arbitrary language over some alphabet , that is, . We are going to show that there is a logspace computable function mapping strings to strings such that, for any ,
- •
is a bimodal formula and
- •
is -satisfiable if, and only if, .
Once we have shown this, we have shown the result.
In order to define this desired reduction function , we are going to make use of an Alternating Turing Machine for . Since , there exist an Alternating Turing Machine and a univariate polynomial such that accepts , that is, , and such that the time used by on arbitrary input of length is bounded by . We can assume without loss of generality , , that the coefficients of the polynomial are natural numbers and that, for all , we have and . In the following, whenever we have fixed some , we set
[TABLE]
Let us consider an input string of length , for some , and let us sketch the main idea of the construction of the formula . The formula will describe the possible computations of on input in the following sense: any -product model of will essentially contain an accepting tree of on input , and if there exists an accepting tree of on input then one can turn this into an -product model of . In such a model, any node in an accepting tree of on input will be modeled by a cloud (that is, by an -equivalence class) in which certain shared variables (we use the notion “shared variables” in the same sense as in Subsection A.1) will have values that describe the data of the computation node that are important in this computation step. Which data are these? First of all, we need the time of the computation node. We assume that the computation starts with the initial configuration of on input at time [math]. Since the ATM needs at most time steps, we can store the time of each computation node in a binary counter counting from [math] to . Since during each time step at most one additional cell either to the right or to the left of the previous cell can be visited, we can describe any configuration reachable during a computation of on input by the following data:
- •
the state of the configuration,
- •
the current content of the tape, given by a string in ,
- •
the current position of the tape head, given by a number in .
We assume that in the initial configuration on input the tape content is (remember that we use for the blank symbol) and that the tape head scans the blank to the left of the first symbol of , that is, the position of the tape head is . If a cloud in an -product model of describes a computation node of on input then in this cloud the following shared variables will have the following values:
- •
a vector giving in binary the current time of the computation,
- •
a vector giving in binary the current position of the tape head,
- •
a vector giving in unary the current state of the computation (here “unary” means: exactly one of the shared variables will be true, namely the one with being the current state),
- •
a vector giving in unary the symbol in the current cell (here “unary” means: exactly one of the shared variables will be true, namely the one with being the symbol in the current cell),
- •
a vector giving in unary the symbol that has just been written into the cell that has just been left, unless the cloud corresponds to the first node in the computation tree — in that case the value of this vector is irrelevant (here “unary” means: exactly one of the variables will be true, namely the one with being the symbol that has just been written),
- •
a vector giving in binary the previous position of the tape head, that is, the position of the cell that has just been left, unless the cloud corresponds to the first node in the computation tree — in that case the value of this vector is irrelevant.
The formula has to ensure that for any possible computation step starting from such a computation node in an accepting tree there exists a cloud describing the corresponding successor node in the accepting tree. In this new cloud, the value of the counter for the time has to be incremented. This can be done by the technique for implementing a binary counter in that was described in Subsection A.1. In parallel, we have to make sure that in this new cloud also the vectors , , , , and are set to the right values. The vector is a copy of the vector in the previous cloud (we will see below how one can copy it). For the vectors , , and these values can be computed using the corresponding element of the transition relation of the ATM. For example, has to be decremented by one if the tape head moves to the left, and it has to be incremented by one if the tape head moves to the right. Also the new state (to be stored in ) and the symbol written into the cell that has just been left (to be stored in ) are determined by the data of the previous computation node and by the corresponding element of the transition relation .
But the vector is supposed to describe the symbol in the current cell. This symbol is not determined by the current computation step but has either been written the last time when this cell has been visited during this computation or, when this cell has never been visited before, the symbol in this cell is still the one that was contained in this cell before the computation started. How can one ensure that is set to the right value? We will do this by using persistent variables and a variable that is neither shared nor persistent. We will ensure that any cloud corresponding to a node in the computation tree in which the cell is being visited contains a point with a persistent position vector and with a persistent time vector that will be forced to contain in binary form the time one step after the previous visit of the cell or, if the cell has not been visited before, to contain the value [math]. Furthermore, there will be a third persistent vector . If the cell has not been visited before then we will make sure that the vector encodes the initial symbol contained in cell . If the cell has been visited before then we will make sure that the vector encodes the symbol that has been written into the cell during the previous visit of the cell. In order to do that we need to determine the time of the previous visit. For that the Boolean variable is used and the fact that due to the left commutativity property the point has -predecessors in all clouds corresponding to any node on the path in the accepting tree from the root to the current cloud. Then, when one knows this time, one can look at the shared variable vector in the cloud corresponding to the step after the previous visit of this cell (this shared variable vector encodes the symbol that has just been written into the cell) and can copy its value to the persistent variable vector . In order to implement all this we use the following persistent variables:
- •
a vector containing in binary the time one step after the previous visit of the current cell (the exponent of stands for “time after previous visit”) or, if the current cell has not been visited before, containing in binary the number [math],
- •
a vector containing in binary the current position of the tape head, that is, the position of the current cell,
- •
a vector giving in unary the symbol in the cell described by (here “unary” means: exactly one of the shared variables will be true, namely the one with being the symbol in the cell described by ),
In fact, the current cell may have been visited several times already. Of course only the -successor of the point corresponding to the previous visit (that is, corresponding to the very last visit of the cell before the current visit, not earlier visits) should be allowed to copy the value of its vector to . In order to determine the right point, we are going to use an additional Boolean
- •
variable (which is neither persistent nor shared) saying whether the current point is active or not.
We shall explain later how all this works. Finally, there are two more vectors of persistent variables that are needed for changing the values of the shared variable vectors and :
- •
a vector containing in binary the current time of the computation minus one, unless the cloud corresponds to the first node in the computation tree — in that case the value of this vector is irrelevant,
- •
a vector containing in binary the previous position of the tape head, that is, the position of the cell that has just been left, unless the cloud corresponds to the first node in the computation tree — in that case the value of this vector is irrelevant.
Now we come to the formal definition of the formula . The formula will have the following structure:
[TABLE]
The formula will contain the following propositional variables:
[TABLE]
For and natural numbers we use as an abbreviation for . These formulas are the shared variables we talked about above.
We are now going to define the subformulas of . We will use the abbreviations introduced above, in Table 1, in Table 2, and in Table 3.
The following formula makes sure that certain propositional variables are persistent:
[TABLE]
The following formula makes sure that in each of the vectors of shared or persistent variables that describe in a unary way the current state respectively the written symbol exactly one variable is true:
[TABLE]
The vector will satisfy the same uniqueness condition automatically due to another formula (due to the formula ).
The following formula ensures that the shared variables in the cloud corresponding to the first node in a computation tree have the correct values. The computation starts at time [math] with the tape head at position and in the state . The vector will automatically get the correct value due to the formulas and , that will be introduced next. For the vectors and we do not need to fix any values.
[TABLE]
The following formula ensures that whenever an initial symbol on the tape is requested (by a point with persistent time equal to [math]) it is stored in a persistent vector of this point.
[TABLE]
We explain this formula. By another formula we will ensure that whenever a cell is visited for the first time there will be an “active” point storing the position of this cell in a persistent vector and such that its persistent time vector has the binary value [math]. The formula above ensures that the persistent vector in this point stores the correct initial symbol in this cell. This is either a symbol of the input string or the blank .
The following formula ensures that whenever a symbol that has just been written on the tape is requested (by an active point with the correct persistent time ) then it is copied into a persistent vector of this point.
[TABLE]
The following formula ensures that the shared variable vector describes the symbol in the current cell.
[TABLE]
where
[TABLE]
We explain these formulas. The formula enforces the existence of an “active” point in the current cloud that contains in the persistent vector the number of the current cell and that we wish to force to contain in the persistent vector the time one step after the previous visit of this cell, if this cell has been visited before, or the value [math], otherwise. How can we enforce that? We make essential use of the left commutativity property. The point whose existence is ensured by the formula has -predecessors in all clouds corresponding to the nodes on the path in the accepting tree from the root to the node corresponding to the current cloud. Since we demand the time stored in binary in the persistent variable must be identical with the time of one of the clouds corresponding to a node on this path. The formula ensures that if it is positive then it can be equal to the time of a cloud corresponding to a node on this path only when , that is, only when in the step leading to this node something has been written into the current cell. So, if the current cell has not been visited before, the binary value of must be [math]. Then the formula will ensure that the persistent variable gets the correct value. Otherwise, when the cell has been visited before, in fact, it may have been visited several times already. In this case, we have to make sure that the number stored in is the time after the very last visit to this cell immediately before the current visit. This is ensured by the formulas and . If the number stored in were strictly smaller than the the time after the very last visit to this cell immediately before the current visit then, due to the corresponding point would be set to “inactive”, and, due to , also its -successor would stay inactive. But this would apply also to the point in the current cloud which is supposed to be active and to contain the correct value in according to formula . Thus, the first four subformulas of ensure that the current cloud contains an active point that contains in the persistent vector the number of the current cell and that contains in the persistent vector the time one step after the previous visit of this cell, if this cell has been visited before, or the value [math], otherwise. Finally, the formula makes sure that the value of (which contains the symbol written into the current cell during the previous visit of this cell, or, if the current cell has not been visited before, the initial symbol in this cell) is copied into the shared variable vector .
Next, we wish to define the formula that describes the computation steps. We have to distinguish between the two cases whether the tape head is going to move to the left or to the right. If in a computation step the symbol is written into the current cell, if the tape head moves to the right, and if the new state after this step is the state , then the following formula guarantees the existence of a point and its cloud with suitable values in the shared variable vectors .
We explain this formula. The first four lines of this formula take care that the two binary counters and for the current time and for the current position of the tape head are incremented at the same time. This is similar to the formula in Subsection A.1. Furthermore, also the persistent vectors (that we will not need otherwise) and (that we use again in the fifth line of this formula) get the correct values. The fifth line ensures that the shared variable vectors , and of the current point get the correct values. The shared variable vector will get the correct value due to the formulas , , and .
[TABLE]
If in a computation step the symbol is written into the current cell, if the tape head moves to the left, and if the new state after this step is the state , then the following formula guarantees the existence of a point and its cloud with suitable values in the shared variables.
[TABLE]
This formula is very similar to the previous one with the exception that here the binary counter for the position of the tape head is decremented.
The computation is modeled by the following subformula. Remember that is the disjoint union of the sets , , , .
[TABLE]
Finally, the subformula is defined as follows.
[TABLE]
We have completed the description of the formula for . It is clear that is a bimodal formula, for any . We still have to show two claims:
The function can be computed in logarithmic space. 2. 2.
For any ,
[TABLE]
The first claim is shown in the following section. The two directions of the equivalence in the second claim are shown afterwards in separate sections.
A.3 LOGSPACE Computability of the Reduction
We wish to show that the function can be computed in logarithmic space. This is shown by the same argument as the corresponding claim for the function in Subsection 4.2.
A.4 Construction of a Model
In this section we show for any , if then the bimodal formula is -satisfiable. Let us assume . We are going to explicitly define an -product model of .
There exists an accepting tree of on input , where is the set of nodes of , where is the set of edges, and where the function labels each node with a configuration (remember the discussion about the description of configurations at the beginning of Subsection A.2). Let be the root of . We will now construct an -product model of . We define an -frame by
[TABLE]
That means, for any we have iff in the tree there is a path from to . We define an -frame by
[TABLE]
Then the product frame with and with and defined as in [8, Definition 2.3] is an -product frame. We still need to define a suitable valuation . We define the valuation as follows.
[TABLE]
for ,
[TABLE]
for ,
[TABLE]
for ,
[TABLE]
for ,
[TABLE]
We have defined an -product model . We claim that in this model . For an illustration of an important detail of the model see Figure 7.
First, we observe that for and natural numbers as well as for the truth value of the variable in the point does not depend on . Hence, all these variables are persistent. So,
[TABLE]
Similarly, for and natural numbers as well as for the truth value of the variable in the point does not depend on . Note that for the set
[TABLE]
is the -equivalence class of . All of the vectors of shared variables have the expected values: for and . We see
[TABLE]
and for and we see
[TABLE]
Similarly, for the vectors of persistent variables we see, for :
[TABLE]
It is straightforward to check that for all
[TABLE]
(in fact, in order to achieve we made a somewhat arbitrary choice for the value of in , for and ). Hence, we have
[TABLE]
It is clear as well that
[TABLE]
As none of the nodes in the accepting tree is labeled with a configuration with the state we have , for all , hence
[TABLE]
We still need to show that
[TABLE]
It is sufficient to show that, for all ,
[TABLE]
First, let us consider the formula . We wish to show that
[TABLE]
for all . Nothing needs to be shown if is not true. So, let us assume that . We noted above that the assumption implies that the cell has not been visited before on the computation path from to . Hence, , where is the initial symbol in the cell . We obtain . So, if the number satisfies then , otherwise . Remember that . We have shown .
Next, we consider the formula and show that
[TABLE]
for all . Let us assume
[TABLE]
(otherwise, nothing needs to be shown). The condition implies and that the binary value of the vector in the point is equal to the time of the previous visit of the cell on the computation path from to . Note that . The condition means . Now the condition implies that is an element of the path from to . Actually, due to the node is exactly the computation node on the computation path from to after the previous visit of the cell . Thus, the symbol written during this visit and described by the value of at the point is just the symbol still contained in the same cell when the computation node is reached. Hence, we have . For later purposes we note that for the same reason we have as well. We have shown .
Next, we consider the formula . We wish to show that
[TABLE]
for all . We show this separately for the five subformulas of . First, we show
[TABLE]
that is,
[TABLE]
Indeed, it is clear that and that and . Furthermore, the binary value of in the point is either the time of the previous visit of the cell on the path from to , if this cell has been visited before on this path, or [math], otherwise. In any case we obtain . Next, we show
[TABLE]
that is,
[TABLE]
Actually, we have seen this already in the proof of above. Next, we show
[TABLE]
that is,
[TABLE]
For the sake of a contradiction, let us assume and . Then is a node on the path from to . Due to we have . And due to the node must have the property . That means that the cell has been visited before on the path from to . But under these circumstances, the binary value of at the point is equal to where is the last node on the path from to with the property . Note that is a node on the path from to with the property . On the other hand, the condition implies . That is a contradiction. We have shown . Next,we show
[TABLE]
that is,
[TABLE]
This is clear from the definition of .
We come to the last subformula of and show
[TABLE]
that is,
[TABLE]
The condition implies that is a node on the path from to . The condition says that . We claim that . Once we have shown this, of course, we obtain . For the sake of a contradiction, let us assume . Then the cell has been visited before on the path from to . Let be the last node before on the path from to with . We obtain . For the binary value of in we obtain . Finally, the condition implies . By putting all this together we arrive at the following contradiction:
[TABLE]
We have shown .
Finally, we have to show that
[TABLE]
for all . We will separately treat the conjunctions over the set and over the set . Let us first fix a pair and let us assume that is a point with . We have to show that there is an element such that or that there is an element such that . As is an accepting tree and the state of is an element of , the node is an inner node of , hence, it has a successor . Let us assume that is the element of the transition relation that leads from to (the case that this element is of the form is treated analogously). We claim that then
[TABLE]
In fact, we observe and . We claim that the two points and have the properties formulated in the formula . Let us check this. Let us assume that, for some and for some ,
[TABLE]
The number is an element of because is an inner point of the tree and the length of any computation path is at most . The number is an element of because the computation starts in cell and during each computation step the tape head can move at most one step to the left or to the right. We obtain and . As we obtain
[TABLE]
and
[TABLE]
And as and we conclude that
[TABLE]
Finally, the condition
[TABLE]
is obviously satisfied and the condition
[TABLE]
follows from the fact that is the element of the transition relation that leads from to . This ends the treatment of the conjunctions over the set in the formula . Let us now consider a pair . Let us assume that is a point such that . We have to show that for all elements we have and for all elements we have . Let us consider an arbitrary element (the case of an element is treated analogously). As and is an accepting tree, in there is a successor of such that the element leads from to . Above, we have already seen that this implies
[TABLE]
Thus, we have shown for all . This ends the proof of the claim that in the -product model that we constructed for we have .
A.5 Existence of an Accepting Tree
We come to the other direction. Let . We wish to show that if is -satisfiable then . We will show that any -product model essentially contains an accepting tree of the Alternating Turing Machine on input . Of course, this implies .
Let us sketch the main idea. We will consider an -product model of . And we will consider partial trees of on input as considered in Subsection 3.3, for any . First, we will show that a certain very simple partial tree of on input “can be mapped to” the model (later we will give a precise meaning to “can be mapped to”). Then we will show that any partial tree of on input that can be mapped to the model and that is not an accepting tree of on input can be properly extended to a strictly larger partial tree of on input that can be mapped to the model as well. If there would not exist an accepting tree of on input then we would obtain an infinite strictly increasing sequence of partial trees of on input . But we show that this cannot happen by giving a finite upper bound on the size of partial trees of on input .
Let be a string such that the formula is -satisfiable. We set . Let be an -frame, let be an -frame, let be a function such that the quadruple where and are defined as in [8, Definition 2.3] is an -product model, and let be a point with . The quintuple
[TABLE]
will be important in the following. We claim that we can assume without loss of generality that for all and . Otherwise, instead of we could consider the set and instead of we could consider the set the -equivalence class of and the restrictions resp. of resp. to . By structural induction one shows that for any bimodal formula and for any ,
[TABLE]
So, we shall assume that , for all , and . Note that this implies that if is a formula with then, for all , we have .
For every , the set
[TABLE]
is the -equivalence class (short: cloud) of any element whose first component is . Remember that for every -equivalence class and every shared variable for and natural numbers , the truth value of this shared variable is the same in all elements of the -equivalence class.
Partial trees of on input as introduced in Subsection 3.3 will play an important role in the following. We will write a partial tree of on input similarly as in Subsection 3.3 as a triple , but with the difference that we will describe configurations as at the beginning of Subsection A.2: the labeling function will be a function of the form . If is a partial tree of on input with root then a function is called a morphism from to if it satisfies the following four conditions:
. 2. 2.
. 3. 3.
\begin{array}[t]{l}(\forall v\in V\setminus\{\mathit{root}\})\,(\exists x\in W_{2})\\ (\pi(v),x)\models\bigl{(}(\underline{\alpha}^{\mathrm{prevpos}}=\mathrm{bin}_{N+1}(\mathit{pos}(\mathit{pred}(v))))\wedge\alpha^{\mathrm{written}}_{\mathit{written}(v)}\bigr{)}\end{array}. 4. 4.
\begin{array}[t]{l}(\forall v\in V)\,(\exists x\in W_{2})\\ (\pi(v),x)\models\bigl{(}(\underline{\alpha}^{\mathrm{time}}=\mathrm{bin}_{N}(\mathit{time}(v)))\wedge(\underline{\alpha}^{\mathrm{pos}}=\mathrm{bin}_{N+1}(\mathit{pos}(v)))\\ \qquad\qquad\qquad\wedge\alpha^{\mathrm{state}}_{\mathit{state}(v)}\wedge\alpha^{\mathrm{read}}_{\mathit{read}(v)}\bigr{)}.\end{array}
We say that can be mapped to if there exists a morphism from to . Below we shall prove the following lemma.
Lemma A.3**.**
If a partial tree of on input can be mapped to and is not an accepting tree of on input then there exists a partial tree of on input that can be mapped to and that satisfies .
Before we prove this lemma, we deduce the desired assertion from it. Let
[TABLE]
Then, due to Condition III in the definition of a “partial tree of on input ”, any node in any partial tree of on input has at most successors. As any computation of on input stops after at most steps, any partial tree of on input has at most
[TABLE]
nodes.
We claim that the rooted and labeled tree
[TABLE]
is a partial tree of on input and that it can be mapped to . Indeed, Condition I in the definition of a “partial tree of on input ” is satisfied because the node is labeled with the initial configuration of on input . Conditions II, III, and IV are satisfied because does not have any inner nodes. Condition is satisfied because and, due to (this is a part of ) and (this follows from ) we obtain . Thus, is indeed a partial tree of on input . Now we show that can be mapped to . Of course, we define the function by .
The condition is true by definition. 2. 2.
The tree does not have any edges, that is, its set of edges is empty. So, the second condition is satisfied. 3. 3.
The third condition does not apply to the tree because has only one node, its root. 4. 4.
On the one hand, we have
[TABLE]
[TABLE]
On the other hand, the condition says
[TABLE]
We still wish to show . We have . This implies , and this implies that there exists some with
[TABLE]
hence, with
[TABLE]
Now implies . Finally, the condition
[TABLE]
implies , and this implies .
If there would not exist an accepting tree of on input then, starting with and using Lemma A.3, we could construct an infinite sequence of partial trees of on input that can be mapped to such that the number of nodes in these trees is strictly increasing. But we have seen that any partial tree of input can have at most nodes. Thus, there exists an accepting tree of on input . We have shown .
In order to complete the proof of Theorem A.1 it remains to prove Lemma A.3.
Proof of Lemma A.3.
Let be a partial tree of on input that is not an accepting tree of on input and that can be mapped to . Then has a leaf such that the state is either an element of or of . First we treat the case that it is an element of , then the case that it is an element of . Let be a morphism from to .
So, let us assume that . We define . As is a morphism from to there exists an with
[TABLE]
Hence, due to ,
[TABLE]
Let us assume there is an element such that (the other case, the case when there is an element such that , is treated analogously). We claim that we can define the new tree as follows:
- •
where is a new element (not in ),
- •
,
- •
\widetilde{c}(x):=\begin{cases}c(x)&\text{for all }x\in V,\\ c^{\prime}&\text{for }x=\widetilde{v},\text{ where c^{\prime}c(\widehat{v})}\\ &\text{in the computation step given by }((q,\eta),(r,\theta,\mathit{left}))\in\delta.\end{cases}
We have to show that is a partial tree of on input . Condition I in the definition of “a partial tree of on input ” is satisfied because has the same root as , and the label of the root does not change. A node in is an internal node of if, and only if, it is either an internal node of or equal to . For internal nodes of Conditions II, III, and IV are satisfied by assumption (and due to the fact that the labels of nodes in do not change when moving from to ). The new internal node satisfies Condition II by our definition of . Condition III is satisfied for because has exactly one successor. And Condition IV does not apply to because . A node in is a leaf if, and only if, it is either equal to or a leaf in different from . For the leaves in different from Condition is satisfied by assumption (and due to the fact that the labels of nodes in do not change). Finally, we have to show that Condition is satisfied for the new leaf in as well. We postpone this until after the definition of a morphism from to .
We also have to show that can be mapped to . Let us define a function that we will show to be a morphism from to . As is an element of a partial tree of on input with , at least one more computation step can be done. As any computation of on input stops after at most steps, we observe that the number satisfies . Then . We set . Together with we conclude . As during each computation step, the tape head can move at most one step to the left or to the right and as the computation started in position the number satisfies . Then . We set . Together with we conclude . Thus, we have
[TABLE]
Due to there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
We claim that we can define the desired function by
[TABLE]
Before we show that is a morphism from to , let us complete the proof that is a partial tree of on input . We still need to show that Condition is satisfied for the new leaf in as well. It is sufficient to show that the state of the configuration is not the rejecting state . But this follows from and (this follows from ). We have shown that is a partial tree of on input .
Now we show that is a morphism from to . The first condition in the definition of a “morphism from to ” is satisfied because . For the second condition let us consider with . We have to show . There are two possible cases.
- •
In the case we have and, hence, . As and we obtain .
- •
The other possible case is and . But we know , , and .
Next, we verify that the third condition in the definition of a “morphism from to ” is satisfied. For it is satisfied by assumption (and by and ). For it is sufficient to show that
[TABLE]
(remember that ). These are really two conditions. We prove them separately.
- •
In the tree we have , and in we have as well. The assumption , for some , implies , and the conditions and as well as the persistence of imply .
- •
In we have . And we have , hence, .
We come to the fourth condition in the definition of a “morphism from to ”. It is satisfied for by assumption (and due to and ). We still need to show that it is satisfied for . Remember . It is sufficient to show
[TABLE]
This assertion consists really of four assertions. We treat them one by one.
- •
In the trees and we have , and in the tree we have . We have already seen that and that . Of course, we get
[TABLE]
The conditions
[TABLE]
and the persistence of imply .
- •
In the trees and we have , and in the tree we have . We have already seen , and . Of course, we get
[TABLE]
The conditions
[TABLE]
and the persistence of imply .
- •
We have . And we have .
- •
Let in . We wish to show . We remark that the proof is a formal version of the informal explanation after the definition of the formula . It is sufficient to show that there is some with . The condition implies that there exists some such that
[TABLE]
Remember that the binary value of in and, hence, also in , is equal to and that the binary value of in and, hence, also in , is equal to . Hence, the binary value of in is equal to . Let be the unique number in with . Let be the unique node in the computation path in from to with .
First, we claim that for all nodes on the path from to . Any such satisfies . We obtain , hence, . If then due to , we would obtain . But this is a contradiction to the condition with which we started. Thus, for all nodes on the path from to we have .
Can there be a node in the path from to with ? We claim that this is not the case. Indeed, if there were such a then for this node we would have . But then would imply in contradiction to what we have just shown. Hence, we have shown that there is no node in the path from to with . Let us now distinguish the two cases and .
First we treat the case . Then . We have just seen that the cell has not been visited before on the path from to . Hence, the initial symbol in the cell is still the symbol in this cell when the node is reached. Thus is the initial symbol in this cell. Due to we obtain . Due to we obtain .
Finally, we treat the case . Then . And we have just seen that the cell has not been visited before on the path from to . But we claim that it has been visited in the predecessor of . Indeed, we have (\widetilde{\pi}(v_{t}),z)\models\bigl{(}(\underline{X}^{\text{time-apv}}>\mathrm{bin}_{N}(0))\wedge(\underline{X}^{\text{time-apv}}=\underline{\alpha}^{\mathrm{time}})\wedge B^{\mathrm{active}}\bigr{)}. Hence, due to , we obtain . Above we have seen that the binary value of in is . As is persistent, the binary value of in is as well. Hence, the binary value of in is as well. That implies . We have shown that the predecessor of the node is the last node before in which the cell has been visited. Hence, the symbol that is read when the node is reached, has been written in the computation step from to . Hence, we have . Due to we obtain . As above in the other case, due to , we finally obtain .
Thus, is not only a partial tree of on input but can also be mapped to . This ends the treatment of the case .
Now we consider the other case, the case . We define . Let
[TABLE]
be the elements of where and , for . We claim that we can define the new tree as follows:
- •
where are new (not in ) pairwise different elements,
- •
,
- •
\widetilde{c}(x):=\begin{cases}c(x)&\text{for all }x\in V,\\ c^{\prime}_{m}&\text{for }x=\widetilde{v}_{m},\text{ where c^{\prime}_{m} is the configuration that is reached from }c(\widehat{v})\\ &\text{in the computation step given by }((q,\eta),(r_{m},\theta_{m},\mathit{dir}_{m}))\in\delta.\end{cases}
Before we show that is a partial tree of on input , we define a function that we will show to be a morphism from to . Since can be mapped to , we have
[TABLE]
for some , hence, due to ,
[TABLE]
As in the case one shows that the numbers and satisfy and , and one defines
[TABLE]
As in the case one obtains
[TABLE]
Let us consider some . If then, due to , there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
Similarly, if then, due to , there exist an element and an element such that as well as
[TABLE]
and
[TABLE]
We claim that we can define the desired function by
[TABLE]
Similarly as in the case one shows that is a partial tree of on input . Note that also Condition IV is satisfied for . Finally, similarly as in the case one shows that is a morphism from to . This ends the treatment of the case . We have proved Lemma A.3. ∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] S. R. Buss. The Boolean formula value problem is in ALOGTIME. In A. V. Aho, editor, Proceedings of the 19th Annual ACM Symposium on Theory of Computing, New York , pages 123–131. ACM, 1987.
- 2[2] A. K. Chandra, D. C. Kozen, and L. J. Stockmeyer. Alternation. ACM , 28(1):114–133, Jan. 1981.
- 3[3] A. K. Chandra and L. J. Stockmeyer. Alternation. In 17th Annual Symposium on Foundations of Computer Science, 1976 , pages 98–108. IEEE, 1976.
- 4[4] P. Clote. Computation models and function algebras. In Handbook of Computability Theory , volume 140 of Stud. Logic Found. Math. , pages 589–681. North-Holland, Amsterdam, 1999.
- 5[5] A. Dabrowski, L. S. Moss, and R. Parikh. Topological reasoning and the logic of knowledge. Ann. Pure Appl. Logic , 78:73–110, 1996.
- 6[6] B. Heinemann. Augmenting subset spaces to cope with multi-agent knowledge. In International Symposium on Logical Foundations of Computer Science , pages 130–145. Springer, 2016.
- 7[7] B. Heinemann. A subset space perspective on agents cooperating for knowledge. In International Conference on Knowledge Science, Engineering and Management , pages 503–514. Springer, 2016.
- 8[8] P. Hertling and G. Krommes. EXPSPACE EXPSPACE \mathrm{EXPSPACE} -completeness of the logics K 4 × S 5 K 4 S 5 \mathrm{K 4\times S 5} and S 4 × S 5 S 4 S 5 \mathrm{S 4\times S 5} and the logic of subset spaces, part 1: ESPACE ESPACE \mathrm{ESPACE} -algorithms, 8 2019. Submitted for publication.
