Showing papers on "Undecidable problem published in 1995"

What Can Be Computed Locally

Abstract: The purpose of this paper is a study of computation that can be done locally in a distributed network, where "locally" means within time (or distance) independent of the size of the network. Locally checkable labeling (LCL) problems are considered, where the legality of a labeling can be checked locally (e.g., coloring). The results include the following: There are nontrivial LCL problems that have local algorithms. There is a variant of the dining philosophers problem that can be solved locally. Randomization cannot make an LCL problem local; i.e., if a problem has a local randomized algorithm then it has a local deterministic algorithm. It is undecidable, in general, whether a given LCL has a local algorithm. However, it is decidable whether a given LCL has an algorithm that operates in a given time $t$. Any LCL problem that has a local algorithm has one that is order-invariant (the algorithm depends only on the order of the processor IDs).

Embedding defaults into terminological knowledge representation formalisms

Abstract: We consider the problem of integrating Reiter's default logic into terminological representation systems. It turns out that such an integration is less straightforward than we expected, considering the fact that the terminological language is a decidable sublanguage of first-order logic. Semantically, one has the unpleasant effect that the consequences of a terminological default theory may be rather unintuitive, and may even vary with the syntactic structure of equivalent concept expressions. This is due to the unsatisfactory treatment of open defaults via Skolemization in Reiter's semantics. On the algorithmic side, we show that this treatment may lead to an undecidable default consequence relation, even though our base language is decidable, and we have only finitely many (open) defaults. Because of these problems, we then consider a restricted semantics for open defaults in our terminological default theories: default rules are applied only to individuals that are explicitly present in the knowledge base. In this semantics it is possible to compute all extensions of a finite terminological default theory, which means that this type of default reasoning is decidable. We describe an algorithm for computing extensions and show how the inference procedures of terminological systems can be modified to give optimal support to this algorithm.

Regular Tree Languages And Rewrite Systems

Abstract: We present a collection of results on regular tree languages and rewrite systems. Moreover we prove the undecidability of the preservation of regularity by rewrite systems. More precisely we prove that it is undecidable whether or not for a set E of equations the set E(R) congruence closure of set R is a regular tree language whenever R is a regular tree language. It is equally undecidable whether or not for a confluent and terminating rewrite system S the set S(R) of ground S-normal forms of set R is a regular tree language whenever R is a regular tree language. Finally we study fragments of the theory of ground term algebras modulo congruence generated by a set of equations which can be compiled in a terminating, confluent rewrite system which preserves regularity.

On the Undecidability of Implications between Embedded Multivalued Database Dependencies

Abstract: The implication and finite implication problems for embedded multivalued database dependencies are both shown to be algorithmically undecidable. The proof is by an interpretation of semigroup word problems via systems of permuting equivalence relations into database dependencies. In contrast, it is shown that for each fixed premise H one has a decision procedure for implications H ? F.

Undecidable boundedness problems for datalog programs

Abstract: A given Datalog program is bounded if its depth of recursion is independent of the input database. Deciding boundedness is a basic task for the analysis of database logic programs. The undecidability of Datalog boundedness was first demonstrated by Gaifman et al. [7]. We introduce new techniques for proving the undecidability of (various kinds of) boundedness, which allow us to considerably strengthen the results of Gaifman et al. [7]. In particular, (1) we use a new generic reduction technique to show that program boundedness is undecidable for arity 2 predicates, even with linear rules; (2) we use the mortality problem of Turing machines to show that uniform boundedness is undecidable for arity 3 predicates and for arity 1 predicates when ≠ is also allowed; (3) by encoding all possible transitions of a two-counter machine in a single rule, we show that program (resp., predicate) boundedness is undecidable for two linear rules (resp., one rule and a projection) and one initialization rule, where all predicates have small arities (6 or 7).

Checking Regular Properties of Petri Nets

Abstract: In this paper we consider the problem of comparing an arbitrary Petri net against one whose places may contain only a bounded number of tokens (that is, against a regular behaviour), with respect to trace set inclusion and equivalence, as well as simulation and bisimulation. In contrast to the known result that language equivalence is undecidable, we find that all of the above are in fact decidable. We furthermore demonstrate that it is undecidable whether a given Petri net is either trace equivalent or simulation equivalent to any (unspecified) bounded net.

Semantic Query Optimization in Datalog Programs.

