A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2019; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Strict functionals for termination proofs
[chapter]

1995
*
Lecture Notes in Computer Science
*

The main advantage of the method is that it makes it possible to transfer ones intuitions about why an HRS should be

doi:10.1007/bfb0014064
fatcat:37aalspibzdd5mdwuttsc7fo2q
*terminating*into a*proof*: one has to nd a \*strict*" interpretation of the constants involved ... Its main tool is the notion of a*strict**functional*, which is a variant of Gandy's notion of a hereditarily monotonic*functional*1]. ... The following lemma enables us to nd a lot more*strict**functionals*: Lemma 3.*For*any*strict**functional*G and monotonic*functional*H, the*functional*F de ned by F(x) := G(x) + H(x), is*strict*.*Proof*. ...##
###
Proof Tool Support for Explicit Strictness
[chapter]

2006
*
Lecture Notes in Computer Science
*

We introduce the various ways in which

doi:10.1007/11964681_3
fatcat:d4bcwbaddrcwfkn5asxwgwyily
*strictness*specific support is offered by the*proof*assistant Sparkle. ... In programs written in lazy*functional*languages such as*for*example Clean and Haskell, the programmer can choose freely whether particular subexpressions will be evaluated lazily (the default) or strictly ... The aim of this support is to hide the cumbersome effects of*strictness*to the user, allowing the same*proof*style and the same*proof*rules to be used both*for*the lazy and*for*the*strict*case. ...##
###
Termination proofs for higher-order rewrite systems
[chapter]

1994
*
Lecture Notes in Computer Science
*

The result is a

doi:10.1007/3-540-58233-9_14
fatcat:w3fhd2cpafcthiepevrsix7xj4
*proof*technique*for*the*termination*of a HRS, similar to the*proof*technique \*Termination*by interpretation in a wellfounded monotone algebra", described in 8, 19] . ... This paper deals with*termination**proofs**for*Higher-Order Rewrite Systems (HRSs), introduced in 12]. ... Theorem 46 suggests the following*proof*technique*for*the*termination*of an HRS: { Find a convenient*strict*interpretation J (c)*for*each constant symbol c 2 C. { Prove that*for*each rule (l ! ...##
###
A complexity tradeoff in ranking-function termination proofs

2008
*
Acta Informatica
*

Our results show a tradeoff: either exponentially many local

doi:10.1007/s00236-008-0085-0
fatcat:hweoft7f6fbuhcwd6qj3qlr3eq
*functions*of certain simple forms, or an exponentially complex global*function*may be required*for*proving*termination*. * ... To prove that a program*terminates*, we can employ a ranking*function*argument, where program states are ranked so that every transition decreases the rank. ... Acknowledgement I am grateful to the Acta Informatica referees*for*their help in improving this paper. ...##
###
Page 5683 of Mathematical Reviews Vol. , Issue 99h
[page]

1999
*
Mathematical Reviews
*

Thus, if the evaluation of a term ¢ does not

*terminate*, the evaluation of a*function*value f(r) will not*terminate*. Examples of*strict*languages are Scheme and ML. ... Logics of partial terms*for**strict*and non-*strict**functional*programming languages. (English summary) J. Funct. Programming 8 (1998), no. 2, 97-129. ...##
###
Topics in termination
[chapter]

1993
*
Lecture Notes in Computer Science
*

We look at methods

doi:10.1007/3-540-56868-9_16
fatcat:yxsyk33rqfcm5ovqdl6snipeim
*for*proving*termination*of orthogonal systems and give a new solution to a problem of Zantema's. ... In fact, we must combine*termination*with the semantics (f(x) = x), as one must*for*the*functional**proof*. 2. ... The path ordering satisfies lhe*strict*subterm property f(. . . , st,...) ~ si,*for*all i.*Proof*. By (1) f( .... si,...) ~_ si, but si ~ f(... ...##
###
Automated termination proofs with measure functions
[chapter]

1995
*
Lecture Notes in Computer Science
*

This paper deals with the automation of

doi:10.1007/3-540-60343-3_33
fatcat:no3adete5fdb3atqlgu2r6dizi
*termination**proofs**for*recursively de ned algorithms (i.e. algorithms in a pure*functional*language). ... To overcome these drawbacks we introduce a calculus*for*automated*termination**proofs*which is able to handle arbitrary measure*functions*based on polynomial norms. ... Acknowledgements I would like to thank J urgen Brauburger, Stefan Gerberding, Thomas Kolbe, Martin Protzen, Christoph Walther and the referees*for*helpful comments. ...##
###
Strict Linearizability and Abstract Atomicity
[article]

2018
*
arXiv
*
pre-print

We also investigate its relationship with

