Termination Of Loops Research Articles

Termination of triangular polynomial loops

AbstractWe consider the problem of proving termination for triangular weakly non-linear loops (twn-loops) over some ring $$\mathcal {S}$$ S like $$\mathbb {Z}$$ Z , $$\mathbb {Q}$$ Q , or $$\mathbb {R}$$ R . The guard of such a loop is an arbitrary quantifier-free Boolean formula over (possibly non-linear) polynomial inequations, and the body is a single assignment of the form $$\begin{bmatrix} x_1\\ \ldots \\ x_d \end{bmatrix} \leftarrow \begin{bmatrix} c_1 \cdot x_1 + p_1\\ \ldots \\ c_d \cdot x_d + p_d \end{bmatrix}$$ x 1 … x d ← c 1 · x 1 + p 1 … c d · x d + p d where each $$x_i$$ x i is a variable, $$c_i \in \mathcal {S}$$ c i ∈ S , and each $$p_i$$ p i is a (possibly non-linear) polynomial over $$\mathcal {S}$$ S and the variables $$x_{i+1},\ldots ,x_{d}$$ x i + 1 , … , x d . We show that the question of termination can be reduced to the existential fragment of the first-order theory of $$\mathcal {S}$$ S . For loops over $$\mathbb {R}$$ R , our reduction implies decidability of termination. For loops over $$\mathbb {Z}$$ Z and $$\mathbb {Q}$$ Q , it proves semi-decidability of non-termination.Furthermore, we present a transformation to convert certain non-twn-loops into twn-form. Then the original loop terminates iff the transformed loop terminates over a specific subset of $$\mathbb {R}$$ R , which can also be checked via our reduction. Moreover, we formalize a technique to linearize (the updates of) twn-loops in our setting and analyze its complexity. Based on these results, we prove complexity bounds for the termination problem of twn-loops as well as tight bounds for two important classes of loops which can always be transformed into twn-loops.Finally, we show that there is an important class of linear loops. where our decision procedure results in an efficient procedure for termination analysis, i.e., where the parameterized complexity of deciding termination is polynomial.

Simulation analysis of visual perception model based on pulse coupled neural network

Pulse-coupled neural networks perform well in many fields such as information retrieval, depth estimation and object detection. Based on pulse coupled neural network (PCNN) theory, this paper constructs a visual perception model framework and builds a real image reproduction platform. The model firstly analyzes the structure and generalization ability of neural network multi-class classifier, uses the minimax criterion of feature space as the splitting criterion of visual perception decision node, which solves the generalization problem of neural network learning algorithm. In the simulation process, the initial threshold is optimized by the two-dimensional maximum inter-class variance method, and in order to improve the real-time performance of the algorithm, the fast recurrence formula of neural network is derived and given. The PCNN image segmentation method based on genetic algorithm is analyzed. The genetic algorithm improves the loop termination condition and the adaptive setting of model parameters of PCNN image segmentation algorithm, but the PCNN image segmentation algorithm still has the problem of complexity. In order to solve this problem, this paper proposed an IGA-PCNN image segmentation method combining the improved algorithm and PCNN model. Firstly, it used the improved immune genetic algorithm to adaptively obtain the optimal threshold, and then replaced the dynamic threshold in PCNN model with the optimal threshold, and finally used the pulse coupling characteristics of PCNN model to complete the image segmentation. From the coupling characteristics of PCNN, junction close space of image and gray level characteristics, it determined the local gray mean square error of image connection strength coefficient. The feature extraction and object segmentation properties of PCNN come from the spike frequency of neurons, and the number of neurons in PCNN is equal to the number of pixels in the input image. In addition, the spatial and gray value differences of pixels should be considered comprehensively to determine their connection matrix. Digital experiments show that the multi-scale multi-task pulse coupled neural network model can shorten the total training time by 17 h, improve the comprehensive accuracy of the task test data set by 1.04%, and shorten the detection time of each image by 4.8 s compared with the series network model of multiple single tasks. Compared with the traditional PCNN algorithm, it has the advantages of fast visual perception and clear target contour segmentation, and effectively improves the anti-interference performance of the model.