Abstract: Semantic query optimization refers to the process of using integrity constraints (ic ‘s) in order to optimize the evaluation of queries. The process is well understood in the case of unions of select-project-join queries (i. e., nonrecursive datalog). For arbitrary datalog programs, however, the issue has largely remained an unsolved problem. This paper studies this problem and shows when semantic query optimization can be completely done in recursive rules provided that order constraints and negated EDB subgoals appear only in the recursive rules, but not in the it’s. If either order constraints or negated EDB subgoals are introduced in it’s, then the problem of semantic query optimization becomes undecidable. Since semantic query optimization is closely related to the containment problem of a datalog program in a union of conjunctive queries, our results also imply new decidability and undecidability results for that problem when order constraints and negated EDB subgoals are used.

On the Model Checking Problem for Branching Time Logics and Basic Parallel Processes

Abstract: We investigate the model checking problem for branching time logics and Basic Parallel Processes. We show that the problem is undecidable for the logic ∀L(O, F, U) (equivalent to CTL*) in the usual interleaving semantics, but decidable in a standard partial order interpretation.

Simultaneous Regid E-Unification Is Undecidable

Abstract: Simultaneous rigid E-unification was introduced in 1987 by Gallier, Raatz and Snyder. It is used in the area of automated reasoning with equality in extension procedures, like the tableau method or the connection method. There were several faulty proofs of the decidability of this problem. We prove the undecidability of simultaneous rigid E-unification using reduction of Hubert's tenth problem. As a consequence, we obtain the undecidability of the ∃*-fragment of intuitionistic logic with equality and representability of recursively enumerable sets by solutions of simultaneous rigid E-unification.

On unification of terms with integer exponents

Abstract: We consider terms in which some patterns can be repeatedn times.n is an integer variable which is part of the syntax of the terms (and hence may occur more than once in them). We show that unification of such terms is decidable and finitary, extending Chen and Hsiang's result onp-term unification. Finally, extending slightly the syntax yields an undecidable unification problem.

High Undecidability of Weak Bisimilarity for Petri Nets

Abstract: It is shown that the problem whether two labelled place/transition Petri nets (with initial markings) are weakly bisimilar is highly undecidable — it resides at least at level ω of the hyperarithmetical hierarchy; on the other hand it belongs to Σ1 1 (the first level of the analytical hierarchy). It contrasts with Π0 1-completeness of the same problem for trace (language) equivalence. Relations to similar problems for the process algebra BPP (Basic Parallel Processes) are also discussed.

Verifying Safety Properties of a Class of Infinite-State Distributed Algorithms

Abstract: We consider the problem of verifying correctness properties of a class of programs with states that are sets of ground atoms. Such programs can model specifications of telephone services, in which we are particularly interested. For this class of systems, we consider the problem of checking reachability properties. A large class of safety properties can also be reduced to the problem of checking reachability in a transformed system. The emphasis of our approach is on automated verification of such properties. Although the reachability problem is in general undecidable, we present a method for analyzing reachability properties, and show that it can be successfully applied to practical examples. The main idea of our method is the following. In order to check whether a certain set of “error” states can be reached from an initial state of the system, we first compute the set of “unsafe states” (i.e., states from which it is possible to reach an error state) as a fixpoint, and finally we prove that the initial state is not “unsafe”. We present the application of our method to an example of a simple telephone service.

Verifying infinite state processes with sequential and parallel composition

Abstract: We investigate the verification problem of infinite-state process w.r.t. logic-based specifications that express properties which may be nonregular. We consider the process algebra PA which integrates and strictly subsumes the algebras BPA (basic process algebra) and BPP (basic parallel processes), by allowing both sequential and parallel compositions as well as nondeterministic choice and recursion. Many relevant properties of PA processes are nonregular, and thus can be expressed neither by classical temporal logics nor by finite state o-automata. Properties of particular interest are those involving constraints on numbers of occurrences of events. In order to express such properties, which are nonregular in general, we use the temporal logic PCTL which combines the branching-time temporal logic CTL with Presburger arithmetics. Then we tackle the verification problem of guarded PA processes w.r.t. PCTL formulas. We mainly prove that, while this problem is undecidable for the full PCTL, it is actually decidable for the class of guarded PA processes (and thus for the class of guarded BPA's and guarded BPP's), and a large fragment of PCTL called PCTL+.

Finite queries do not have effective syntax