arXiv:1806.08128v1
fatcat:ojnow5vbkncljj7qhdqzda7tqa
*strict*linearizability. ... We also investigate several important properties of*strict*linearizability. ... : Since Z is*strict*linearizable. 2.2 There exists a sequential and*terminating*execution ϕ of A such that H(ϕ ) = H(ϕ ).*proof*: by the 1.1. 2.3 Q.E.D.*proof*: By 2.1 and 2.2,*for*any execution ϕ of Z starting ...##
###
Certification extends Termination Techniques
[article]

2012
*
arXiv
*
pre-print

There are

arXiv:1208.1594v1
fatcat:g3xnak4okvernolckry6n6og2q
*termination**proofs*that are produced by*termination*tools*for*which certifiers are not powerful enough. However, a similar situation also occurs in the other direction. ... We have formalized*termination*techniques in a more general setting as they have been introduced. Hence, we can certify*proofs*using techniques that no*termination*tool supports so far. ... Moreover, monotone reduction pairs can be used*for*direct*termination**proofs*or rule removal [3, 9, 14] . ...##
###
Strictness and totality analysis with conjunction
[chapter]

1995
*
Lecture Notes in Computer Science
*

We prove the

doi:10.1007/3-540-59293-8_216
fatcat:hrygqbrgxzfz3gn45hqlrxbjay
*strictness*and totality analysis correct with respect to a denotational semantics and finally construct an algorithm*for*inferring the*strictness*and totality properties. ... We extend the*strictness*and totality analysis of [12] by allowing conjunction at all levels rather than at the top-level. ... As an example a*function*may have the annotated type (n Int ~ n Int) A (b Int ~ b Ine) which means that given a*terminating*argument the*function*will definitely*terminate*and given a non-*terminating*argument ...##
###
Combining Proofs and Programs
[chapter]

2011
*
Lecture Notes in Computer Science
*

We call this principle freedom of speech: whereas

doi:10.1007/978-3-642-21691-6_4
fatcat:a27bbesitvbala6krv3e6luuj4
*proofs*themselves must*terminate*, they must be allowed to reason about any*function*a programmer might write. ... These languages trade*termination*obligations*for*more limited correctness assurances. In this talk, I present a work-in-progress overview of the Trellys project. ... We call this principle freedom of speech: whereas*proofs*themselves must*terminate*, they must be allowed to reason about any*function*a programmer might write. ...##
###
Elementary strong functional programming
[chapter]

1995
*
Lecture Notes in Computer Science
*

What we should be doing is strong (or total)

doi:10.1007/3-540-60675-0_35
fatcat:bdqjo72z6nbatnp4lainzotq6a
*functional*programming -in which all computations*terminate*. We propose an elementary discipline of strong*functional*programming. ...*Functional*programming is a good idea, but we haven't got it quite right yet. What we have been doing up to now is weak (or partial)*functional*programming. ... I am grateful to the audience at that symposium*for*a number of comments. ...##
###
Universal extensions to simulate specifications

2008
*
Information and Computation
*

The

doi:10.1016/j.ic.2007.10.003
fatcat:qy3llmgwfrgsjela7ucgnzmgcu
*proofs*have been verified with the theorem prover PVS. The methodology of using eternity extensions in correctness*proofs*is briefly discussed. ...*Proof*. Since K is never-*terminating*, the successor*function*s of K satisfies s k+1 (z) / = s k (z)*for*all k. ... Then z = xs(0) satisfies z = q(xs(i))*for*all i. Therefore, f • xs = h(z) • c • xs. Since K is never-*terminating*, xs does not*terminate*. By Lemma 5.1, c • xs is a stutter*function*. ...##
###
An Improved General Path Order

1996
*
Applicable Algebra in Engineering, Communication and Computing
*

We define a strong and versatile

doi:10.1007/bf01293264
fatcat:qyhcmt36nzhwrexzbaa5izvh5q
*termination*order*for*term rewriting systems, called the Improved General Path Order, which simplifies and strengthens Dershowitz/Hoot's General Path Order. ... We demonstrate the power of the Improved General Path Order by*proofs*of*termination*of non-trivial examples, among them a medium-scale term rewriting system that models a lift control. ... I also wish to thank Nachum Dershowitz*for*a number of discussions about the general path order, and Joachim Steinbach*for*pointing to interesting examples. ...##
###
TEA: Automatically proving termination of programs in a non-strict higher-order functional language
[chapter]

1997
*
Lecture Notes in Computer Science
*

We present TEA, a tool that is able to detect

doi:10.1007/bfb0032752
fatcat:v7ygiwerefaphcgcy7m4lztcjy
*termination*of*functions*written in a non-*strict*high-level*functional*programming language like Haskell. ... Since almost every compiler*for*lazy*functional*languages transforms programs into a*functional*core language, we use such a core language as the source language*for*the analysis. ... Acknowledgment We would like to thank Marko Sch utz*for*his helpful remarks in discussions. ...
« Previous

*Showing results 1 — 15 out of 103,645 results*