Accurate control to run and stop chemical reactions via relaxation oscillators

Regulation of multiple reaction modules is quite common in molecular computation and synthetic genetic circuits through chemical reactions, as is always a headache for that sequential execution of modules goes against the intrinsically parallel nature of chemical reactions. Precisely switching multiple reaction modules both on and off acts as the core role in programming chemical reaction systems. Unlike setting up physical compartments or adding human intervention signals, we adopt the idea of chemical oscillators based on relaxation oscillation, and assign corresponding clock signal components into the modules to be regulated as catalysts. We mainly demonstrate our design process of oscillator model under the regulation task of three modules, and provide a suitable approach for automatic loop termination of the whole system. Analysis and numerical simulation are directly based on dynamical equations of the oscillator model, which can be translated into corresponding chemical reaction networks through mass-action kinetics.

The probabilistic termination tool amber

We describe the Amber tool for proving and refuting the termination of a class of probabilistic while-programs with polynomial arithmetic, in a fully automated manner. Amber combines martingale theory with properties of asymptotic bounding functions and implements relaxed versions of existing probabilistic termination proof rules to prove/disprove (positive) almost sure termination of probabilistic loops. Amber supports programs parametrized by symbolic constants and drawing from common probability distributions. Our experimental comparisons give practical evidence of Amber outperforming existing state-of-the-art tools.

Synthesizing ranking functions for loop programs via SVM

Termination of programs is probably the most famous undecidable problem in computer science. Despite this undecidability result, a lot of effort has been spent on improving algorithms that prove termination of loops, which is one of the fundamental aspects of software reliability analysis. These algorithms usually focus on finding an appropriate ranking function for the loop, which proves its termination. In this paper, we focus on handling the synthesis problem of nested ranking functions and multi-phase ranking functions for loop programs. We first reduce the problem of a nested ranking function synthesis to the existence problem of a hyperplane separating classes of data. This allows us to leverage Support-Vector Machines (SVM) techniques for the synthesis of nested ranking functions. SVM are supervised learning algorithms that are used to classify data; they work by finding a hyperplane separating data points parted into two classes. We show how to carefully define the data points so that the separating hyperplane gives rise to a nested ranking function for the loop. Then we use this algorithm for nested ranking functions synthesis as a subprocedure to devise a sound algorithm which incrementally synthesizes multi-phase ranking functions. Experimental results confirm the effectiveness of our SVM-based synthesis of nested and multi-phase ranking functions.

Sustainable vehicle routing problem on real-time roads: the restrictive inheritance-based heuristic algorithm

• This article aims to present an efficient vehicle routing algorithm for a real-time routing solution. • The recursive routing process reflects the vehicle's energy consumption mechanism and the effect of vehicle speeds on CO2 emissions. • The restrictive inheritance strategy and loop termination condition prevent high memory usage, redundancy, and infinite negative loop, leading to high computational efficiency and a Pareto-optimal solution. • The suggested method contributes to reducing energy consumption and CO2 emission and shows robustness in reflecting ever-changing road conditions. Road transportation is a substantial contributor to urban greenhouse gas (GHG) emissions. This article focuses on the energy-efficient vehicle routing problem, given the relationship between a vehicle's energy consumption and CO2 emission. Extensive studies have established the energy dissipation model considering road gradients, traffic flow, and road congestion, and the route searching process entails algorithm application. However, despite the efforts to overcome the trade-off between computational efficiency and solution quality, the probabilistic and randomized-based routing algorithms would be trapped into the local optima or compromise computational efficiency. Hence, this article aims to propose an efficient vehicle routing algorithm in the sustainable transportation domain. The method derives a Pareto-optimal solution in an acceptable execution time; furthermore, the embedded cost function includes energy dissipation and recuperation mechanism in hilly regions. For a real-world application, this article refers to road gradients and a real-time traffic API. The findings showed the amelioration of CO2 emissions and computational loads, thus corroborating the pragmatic aspect. The eco-oriented route decision connotes a practical foundation of sustainability and contributes to future studies in this promising field.