Abstract: A relational query is called finite, or sometimes safe, iff it yields a finite answer in every database state. The set of finite queries of relational calculus is known to be unsolvable. However, in many cases it is possible to impose syntactical restrictions on the class of queries that guarantee finiteness and do not reduce the expressive power of the calculus. We show that unfortunately this is not always the case, as we construct a recursive domain with decidable theory where any solvable (or enumerable, for that matter) subclass of queries either contains an infinite query, or misses a finite one. We show that, although any domain can always be extended to a domain with an effective syntax for finite queries, such extensions of our domain necessarily have undecidable theories. The reason decidability of domain matters is that this property is, in effect, equivalent to the ability to answer queries effectively. Using the same example, we further show undecidability of the problem of relative finiteness, which is, given a query and a database state, to decide upon finiteness of the query in this state. This settles two long-standing open problems in the theory of relational databases.

Analyses of unsatisfiability for equational logic programming

Abstract: The problem of unifying pairs of terms with respect to an equational theory (as well as detecting the unsatisfiability of a system of equations) is, in general, undecidable. In this work, we define a framework based on abstract interpretation for the (static) analysis of the unsatisfiability of equation sets. The main idea behind the method is to abstract the process of semantic unification of equation sets based on narrowing. The method consists of building an abstract narrower for equational theories, and executing the sets of equations to be detected for unsatisfiability in the approximated narrower. As an instance of our framework, we define a new analysis whose accuracy is enhanced by some simple loop-checking technique. This analysis can also be actively used for pruning the search tree of an incremental equational constraint solver, and can be integrated with other methods in the literature. Standard methods are shown to be an instance of our framework. To the best of our knowledge, this is the first framework proposed for approximating equational unification.

Effectiveness of data dependence analysis

Abstract: Data dependence testing is the basic step in detecting loop level parallelism in numerical programs. The problem is undecidable in the general case. Therefore, work has been concentrated on a simplified problem, affine memory disambiguation. In this simpler domain, array references and loops bounds are assumed to be linear integer functions of loop variables. Dataflow information is ignored. For this domain, we have shown that in practice the problem can be solved accurately and efficiently.(1) This paper studies empirically the effectiveness of this domain restriction, how many real references are affine and flow insensitive. We use Larus's llpp system(2) to find all the data dependences dynamically. We compare these to the results given by our affine memory disambiguation system. This system is exact for all the cases we see in practice. We show that while the affine approximation is reasonable, memory disambiguation is not a sufficient approximation for data dependence analysis. We propose extensions to improve the analysis.

On Some Decision Problems in Programming

Abstract: One of the central problems in programming is the correctness problem, i.e., the question of whether a program computes a given function. We choose a rather general formal semantical framework, effectively given topological T0-spaces, and study the problem to decide whether an element of the space is equal to a fixed element. Moreover, we consider the problems of deciding for two elements, whether they are equal and whether one approximates the other in the specialization order. These are one-one equivalent for a large class of spaces, including effectively given Scott domains. All these problems are undecidable. In most cases they are complete on some level of the arithmetical and/or the Boolean hierarchy. The complexity respectively depends on whether the fixed element is not finite and whether the space contains a nonfinite element. The problem of deciding whether an element is not finite is potentially ?02-complete and for domain-like spaces the membership problem of any nonempty set of nonfinite elements that intersects the effective closure of its complement is ?02-hard. If the given element is finite or the space contains only finite elements, the complexity also depends on the location of the given element in the specialization order and/or the boundedness of the set of lengths of all decreasing chains of basic open sets.

Response time analysis of EQL real-time rule-based systems

Abstract: Real-time rule-based expert systems are embedded decision systems that must respond to changes in the environments within stringent timing constraints. Given a program p, the response time analysis problem is to determine the response time of p. This problem consists of: determining whether or not the execution of p always terminates in bounded time; and computing the maximal execution time of p. The Equational Logic (EQL) language is a simple language designed for real-time applications. It has been proved by A.K. Mok (1989) that the response time analysis problem is undecidable if the program variables have infinite domains, and is PSPACE-hard in the case where all of the variables have finite domains. However, we have observed that the use of a simple syntactic and semantic check on programs coupled with other techniques such as state space graph checks can dramatically reduce the time needed in the analysis. There are sets of syntactic and semantic constraint assertions such that if the set S of rules satisfies any of them, then the execution of S always terminates in bounded time. Each of these sets of syntactic and semantic constraint assertions is called a Special Form. The focus of the paper is on proving the existence of two Special Forms and determining tight response time upper bounds of EQL rule-based programs. For each known Special Form, an algorithm used to calculate the maximal response time of programs satisfying this Special Form is presented. Additionally, to enhance the applicability of the proposed algorithms, we show how the General Analysis Algorithm can be used with these algorithms. >

