301 research outputs found
Speeding up active mesh segmentation by local termination of nodes.
This article outlines a procedure for speeding up segmentation of images using active mesh systems. Active meshes and other deformable models are very popular in image segmentation due to their ability to capture weak or missing boundary information; however, where strong edges exist, computations are still done after mesh nodes have settled on the boundary. This can lead to extra computational time whilst the system continues to deform completed regions of the mesh. We propose a local termination procedure, reducing these unnecessary computations and speeding up segmentation time with minimal loss of quality
Local Termination: theory and practice
The characterisation of termination using well-founded monotone algebras has
been a milestone on the way to automated termination techniques, of which we
have seen an extensive development over the past years. Both the semantic
characterisation and most known termination methods are concerned with global
termination, uniformly of all the terms of a term rewriting system (TRS). In
this paper we consider local termination, of specific sets of terms within a
given TRS. The principal goal of this paper is generalising the semantic
characterisation of global termination to local termination. This is made
possible by admitting the well-founded monotone algebras to be partial. We also
extend our approach to local relative termination. The interest in local
termination naturally arises in program verification, where one is probably
interested only in sensible inputs, or just wants to characterise the set of
inputs for which a program terminates. Local termination will be also be of
interest when dealing with a specific class of terms within a TRS that is known
to be non-terminating, such as combinatory logic (CL) or a TRS encoding
recursive program schemes or Turing machines. We show how some of the
well-known techniques for proving global termination, such as stepwise removal
of rewrite rules and semantic labelling, can be adapted to the local case. We
also describe transformations reducing local to global termination problems.
The resulting techniques for proving local termination have in some cases
already been automated. One of our applications concerns the characterisation
of the terminating S-terms in CL as regular language. Previously this language
had already been found via a tedious analysis of the reduction behaviour of
S-terms. These findings have now been vindicated by a fully automated and
verified proof
Termination Detection of Local Computations
Contrary to the sequential world, the processes involved in a distributed
system do not necessarily know when a computation is globally finished. This
paper investigates the problem of the detection of the termination of local
computations. We define four types of termination detection: no detection,
detection of the local termination, detection by a distributed observer,
detection of the global termination. We give a complete characterisation
(except in the local termination detection case where a partial one is given)
for each of this termination detection and show that they define a strict
hierarchy. These results emphasise the difference between computability of a
distributed task and termination detection. Furthermore, these
characterisations encompass all standard criteria that are usually formulated :
topological restriction (tree, rings, or triangu- lated networks ...),
topological knowledge (size, diameter ...), and local knowledge to distinguish
nodes (identities, sense of direction). These results are now presented as
corollaries of generalising theorems. As a very special and important case, the
techniques are also applied to the election problem. Though given in the model
of local computations, these results can give qualitative insight for similar
results in other standard models. The necessary conditions involve graphs
covering and quasi-covering; the sufficient conditions (constructive local
computations) are based upon an enumeration algorithm of Mazurkiewicz and a
stable properties detection algorithm of Szymanski, Shi and Prywes
Speeding Up Active Mesh Segmentation by Local Termination of Nodes
This article outlines a procedure for speeding up segmentation of images using active mesh systems. Active meshes and other deformable models are very popular in image segmentation due to their ability to capture weak or missing boundary information; however, where strong edges exist, computations are still done after mesh nodes have settled on the boundary. This can lead to extra computational time whilst the system continues to deform completed regions of the mesh. We propose a local termination procedure, reducing these unnecessary computations and speeding up segmentation time with minimal loss of quality
Local Termination: theory and practice
The characterisation of termination using well-founded monotone algebras has
been a milestone on the way to automated termination techniques, of which we
have seen an extensive development over the past years. Both the semantic
characterisation and most known termination methods are concerned with global
termination, uniformly of all the terms of a term rewriting system (TRS). In
this paper we consider local termination, of specific sets of terms within a
given TRS. The principal goal of this paper is generalising the semantic
characterisation of global termination to local termination. This is made
possible by admitting the well-founded monotone algebras to be partial. We also
extend our approach to local relative termination. The interest in local
termination naturally arises in program verification, where one is probably
interested only in sensible inputs, or just wants to characterise the set of
inputs for which a program terminates. Local termination will be also be of
interest when dealing with a specific class of terms within a TRS that is known
to be non-terminating, such as combinatory logic (CL) or a TRS encoding
recursive program schemes or Turing machines. We show how some of the
well-known techniques for proving global termination, such as stepwise removal
of rewrite rules and semantic labelling, can be adapted to the local case. We
also describe transformations reducing local to global termination problems.
The resulting techniques for proving local termination have in some cases
already been automated. One of our applications concerns the characterisation
of the terminating S-terms in CL as regular language. Previously this language
had already been found via a tedious analysis of the reduction behaviour of
S-terms. These findings have now been vindicated by a fully automated and
verified proof
Generating Efficient, Terminating Logic Programs
The objective of control generation in logic programming is to automatically derive a computation rule for a program that is efficient and yet does not compromise program correctness. Progress in solving this important problem has been slow and, to date, only partial solutions have been proposed where the generated programs are either incorrect or inefficient. We show how the control generation problem can be tackled with a simple automatic transformation that relies on information about the depths of derivations. To prove correctness of our transform we introduce the notion of a semi delay recurrent program which generalises previous ideas in the termination literature for reasoning about logic programs with dynamic selection rules
Size-Change Termination, Monotonicity Constraints and Ranking Functions
Size-Change Termination (SCT) is a method of proving program termination
based on the impossibility of infinite descent. To this end we may use a
program abstraction in which transitions are described by monotonicity
constraints over (abstract) variables. When only constraints of the form x>y'
and x>=y' are allowed, we have size-change graphs. Both theory and practice are
now more evolved in this restricted framework then in the general framework of
monotonicity constraints. This paper shows that it is possible to extend and
adapt some theory from the domain of size-change graphs to the general case,
thus complementing previous work on monotonicity constraints. In particular, we
present precise decision procedures for termination; and we provide a procedure
to construct explicit global ranking functions from monotonicity constraints in
singly-exponential time, which is better than what has been published so far
even for size-change graphs.Comment: revised version of September 2
Optimal Collision/Conflict-free Distance-2 Coloring in Synchronous Broadcast/Receive Tree Networks
This article is on message-passing systems where communication is (a)
synchronous and (b) based on the "broadcast/receive" pair of communication
operations. "Synchronous" means that time is discrete and appears as a sequence
of time slots (or rounds) such that each message is received in the very same
round in which it is sent. "Broadcast/receive" means that during a round a
process can either broadcast a message to its neighbors or receive a message
from one of them. In such a communication model, no two neighbors of the same
process, nor a process and any of its neighbors, must be allowed to broadcast
during the same time slot (thereby preventing message collisions in the first
case, and message conflicts in the second case). From a graph theory point of
view, the allocation of slots to processes is know as the distance-2 coloring
problem: a color must be associated with each process (defining the time slots
in which it will be allowed to broadcast) in such a way that any two processes
at distance at most 2 obtain different colors, while the total number of colors
is "as small as possible". The paper presents a parallel message-passing
distance-2 coloring algorithm suited to trees, whose roots are dynamically
defined. This algorithm, which is itself collision-free and conflict-free, uses
colors where is the maximal degree of the graph (hence
the algorithm is color-optimal). It does not require all processes to have
different initial identities, and its time complexity is , where d
is the depth of the tree. As far as we know, this is the first distributed
distance-2 coloring algorithm designed for the broadcast/receive round-based
communication model, which owns all the previous properties.Comment: 19 pages including one appendix. One Figur
Non-termination using Regular Languages
We describe a method for proving non-looping non-termination, that is, of
term rewriting systems that do not admit looping reductions. As certificates of
non-termination, we employ regular (tree) automata.Comment: Published at International Workshop on Termination 201
- âŠ