Direct measurement for nanoscale vertical carrier diffusion on semiconductor surface—An approach toward scanning diffusion microscopy

Carrier diffusion properties, including the diffusion length, diffusion coefficient, and carrier lifetime are important for photonic devices. In nitride semiconductors, there are many microscopic structures, which have a strong influence on carrier diffusion. In this paper, a method based on the photo-assisted Kelvin-probe force microscope and the confocal time-resolved photoluminescence spectrum at the same position is developed to map simultaneously the topography and the nanoscale vertical carrier diffusion on the semiconductor surface. On the surface without any dislocations, the hole diffusion length and diffusion coefficient are 161 ± 8 nm and 1.6 ± 0.2 cm2/s, respectively. Near the termination of the dislocation loops on the surface, it can be clearly seen that the diffusion length and diffusion coefficient gradually drop to about 13 ± 5 nm and 0.02 ± 0.01 cm2/s with a spatial resolution of about 100 nm.

How to Design While Loops

Beginning students find the syntactic construct known as a while loop difficult to master. The difficulties revolve around guaranteeing loop termination and around learning how to properly sequence mutations to solve a problem. In fact, both of these are intertwined and students need to be taught a model that helps them reason about how to design while loops. For students that have been introduced to how to design programs using structural recursion, generative recursion, accumulative recursion, and mutation, the task of teaching them how to design while loops is made easier. These students are familiar, for example, with state variables, termination arguments, and accumulator invariants. All of these are fundamental in the design of while loops. This articles presents a novel technique used at Seton Hall University to introduce beginners to the design of while loops. It presents a design recipe that students can follow step-by-step to establish such things as the driver of the loop, the loop invariant, and the proper sequencing of mutations. The article also presents an example of designing a while-loop based function using the new design recipe.

Research and Application of Image Edge Detection Algorithm Based on FOA

Traditional differential-based edge detection algorithms have shortcomings such as inaccurate edge point positioning and corner point missing detection. This paper presents an application of FOA (Fruit Fly Optimization Algorithm) for establishing an image edge tracking model. Firstly, the prior knowledge of edge points is obtained by Canny edge detection operator. Then the corner points are extracted by Hilbert transform, and the edge tracking is accomplished by the coordination of the two mechanisms of randomness and positive feedback; Finally, a single pixel edge is obtained by using the forward movement mechanism and the loop termination condition. Compared with the original Canny edge detection algorithm, the precision and accuracy of image detection are better

An adaptive primal-dual framework for nonsmooth convex minimization

We propose a new self-adaptive and double-loop smoothing algorithm to solve composite, nonsmooth, and constrained convex optimization problems. Our algorithm is based on Nesterov’s smoothing technique via general Bregman distance functions. It self-adaptively selects the number of iterations in the inner loop to achieve a desired complexity bound without requiring to set the accuracy a priori as in variants of augmented Lagrangian methods (ALM). We prove $$\mathcal {O}\left( \frac{1}{k}\right) $$ -convergence rate on the last iterate of the outer sequence for both unconstrained and constrained settings in contrast to ergodic rates which are common in ALM as well as alternating direction method-of-multipliers literature. Compared to existing inexact ALM or quadratic penalty methods, our analysis does not rely on the worst-case bounds of the subproblem solved by the inner loop. Therefore, our algorithm can be viewed as a restarting technique applied to the ASGARD method in Tran-Dinh et al. (SIAM J Optim 28(1):96–134, 2018) but with rigorous theoretical guarantees or as an inexact ALM with explicit inner loop termination rules and adaptive parameters. Our algorithm only requires to initialize the parameters once, and automatically updates them during the iteration process without tuning. We illustrate the superiority of our methods via several examples as compared to the state-of-the-art.

