Department Mathematik



Publications of Helmut Schwichtenberg

Books and surveys


  • Lookahead analysis in exact real arithmetic with logical methods, with Nils Köpp. To appear in TCS, 2022.
    Program extraction from proofs can be used to obtain verified algorithms in exact real arithmetic for e.g., the signed-digit code representation. In Minlog this has been done in the past with the use of certain coinductive predicates. In a next step we want to analyze the lookahead of these extracted programs. Doing it by hand is quite cumbersome, so instead we change our definitions. Instead of a coinductive predicate we use an inductive predicate for the representation of reals that already incorporates the lookahead. In this way the lookahead becomes part of the specification which is carried through all the proofs. In the end we extract programs for computations on a signed-digit representation and we can just read off the lookahead from the specification.
  • Logic for exact real arithmetic, with Franziskus Wiesnet. In LMCS 17(2021),
    Continuing earlier work of the first author with U. Berger, K. Miyamoto and H. Tsuiki, it is shown how a division algorithm for real numbers given as a stream of signed digits can be extracted from an appropriate formal proof. The property of being a real number represented as a stream is formulated by means of coinductively defined predicates, and formal proofs involve coinduction. The proof assistant Minlog is used to generate the formal proofs and extract their computational content as terms of the underlying theory, a form of type theory for finite or infinite data. Some experiments with running the extracted term are described, after its translation to Haskell.
  • Program extraction from proofs: the fan theorem for uniformly coconvex bars. Final version in Mathesis Universalis and Proof Theory (eds. S. Centrone and P. Schuster), Synthese Library, 2019
    Proofs can have computational content, and the most direct method to extract it is via a realizability interpretation in the form given by Kreisel. After a short introduction into the subject we present a recent case study on Brouwer's fan theorem for uniform coconvex bars. As an application we prove a constructive version of the Heine-Borel Theorem, for uniformly coconvex coverings.
  • Tiered arithmetics, with Stan Wainer. Final version in G. Jäger and W. Sieg (eds.), Feferman on Foundations, Springer, 2017
    In his paper "Logics for Termination and Correctness of Functional Programs, II. Logics of Strength PR" Feferman was concerned with the problem of how to guarantee the feasibility (or at least the subrecursive complexity) of functions definable in certain logical systems. His ideas have influenced much subsequent work, for instance the final chapter of [SchwichtenbergWainer12]. There, linear two-sorted systems LRT (a version of Gödel's T) and LRA (a corresponding arithmetical theory) of polynomial-time strength were introduced. Here we extend LRT and LRA in such a way that some forms of non-linearity are covered as well. This is important when one wants to deal on the proof level with particular algorithms, not only with the functions they compute. Examples are divide-and-conquer approaches as in treesort, and the first of two main sections here gives a detailed analysis of this. The second topic treated heads in a different direction, though again its roots lie in the final chapter of [SchwichtenbergWainer12]. Instead of just two sorts we consider transfinite ramified sequences of such sorts (or "tiers"). A hierarchy of infinitary arithmetical systems EA(I_alpha) is devised, being weak analogues of the iterated inductive definitions underpinning much of Feferman's work. Their strengths turn out to correspond to the levels of the extended Grzegorczyk or Fast-Growing hierarchy. A "pointwise" concept of transfinite induction provides an ordinal measure of strength, but it is a weak (essentially finitistic) notion, related to the Slow-Growing hierarchy.
  • Logic for Gray-code computation, with U. Berger, K. Miyamoto and H. Tsuiki. Final version in D. Probst and P. Schuster (eds), Concepts of Proof in Mathematics, Philosophy, and Computer Science, De Gruyter, 2016
    Gray-code is a well-known binary number system where neighboring values differ in one digit only. Tsuiki (2002) has introduced Gray code to the field of real number computation. He assigns to each number a unique 1bot-sequence, i.e., an infinite sequence of -1, 1, bot containing at most one copy of bot (meaning undefinedness). In this paper we take a logical and constructive approach to study real number computation based on Gray-code. Instead of Tsuiki's indeterministic multihead Type-2 machine, we use pre-Gray code, which is a representation of Gray-code as a sequence of constructors, to avoid the difficulty due to bot which prevents sequential access to a stream. We extract real number algorithms from proofs in an appropriate formal theory involving inductive and coinductive definitions. Examples are algorithms transforming pre-Gray code into signed digit code of real numbers, and conversely, the average for pre-Gray code and a translation of finite segments of pre-Gray code into its normal form. These examples are formalized in the proof assistant Minlog.
  • Higman's Lemma and its computational content, with M. Seisenberger and F. Wiesnet. Final version in R. Kahle, T. Strahm, and T. Studer (eds), Advances in Proof Theory, Birkhäuser, 2016.
    Higman's Lemma is a fascinating result in infinite combinatorics, with manyfold applications in logic and computer science. It has been proven several times using different formulations and methods. The aim of this paper is to look at Higman's Lemma from a computational and comparative point of view. We give a proof of Higman's Lemma that uses the same combinatorial idea as Nash-Williams' indirect proof using the so-called minimal bad sequence argument, but which is constructive. For the case of a two letter alphabet such a proof was given by Coquand. Using more flexible structures, we present a proof that works for an arbitrary well-quasiordered alphabet. We report on a formalization of this proof in the proof assistant Minlog, and discuss machine extracted terms (in an extension of Gödel's system T) expressing its computational content.
  • Embedding classical in minimal implicational logic, with H. Ishihara. Final version in Mathematical Logic Quarterly 63, 2016.
    Consider the problem which set V of propositional variables suffices to prove intuitionistically A from stability (not not P -> P) for all P in V provided A is provable classically. We give a direct proof that stability for the final propositional variable of the (implicational) formula A is sufficient; as a corollary one obtains Glivenko's theorem. Conversely, using Glivenko's theorem one can give an alternative proof of our result. As an alternative to stability we then consider the Peirce formula ((Q -> P) -> Q) -> Q. It is an easy consequence of the result above that adding a single instance of the Peirce formula suffices to move from classical to intuitionistic derivability. Finally we consider the question whether one could do the same for minimal logic. Given a classical derivation of a propositional formula not involving falsum, which instances of the Peirce formula suffice as additional premises to ensure derivability in minimal logic? We define a set of such Peirce formulas, and show that in general an unbounded number of them is necessary.
  • Program extraction from nested definitions, with K. Miyamoto and F. Nordvall Forsberg. In Proceedings ITP 2013.
    Minlog is a proof assistant which automatically extracts computational content in an extension of Gödel's T from formalized proofs. We report on extending Minlog to deal with predicates defined using a particular combination of induction and coinduction, via so-called nested definitions. In order to increase the efficiency of the extracted programs, we have also implemented a feature to translate terms into Haskell programs. To illustrate our theory and implementation, a formalisation of a theory of uniformly continuous functions due to Berger is presented.
  • Viewing lambda-terms through Maps, with M. Sato, R. Pollack and T. Sakurai. Final version in Indagationes Mathematicae 24, 2013.
    In this paper we introduce the notion of map, which is a notation for occurrence of a symbol in syntactic expressions such as formulas or lambda-terms. We use binary trees over 0 and 1 as maps, but some well-formedness conditions are required. We develop a representation of lambda terms using maps. The representation is concrete (inductively definable in HOL or Constructive Type Theory) and canonical (one representative per lambda-term). We define substitution for our map representation, and prove the representation is in substitution preserving isomorphism with both nominal logic lambda-terms and de Bruijn nameless terms. These proofs are mechanically checked in Isabelle/HOL and Minlog respectively. The map representation has good properties. Substitution does not require adjustment of binding information: neither alpha-conversion of the body being substituted into, nor de Bruijn lifting of the term being implanted. We have a natural proof of the substitution lemma of lambda calculus that requires no fresh names, or index manipulation. Using the notion of map we study conventional raw lambda syntax. E.g. we give, and prove correct, a decision procedure for alpha-equivalence of raw lambda terms that does not require fresh names. We conclude with a definition of beta-reduction of map terms, some discussion on the limitations of our current work, and suggestions for future work.
  • Constructive aspects of Riemann's permutation theorem for series, with J. Berger, D.S. Bridges and H. Diener. Draft (February 2012).
  • Program extraction in exact real arithmetic, with K. Miyamoto. Final version in MSCS 25, 2015.
    The importance of an abstract approach to a computation theory over general data types has been stressed by John Tucker in many of his papers. Ulrich Berger and Monika Seisenberger recently elaborated the idea for extraction out of proofs involving (only) abstract reals. They considered a proof involving coinduction of the proposition that any two reals in [-1,1] have their average in the same interval, and informally extract a Haskell program from this proof, which works with stream representations of reals. Here we formalize the proof, and machine-extract its computational content using the Minlog proof assistant. This required an extension of this system to also take coinduction into account.
  • A bound for Dickson's lemma, with J. Berger. Final version in LMCS, 2016
    We consider the following special case of Dickson's lemma: for any two functions f,g on the natural numbers there are two numbers i,j with i less than j such that both f and g weakly increase on them, i.e., f_i \le f_j and g_i \le g_j. By a combinatorial argument (due to the first author) a simple bound for such i,j is constructed. The combinatorics is based on the finite pigeon hole principle and results in a certain descent lemma. From the descent lemma one can prove Dickson's lemma, then guess what the bound might be, and verify it by an appropriate proof. We also extract (via realizability) a bound from (a formalization of) our proof of the descent lemma.
  • Minimal from classical proofs, with C. Senjak. Final version in APAL 164, 2013.
    Let A be a formula without implications, and Gamma consist of formulas containing disjunction and falsity only negatively and implication only positively. Orevkov (1968) and Nadathur (2000) proved that classical derivability of A from Gamma implies intuitionistic derivability, by a transformation of derivations in sequent calculi. We give a new proof of this result (for minimal rather than intuitionistic logic), where the input data are natural deduction proofs in long normal form (given as proof terms via the Curry-Howard correspondence) involving stability axioms for relations; the proof gives a quadratic algorithm to remove the stability axioms. This can be of interest for computational uses of classical proofs. Keywords: Minimal logic, stability axioms, Glivenko-style theorems, Orevkov, intuitionistic logic.
  • Minlog - A Tool for Program Extraction Supporting Algebras and Coalgebras, with U. Berger, K. Miyamoto and M. Seisenberger. (In: A. Corradini et al., eds, CALCO-Tools 2011, LNCS 6859, 393-399)
    Minlog is an interactive system which implements proof-theoretic methods and applies them to verification and program extraction. We give an overview of Minlog and demonstrate how it can be used to exploit the computational content in (co)algebraic proofs and to develop correct and efficient programs. We illustrate this by means of two examples: one about parsing, the other about exact real numbers in signed digit representation.
  • Towards a formal theory of computability, with S. Huber and B. Karadais (In: R. Schindler, ed, Ways of Proof Theory: Festschrift for W. Pohlers, 2010)
    We sketch a constructive formal theory TCF+ of computable functionals, based on the partial continuous functionals as their intendend domain. Such a task had long ago been started by Dana Scott (1969, 1993), under the well-known abbreviation LCF (logic of computable functionals). The present approach differs from Scott's in two aspects. (i) The intended semantical domains for the base types are non-flat free algebras, given by their constructors, where the latter are injective and have disjoint ranges; both properties do not hold in the flat case. (ii) TCF+ has the facility to argue not only about the functionals themselves, but also about their finite approximations. In this setting we give an informal proof (based on Berger 1993) of Kreisel's density theorem, and an adaption of Plotkin's definability theorem. We then show that both proofs can be formalized in TCF+.
  • Decorating proofs, with D. Ratiu (In: S. Feferman and W. Sieg, eds, Mints Festschrift, 2010)
    The programs synthesized from proofs are guaranteed to be correct, however at the cost of sometimes introducing irrelevant computations, as a consequence of the fact that the extracted code faithfully reflects the proof. In this paper we extend the work of Ulrich Berger (1993), which introduces the concept of ''non-computational universal quantifiers'', and propose an algorithm by which we identify at the proof level the components - quantified variables, as well as premises of implications - that are computationally irrelevant and mark them as such. We illustrate the benefits of this (optimal) decorating algorithm in some case studies and present the results obtained with the proof assistant Minlog.
  • Content in proofs of list reversal (Marktoberdorf '07)
    Ulrich Berger (2005) observed that the well-known linear list reversal algorithm can be obtained as the computational content of a weak (or ''classical'') existence proof. The necessary tools are a refinement of the Dragalin/Friedman A-translation, and uniform (or ''non-computational'') quantifiers. Both tools are implemented in the Minlog proof assistant, in addition to the more standard realizability interpretation. The aim of the paper is to give an introduction into the theory underlying these tools, and to explain their usage in Minlog, using list reversal as a running example.
  • Dialectica Interpretation of Well-Founded Induction. (Final version in Mathematical Logic Quarterly 54, 2008)
    From a classical proof that the gcd of natural numbers a1 and a2 is a linear combination of the two, we extract by Gödel's Dialectica interpretation an algorithm computing the coefficients. The proof uses the minimum principle. We show generally how well-founded recursion can be used to Dialectica interpret well-founded induction, which is needed in the proof of the minimum principle. In the special case of the example above it turns out that we obtain a reasonable extracted term, representing an algorithm close to Euclid's.
  • Realizability interpretation of proofs in constructive analysis. (Final version in ToCS, 2008)
    We prove constructively (in the style of Bishop) that every monotone continuous function with a uniform modulus of increase has a continuous inverse. The proof is formalized, and a realizing term extracted. It turns out that even in the logical term language - a version of Gödel's T - evaluation is reasonably efficient.
  • New Developments in Proofs and Computations. (Final version in New Computational Paradigms (B. Cooper, B. Löwe, A. Sorbi, eds.))
  • Machine Extraction of the Normalization-by-Evaluation Algorithm from a Normalization Proof, with Dominik Schlenker (Marktoberdorf '05)
  • Inverting monotone continuous functions in constructive analysis, (Proc. CiE 2006, Swansea)
  • Program extraction in constructive analysis. (Final version in S. Lindström et al., eds, Logicism, Intuitionism, and Formalism - What has become of them?)
    We sketch a development of constructive analysis in Bishop's style, with special emphasis on low type-level witnesses (using separability of the reals). The goal is to set up things in such a way that realistically executable programs can be extracted from proofs. This is carried out for (1) the Intermediate Value Theorem and (2) the existence of a continuous inverse to a monotonically increasing continuous function. Using the Minlog proof assistant, the proofs leading to the Intermediate Value Theorem are formalized and realizing terms extracted. It turns out that evaluating these terms is a reasonably fast algorithm to compute, say, approximations of the square root of 2.
  • Recursion on the partial continuous functionals, (Proc. LC 2005, Athens)
    We describe a constructive theory of computable functionals, based on the partial continuous functionals as their intendend domain. Such a task had long ago been started by Dana Scott (1969) under the well-known abbreviation LCF. However, the prime example of such a theory, Per Martin-Löf's type theory in its present form deals with total (structural recursive) functionals only. An early attempt of Martin-Löf (1983) to give a domain theoretic interpretation of his type theory has not even been published, probably because it was felt that a more general approach - such as formal topology - would be more appropriate. In the paper we try to make a fresh start, and do full justice to the fundamental notion of computability in finite types, with the partial continuous functionals as underlying domains. The total ones then appear as a dense subset, and seem to be best treated in this way.
  • A direct proof of the equivalence between Brouwer's fan theorem and König's lemma with a uniqueness hypothesis. (Final version in J. of Universal Computer Science 11, 2005)
    From results of Ishihara it is known that the weak (that is, binary) form of König's lemma (WKL) implies Brouwer's fan theorem (Fan). Moreover, Berger and Ishihara [MLQ 2005] have shown that a weakened form WKL! of WKL, where as an additional hypothesis it is required that in an effective sense infinite paths are unique, is equivalent to Fan. The proof that WKL! implies Fan is done explicitly. The other direction (Fan implies WKL!) is far less directly proved; the emphasis is rather to provide a fair number of equivalents to Fan, and to do the proofs economically by giving a circle of implications. Here we give a direct construction. Moreover, we go one step further and formalize the equivalence proof (in the Minlog proof assistant). Since the statements of both Fan and WKL! have computational content, we can automatically extract terms from the two proofs. It turns out that these terms express in a rather perspicuous way the informal constructions.
  • Program extraction from normalization proofs, with U. Berger, S. Berghofer and P. Letouzey (Final version in Studia Logica 82, 2006)
    This paper describes formalizations of Tait's normalization proof for the simply typed lambda-calculus in the proof assistants Minlog, Coq and Isabelle/HOL. From the formal proofs programs are machine-extracted that implement variants of the well-known normalization-bt-evaluation algorithm. The case study is used to test and compare the program extraction machineries of the three proof assistants in a non-trivial setting.
  • Proof search in minimal logic (AISC, 2004)
  • Constructive Analysis with Witnesses (Marktoberdorf '03)
  • Constructive Solutions of Continuous Equations, with P. Schuster (Russell Volume, 2004)
  • An arithmetic for polynomial-time computation (Final version in TCS 357, 2006)
    We define a restriction LHA of Heyting arithmetic HA with the property that all extracted programs are feasible. The restrictions consist in linearity and ramification requirements.
  • An arithmetic for non-size-increasing polynomial-time computation, with K. Aehlig, U. Berger and M. Hofmann (Final version in TCS 318, 2004)
  • Feasible computation with higher types, with S. Bellantoni (Marktoberdorf '01)
    We restrict recursion in finite types so as to characterize the polynomial time computable functions. The restrictions are obtained by enriching the type structure with the formation of ordinary and linear arrow types and abstraction terms. It turns out that we need two sorts of typed variables: complete and incomplete ones.
  • Linear Ramified Higher Type Recursion and Parallel Computation, with K. Aehlig, J. Johannsen and S. Terwijn (PTCS Volume LNCS 2183, 2001)
  • Refined Program Extraction from Classical Proofs, with U. Berger and W. Buchholz (Final version in Annals of Pure and Applied Logic 114, 2002)
    It is well known that it is undecidable in general whether a given program meets its specification. In contrast, it can be checked easily by a machine whether a formal proof is correct, and from a constructive proof one can automatically extract a corresponding program, which by its very construction is correct as well. This - at least in principle - opens a way to produce correct software, e.g. for safety-critical applications. Moreover, programs obtained from proofs are ''commented'' in a rather extreme sense. Therefore it is easy to maintain them, and also to adapt them to particular situations. We will concentrate on the question of classical versus constructive proofs. It is known that any classical proof of a specification of the form forall x exists y B with B quantifier-free can be transformed into a constructive proof of the same formula. However, when it comes to extraction of a program from a proof obtained in this way, one easily ends up with a mess. Therefore, some refinements of the standard transformation are necessary. In this paper we develop a refined method of extracting reasonable and sometimes unexpected programs from classical proofs. We also generalize previously known results since B in forall x exists y B no longer needs to be quantifier-free, but only has to belong to the strictly larger class of ''goal formulas''. Furthermore we allow unproven lemmas D in the proof of forall x exists y B, where D is a ''definite'' formula.
  • Beweise und Programme. Anmerkungen zu Heytings Formalisierung der intuitionistischen Logik (Ber. Abh. Berlin Brand. Akad. Wiss 8, 2000)
  • A syntactical analysis of non-size-increasing polynomial time computation, with K. Aehlig (LICS'2000) ( Journal version, in ACM ToCL)
  • Refined Program Extraction from Classical Proofs: Some Case Studies, (Marktoberdorf '99)
    We make use of a refined method of extracting programs from classical proofs [Berger, Buchholz and Schwichtenberg 2002]. Its use is demonstrated with two rather detailed case studies. Specifically, we extract programs from classical proofs of the existence of (i) integer square roots, and (ii) integer coefficients to linearly combine the greatest common divisor of two numbers from these numbers.
  • Term rewriting for normalization by evaluation, with U. Berger and M. Eberl (Final version in Information and Computation 183, 2003)
    We extend normalization by evaluation (first presented in [Berger and Schwichtenberg 1991]) from the pure typed lambda-calculus to general higher type term rewriting systems and prove its correctness w.r.t. a domain-theoretic model. We distinguish between computational rules and proper rewrite rules. The former is a rather restricted class of rules, which, however, allows for a more efficient implementation
  • Higher Type Recursion, Ramification and Polynomial Time, with S. Bellantoni and K-H. Niggl (Final version in Annals of Pure and Applied Logic 104, 2000).
  • Normalization by evaluation, with U. Berger and M. Eberl (NADA Volume LNCS 1546, 1998)
  • Proof theory at work: Program development in the Minlog system , with H. Benl, U. Berger, M. Seisenberger and W. Zuber (Automated Deduction, W. Bibel and P.H. Schmitt, eds., Vol. II, Kluwer 1998)
  • Formal correctness proofs of functional programs: Dijkstra's algorithm, a case study , with H. Benl (Marktoberdorf '97))
  • Termination of permutative conversions in intuitionistic Gentzen calculi (Final version in TCS 212, 1999)
  • Monotone majorizable functionals (Final version in Studia Logica 62, 1999)
  • The Warshall Algorithm and Dickson's Lemma: Two examples of realistic program extraction, with U. Berger and M. Seisenberger (Final version in Journal of Automated Reasoning 26, 2001)
  • Programmentwicklung durch Beweistransformation: Das Maximalsegmentproblem (Bayer. Akad., 12/96)
  • Finite notations for infinite terms (Final version in Annals of Pure and Applied Logic 94, 1998)
  • From higher order terms to circuits, with K. Stroetmann (ICLMPS Florenz '95)
  • The greatest common divisor: a case study for program extraction from classical proofs (also in dvi or pdf -format), with U. Berger (Turin '95)
    Yiannis Moschovakis suggested the following example of a classical existence proof with a quantifier-free kernel which does not obviously contain an algorithm: the gcd of two natural numbers is a linear combination of the two. Here we treat that example as a case study for program extraction from classical proofs. We apply Harvey Friedman's A-translation followed by a modified realizability interpretation to extract a program from this proof. However, to obtain a reasonable program it is essential to use a refinement of the A-translation. This refinement makes it possible that not all atoms in the proof are A-translated, but only those with a "critical" relation symbol. In our example only the divisibility relation is critical.
  • Proofs, Lambda Terms and Control Operators (Marktoberdorf '95)
  • Strict Functionals for Termination Proofs, with J. van de Pol (TLCA '95)
  • Program Extraction from Classical Proofs , with U. Berger (LCC '94)
  • Ordinal Bounds for Programs, with A. Wainer (Feasible Math '94)
  • Density and choice for total continuous functionals (Kreisel '93)
  • Program development by proof transformation, with U. Berger (Marktoberdorf '93)
  • Minimal from Classical Proofs (CSL '91)
  • Minimal Logic for Computable Functions (Marktoberdorf '91)
  • Proofs as Programs (Leeds '90)
    Suppose a formal proof of (all x)(ex y) Spec(x,y) is given, where Spec(x,y) is an atomic formula expressing some specification for natural numbers x, y. For any particular number n we then obtain a formal proof of (ex y) Spec(n,y). Now the proof-theoretic normalization procedure yields another proof of (ex y) Spec(n,y) which is in normal form. In particular, it does not use induction axioms any more, and it also does not contain non-evaluated terms. Hence we can read off, linearly in the size of the normal proof, an instance m for y such that Spec(n,m) holds. In this way a formal proof can be seen as a program, and the central part in implementing this programming language consists in an implementation of the proof-theoretic normalization procedure. It is not the prime purpose of the paper to discuss this implementation. Rather, we want to explore the theoretical possibilities and limitations of a programming language based on formal proofs. The notion of proof is taken here in a quite basic sense: the formal language is supposed to talk about algebraic data structures (i.e. free algebras), and structural recursion as well as structural induction is allowed. Hence we discuss systems of the strength of ordinary arithmetic. We will measure the strength of our proofs/programs in terms of the so-called slow growing hierarchy G_alpha introduced by Wainer and studied by Girard. We will give a new proof of the following result of Kreisel and (Girard 1981): Any function defined by a proof of (all x)(ex y)Spec (x,y) is bounded by a function G_alpha of the hierarchy with alpha below the Bachmann-Howard ordinal, and conversely that for any such G_alpha there is an atomic formula Spec_alpha (x,y) such that G_alpha(n) below the least m with Spec_alpha(n,m), and (all x)(ex y) Spec_alpha(x,y) is provable, and hence for any proof of this fact the function computed by that proof (considered as a program) grows at least as fast as G_alpha. On the more technical side, our work builds heavily on earlier work of Buchholz (1987) and Arai (1989). In particular, the material in Sections 1-3 on trees, tree notations and the slow growing hierarchy is taken from Buchholz. Also, the omega^+-Rule below is derived from (a special case of) the Omega-Rule in (Buchholz 1987) (or more precisely of its "slow-growing" variant in (Arai 1989)), which in turn is based on earlier work of Howard (1972). The new twist here is that we make use of a technique of Howard (1980) to measure the complexity of a (finite) term/proof by (transfinite) trees; for this to go through it is essential to use a natural deduction system and not a Tait calculus as in (Buchholz 1987) or (Buchholz and Wainer 1987). More precisely, we inductively define what it means for a (finite) term/proof involving recursion/induction constants to be SDH-generated (for Sanchis-Diller-Howard) with measure alpha (a transfinite tree) and rank m. One clause of this inductive definition is called omega^+-rule and introduces uncountable trees. In this setup it is easy to provide relatively perspicious and complete proofs of the relations mentioned above between the slow growing hierarchy and the functions computed by proofs/programs in arithmetical systems.
  • An upper bound for reduction sequences in the typed lambda-calculus (Final version in Arch. Math. Logic 30, 1991)
  • Normalization (Marktoberdorf '89)
  • Primitive Recursion on the Partial Continuous Functionals (Bauer-Kolloquium '89)
There is also a List of publications

See also the listing in Google scholar

Last change

7. October 2022