Chaotic neural nets, computability, and undecidability: Toward a computational dynamics

Abstract: In this article we intend to analyze a chaotic system from the standpoint of its computation capability. to pursue this aim, we refer to a complex chaotic dynamics that we characterize via its symbolic dynamics. We show that these dynamic systems are subjected to some typical undecidable problems. Particularly, we stress the impossibility of deciding on a unique invariant measure. This depends essentially on the supposition of the existence of a fixed universal grammar. the suggestion is thus of justifying a contextual redefinition of the grammar as a function of the same evolution of the system. We propose on this basis a general theorem for avoiding undecidable problems in computability theory by introducing a new class of recursive functions on different axiomatizations of numbers. From it a series expansion on n algebraic fields can be defined. In such a way, we are able to obtain a very fast extraction procedure of unstable periodic orbits from a generic chaotic dynamics. the computational efficiency of this algorithm allows us to characterize a chaotic system by the complete statistics of its unstable cycles. Some examples of these two techniques are discussed. Finally, we introduce the possibility of an application of this same class of recursive functions to the calculus of the absolute minimum of energy in neural nets, as far as it is equivalent to a well-formed formula of a first-order predicate calculus. © 1995 John Wiley & Sons, Inc.

Applying an update method to a set of receivers

Abstract: In the context of object databases, we study the application of an update method to a collection of receivers rather than to a single one. The obvious strategy of applying the update to the receivers one after the other, in some arbitrary order, brings up the problem of order independence. On a very general level, we investigate how update behavior can be analyzed in terms of certain schema annotations, called colorings. We are able to characterize those colorings that always describe order-independedent updates. We also consider a more specific model of update methods implemented in the relational algebra. Order-independence of such algebraic methods is undecidable in general, but decidable if the expressions used are positive. Finally, we consider an alternative parallel strategy for set-oriented applications of algebraic update methods and compare and relate it to the sequential strategy.

3-processor tasks are undecidable

Abstract: This note addresses the complexity of the following fundament al question [3, 4]: Given an explicit specification of a distributed task, is it solvable, i.e. is there a wait-free readwrite protocol that solves it? It was known that for two processors the problem can be reduced to connectivity [1]. In this note we show that for three processors there is no algorithm to determine the solvability of a task. Furthermore, this is true even for very simple tasks, such as tasks with no inputs; such a task is given simply as a finite collection of output tuples.

Occurrence problem for free solvable groups

Abstract: We study the problem on the existence of an algorithm verifying whether systems of linear equations over a group ring of a free metabelian group are solvable. The occurrence problem for free solvable groups of derived length ≥ 3is proved undecidable. We give an example of a group with undecidable word problem which is finitely presented in a variety of solvable groups and is defined by the relations from the last commutator subgroup.

Some remarks on the decidability of the generation problem in LFG- and PATR-style unification grammars

Abstract: In this paper, we prove the decidability of the generation problem for those unification grammars which are based on context-free phrase structure rule skeletons, like e.g. LFG and PATR-II. The result shows a perhaps unexpected asymmetry, since it is valid also for those unification grammars whose parsing problem is undecidable, e.g. grammars which do not satisfy the off-line parsability constraint. The general proof is achieved by showing that the space of the derivations which have to be considered in order to decide the problem for a given input is always restricted to derivations whose length is limited by some fixed upper bound which is determined relative to the "size" of the input.

The Undecidability of the II$^4$ Theory for the R. E. Wtt and Turing Degrees

Abstract: We show that the Π4-theory of the partial order of recursively enumerable weak truth-table degrees is undecidable, and give a new proof of the similar fact for r.e. T-degrees. This is accomplished by introducing a new coding scheme which consists in defining the class of finite bipartite graphs with parameters.

A Note on the Complexity of Restricted Attribute-Value Grammars

Abstract: The recognition problem for attribute-value grammars (AVGs) was shown to be undecidable by Johnson in 1988. Therefore, the general form of AVGs is of no practical use. In this paper we study a very restricted form of AVG, for which the recognition problem is decidable (though still NP-complete), the R-AVG. We show that the R-AVG formalism captures all of the context free languages and more, and introduce a variation on the so-called `off-line parsability constraint', the `honest parsability constraint', which lets different types of R-AVG coincide precisely with well-known time complexity classes.