Method for Proving Loop Termination Using Higher Order Differentials

Method for Proving Loop Termination Using Higher Order Differentials

Training Difficulties in Deductive Methods of Verification and Synthesis of Program

The article analyzes the difficulties which Bachelor Degree in Informatics and Computer Sciences students encounter in the process of being trained in applying deductive methods of verification and synthesis of procedural programs. Education in this field is an important step towards moving from classical software engineering to formal software engineering. The training in deductive methods is done in the introductory courses in programming in some Bulgarian universities. It includes: Floyd’s method for proving partial and total correctness of flowchart programs; Hoare’s method of verification of programs; and Djikstra’s method of transforming predicates for verification and synthesis of Algol−like programs. The difficulties which occurred during the defining of the specification of the program, which is subjected to verification or synthesis; choosing a loop invariant and loop termination function; finding the weakest precondition; proving the formulated verifying conditions, are discussed in the paper. Means of overcoming these difficulties is proposed. Conclusions are drawn in order to improve the training in the field. Special attention is dedicated to motivating the use of specific tools for software analysis, such as interactive theorem proving system HOL, the software analyzers Frama−C and its WP plug−in, as well as the formal language ACSL, which allows formal specification of properties of C/C++ programs.

A Hoare Logic for GPU Kernels

We study a Hoare Logic to reason about parallel programs executed on graphics processing units (GPUs), called GPU kernels. During the execution of GPU kernels, multiple threads execute in lockstep, that is, execute the same instruction simultaneously. When the control branches, the two branches are executed sequentially, but during the execution of each branch only those threads that take it are enabled; after the control converges, all the threads are enabled and again execute in lockstep. In this article, we first consider a semantics in which all threads execute in lockstep (this semantics simplifies the actual execution model of GPUs) and adapt Hoare Logic to this setting by augmenting the usual Hoare triples with an additional component representing the set of enabled threads. It is determined that the soundness and relative completeness of the logic do not hold for all programs; a difficulty arises from the fact that one thread can invalidate the loop termination condition of another thread through shared memory. We overcome this difficulty by identifying an appropriate class of programs for which the soundness and relative completeness hold. Additionally, we discuss thread interleaving, which is present in the actual execution of GPUs but not in the lockstep semantics mentioned above. We show that if a program is race free, then the lockstep and interleaving semantics produce the same result. This implies that our logic is sound and relatively complete for race-free programs, even if the thread interleaving is taken into account.

Rely-Guarantee Termination and Cost Analyses of Loops with Concurrent Interleavings

By following a rely-guarantee style of reasoning, we present novel termination and cost analyses for concurrent programs that, in order to prove termination or infer the cost of a considered loop: (1) infer the termination/cost of each loop as if it were a sequential one, imposing assertions on how shared-data is modified concurrently; and then (2) prove that these assertions cannot be violated infinitely many times and, for cost analysis, infer how many times they are violated. At the core of the analysis, we use a may-happen-in-parallel analysis to restrict the set of program points whose execution can interleave. Interestingly, the same kind of reasoning can be applied to prove termination and infer upper bounds on the number of iterations of loops with concurrent interleavings. To the best of our knowledge, this is the first method to automatically bound the cost of such kind of loops. We have implemented our analysis for an actor-based language, and showed its accuracy and efficiency by applying it on several typical applications for concurrent programs and on an industrial case study.

On linear recurrence sequences and loop termination

A sequence of real numbers is said to be positive if all terms are positive, and ultimately positive if all but finitely many terms are positive. In this article we survey recent progress on long-standing open problems concerning deciding the positivity and ultimate positivity of integer linear recurrence sequences. We briefly discuss some of the many contexts in which these problems arise, and relate them to the well-known Skolem Problem, which asks whether a given linear recurrence sequence has a zero term. We also highlight some of the mathematical techniques that have been used to obtain decision procedures for these problems, pointing out obstacles to further progress. In the second half of this survey we move on to closely related questions concerning the termination of linear while loops. This is a well-studied subject in software verification and by now there is rich toolkit of techniques to prove termination in practice. However the decidability of termination for some of the most basic types of loop remains open. Here again we discuss recent progress and remaining open problems.

Conditional termination of loops over heap-allocated data

Static analysis which takes into account the values of data stored in the heap is considered complex and computationally intractable in practice. Thus, most static analyzers do not keep track of object fields nor of array contents, i.e., they are heap-insensitive. In this article, we propose locality conditions for soundly tracking heap-allocated data in Java (bytecode) programs, by means of ghost non-heap allocated variables. This way, heap-insensitive analysis over the transformed program can infer information on the original heap-allocated data without sacrificing efficiency. If the locality conditions cannot be proven unconditionally, we seek to generate aliasing preconditions which, when they hold in the initial state, guarantee the termination of the program. Experimental results show that we greatly improve the accuracy w.r.t. a heap-insensitive analysis while the overhead introduced is reasonable.

On the Termination of Integer Loops

In this article we study the decidability of termination of several variants of simple integer loops, without branching in the loop body and with affine constraints as the loop guard (and possibly a precondition). We show that termination of such loops is undecidable in some cases, in particular, when the body of the loop is expressed by a set of linear inequalities where the coefficients are from Z ∪ { r } with r an arbitrary irrational; when the loop is a sequence of instructions, that compute either linear expressions or the step function; and when the loop body is a piecewise linear deterministic update with two pieces. The undecidability result is proven by a reduction from counter programs, whose termination is known to be undecidable. For the common case of integer linear-constraint loops with rational coefficients we have not succeeded in proving either decidability or undecidability of termination, but we show that a Petri net can be simulated with such a loop; this implies some interesting lower bounds. For example, termination for a partially specified input is at least EXPSPACE-hard.

Termination Analysis of Nonlinear Loops

The termination of linear loops has been studied extensively,but there are few results collected on termination of nonlinear loops.Through the fixed point theorem,this paper presents an approach to the decision of termination of a class of nonlinear loops.In addition,for a particular class of loops,the paper gives a condition under which the termination of the loops is decidable.

Proving termination of nonlinear command sequences

Abstract We describe a simple and efficient algorithm for proving the termination of a class of loops with nonlinear assignments to variables. The method is based on divergence testing for each variable in the cone-of-influence of the loop’s condition. The analysis allows us to automatically prove the termination of loops that cannot be handled using previous techniques. We also describe a method for integrating our nonlinear termination proving technique into a larger termination proving framework that depends on linear reasoning.

Symbolic termination analysis of solvable loops

Termination is an essential part of program correctness. For a class of regular programs, both automatically proving termination and constructing witnesses of nontermination are significant in theoretical computer science. Many traditional theorem-proving methods for analyzing termination are based on Presburger arithmetic or linear programming, so they are valid only for restricted linear problems. On the contrary, some newly-emerged algebraic methods are suitable for polynomial problems, and are promising in deciding termination of polynomial programs. In this paper, we investigate a large class of imperative programs, called solvable loops, whose guards are general polynomials and assignments are special polynomial mappings. We then propose some sufficient criteria for proving termination and nontermination of such loops in parallel. These criteria can further be translated to the quantifier elimination problem over the reals, and hence are computable. Finally, feasible sample points in the process for inferring nontermination are eventually nonterminating inputs, which can be used to generate witnesses of nontermination. Our decision procedure uses symbolic computation and is mechanically implementable in spite of considerably high complexity. Thereby a series of strong and exact results are established in analyzing termination of loops.