Free polynomial strong bimonoids

One of the means to enhance reliability and quality of software systems is testing. Object-oriented methodology makes resulting software systems more reliable, maintainable and reusable. However, it also renders the testing more complex and difficult. There are various sequences and combinations to execute the methods in a class or across different classes. This character leads us to select sequences of operations (namely ground terms), rather than individual operations, as test cases in object-oriented class level testing. The pairs of equivalent ground terms can be derived as test cases from a given algebraic specification for a class. If two ground terms are equivalent, but their implemented sequences produce observationally non-equivalent objects, then there is an error in the implementation. However, the set of all equivalent pairs is generally infinite. How do we select a finite number of them? Recently, we have proposed an approach to deal with this problem. In our approach, a fundamental pair is defined as a pair of equivalent terms produced by substituting all the variables on both sides of an axiom by normal forms. We prove that an implementation is consistent with respect to all equivalent terms if and only if it is consistent with respect to all fundamental pairs.

It is well known that combinatory logic with unrestricted introduction and elimination rules for implication is inconsistent in the strong sense that an arbitrary term Y is provable. The simplest proof of this, now usually called Curry's paradox, involves for an arbitrary term Y, a term X defined by X = Y(CPy).The fact that X = PXY = X ⊃ Y is an essential part of the proof.The paradox can be avoided by placing restrictions on the implication introduction rule or on the axioms from which it can be proved.In this paper we determine the forms that must be taken by inconsistency proofs of systems of propositional calculus based on combinatory logic, with arbitrary restrictions on both the introduction and elimination rules for the connectives. Generally such a proof will involve terms without normal form and cut formulas, i.e. formulas formed by an introduction rule that are immediately removed by an elimination with at most some equality steps intervening. (Such a sequence of steps we call a “cut”.)The above applies not only to the strong form of inconsistency defined above, but also to the weak form of inconsistency defined by: all propositions are provable, if this can be represented in the system.Any inconsistency proof of this kind of system can be reduced to one where the major premise of the elimination rule involved in the cut and its deduction must also appear in the deduction of the minor premise involved in the cut.We can, using this characterization of inconsistency proofs, put appropriate restrictions on certain introduction rules so that the systems, including a full classical propositional one, become provably consistent.

Testing object-oriented software is more complex than its procedural counterpart. The concept of "fundamental pairs" was introduced in our TACCLE methodology for testing object-oriented software. It was proved that, although the set of fundamental pairs is only a proper subset of equivalent ground terms, the use of fundamental pairs as test cases covers the use of equivalent ground terms. Recently, we found that any normal form consists of only a creator, or a creator followed only by constructors but not transformers; and yet the reverse is not necessarily true. Thus, the generation of patterns of normal forms is nontrivial and warrants further study. Motivated by this finding and based on further pattern analyses of normal forms and tree models with pruning techniques, we propose an algorithm to generate representative normal forms according to patterns and develop a corresponding automatic tool. This work improves the automation, coverage, and adequacy of selecting (equivalent) fundamental pairs as test cases.

It is known that the first-order theory of rewriting is decidable for ground term rewrite systems, but the general technique uses tree automata and often takes exponential time. For many properties, including confluence (CR), uniqueness of normal forms with respect to reductions (UNR) and with respect to conversions (UNC), polynomial time decision procedures are known for ground term rewrite systems. However, this is not the case for the normal form property (NFP). In this work, we present a cubic time algorithm for NFP, an almost cubic time algorithm for UNR, and an almost linear time algorithm for UNC, improving previous bounds. We also present a cubic time algorithm for CR.

SAT-3 is an NP-complete problem for determining whether there exists a solution satisfying a given Boolean formula in the Conjunctive Normal Form, wherein each clause has at most three literals. Existing approaches of this problem take exponential time and are also memory inefficient. The work uses Genetic Algorithms for finding an optimal solution to this problem. The central idea is the intelligent exploitation of a random search used to solve optimization problems. The work explores previous works to direct the search into regions of better performance within the search space, thus reducing the time and space complexity. It thus establishes the ability of Genetic Algorithms for finding optimal solutions from a huge set of solutions. The work has been implemented and analyzed with satisfactory results.

We use a fully abstract denotational model to show that nested function calls and recursive definitions can be eliminated from SPCF (a typed functional language with simple non-local control operators) without losing expressiveness. We describe — via simple typing rules — an affine fragment of SPCF in which function nesting and recursion (other than iteration) are not permitted. We prove that this affine fragment is fully expressive in the sense that every term of SPCF is observationally equivalent to an affine term.Our proof is based on the observation of Longley — already used to prove universality and full abstraction results for models of SPCF — that every type of SPCF is a retract of a first-order type. We describe retractions of this kind which are definable in the affine fragment. This allows us to transform an arbitrary SPCF term into an affine one by mapping it to a first-order term, obtaining an (affine) normal form, and then projecting back to the original type. In the case of finitary SPCF, the retraction is based on a simple induction, which yields bounds for the size of the resulting term. In the infinitary case, it is based on an analysis of the relationship between SPCF definable functions and strategies for computing them sequentially.KeywordsSequential CompositionFunctional LanguageDenotational SemanticPartial Recursive FunctionStrict FunctionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

In this paper we consider a calculus of connectors that allows for the most general combination of synchronisation, non-determinism and buffering. According to previous results, this calculus is tightly related to a flavour of Petri nets with interfaces for composition, called Petri nets with boundaries. The calculus and the net version are equipped with equivalent bisimilarity semantics. Also the buffers (the net places) can be one-place (C/E nets) or with unlimited capacity (P/T nets). In the paper we investigate the idea of finding normal form representations for terms of this calculus, in the sense that equivalent (bisimilar) terms should have the same (isomorphic) normal form. We show that this is possible for finite state terms. The result is obtained by computing the minimal marking graph (when finite) for the net with boundaries corresponding to the given term, and reconstructing from it a canonical net and a canonical term.

Algorithms that convert direct-style λ-calculus terms to their equivalent terms in continuation-passing style (CPS) typically introduce so-called “administrative redexes:” useless artifacts of the conversion that must be cleaned up by a subsequent pass over the result to reduce them away. We present a simple, linear-time algorithm for CPS conversion that introduces no administrative redexes. In fact, the output term is a normal form in a reduction system that generalizes the notion of “administrative redexes” to what we call “no-brainer redexes,” that is, redexes whose reduction shrinks the size of the term. We state the theorems which establish the algorithm's desireable properties, along with sketches of the full proofs.

Because of the growing importance of object-oriented programming, a number of testing strategies have been proposed. They are based either on pure black-box or white-box techniques. We propose in this article a methodology to integrate the black- and white-box techniques. The black-box technique is used to select test cases. The white-box technique is mainly applied to determine whether two objects resulting from the program execution of a test care are observationally equivalent. It is also used to select test cases in some situations. We define the concept of a fundamental pair as a pair of equivalent terms that are formed by replacing all the variables on both sides of an axiom by normal forms. We prove that an implementation is consistent with respect to all equivalent terms if and only if it is consistent with respect to all fundamental pairs. In other words, the testing coverage of fundamental pairs is as good as that of all possible term rewritings, and hence we need only concentrate on the testing of fundamental pairs. Our strategy is based on mathematical theorems. According to the strategy, we propose an algorithm for selecting a finite set of fundamental pairs as test cases. Given a pair of equivalent terms as a test case, we should then determine whether the objects that result from executing the implemented program are observationally equivalent. We prove, however, that the observational equivalence of objects cannot be determined using a finite set of observable contexts (which are operation sequences ending with an observer function) derived from any black-box technique. Hence we supplement our approach with a “relevant observable context” technique, which is a heuristic white-box technique to select a relevant finite subset of the set of observable contexts for determining the observational equivalence. The relevant observable contezxts are constructed from a data member relevance graph (DRG), which is an abstraction of the given implementation for a given specificatin. A semiautomatic tool hass been developed to support this technique.

ROCS: an object-oriented class-level testing system based on the Relevant Observable ContextS technique

We study the λΠΣS≤ calculus, which contains singleton types S(M) classifying terms of base type provably equivalent to the term M. The system includes dependent types for pairs and functions (Σ and Π) and a subtyping relation induced by regarding singletons as subtypes of the base type. The decidability of type checking for this language is non-obvious, since to type check we must be able to determine equivalence of well-formed terms. But in the presence of singleton types, the provability of an equivalence judgment Γ ⊢ M1 ≡M2 : A can depend both on the typing context Γ and on the particular type A at which M1 and M2 are compared.We show how to prove decidability of term equivalence, hence of type checking, in λΠΣS≤ by exhibiting a type-directed algorithm for directly computing normal forms. The correctness of normalization is shown using an unusual variant of Kripke logical relations organized around sets; rather than defining a logical equivalence relation, we work directly with (subsets of) the corresponding equivalence classes.We then provide a more efficient algorithm for checking type equivalence without constructing normal forms. We also show that type checking, subtyping, and all other judgments of the system are decidable.The λΠΣS≤ calculus models type constructors and kinds in the intermediate language used by the TILT compiler for Standard ML to implement the SML module system. The decidability of λΠΣS≤ term equivalence allows us to show decidability of type checking for TILT's intermediate language. We also obtain a consistency result that allows us to prove type safety for the intermediate language. The algorithms derived here form the core of the type checker used for internal type checking in TILT.

We study the λ ΠΣ S ≤ calculus, which contains singleton types S ( M ) classifying terms of base type provably equivalent to the term M . The system includes dependent types for pairs and functions (Σ and Π) and a subtyping relation induced by regarding singletons as subtypes of the base type. The decidability of type checking for this language is non-obvious, since to type check we must be able to determine equivalence of well-formed terms. But in the presence of singleton types, the provability of an equivalence judgment Γ ⊢ M 1 ≡ M 2 : A can depend both on the typing context Γ and on the particular type A at which M 1 and M 2 are compared.We show how to prove decidability of term equivalence, hence of type checking, in λ ΠΣ S ≤ by exhibiting a type-directed algorithm for directly computing normal forms. The correctness of normalization is shown using an unusual variant of Kripke logical relations organized around sets; rather than defining a logical equivalence relation, we work directly with (subsets of) the corresponding equivalence classes.We then provide a more efficient algorithm for checking type equivalence without constructing normal forms. We also show that type checking, subtyping, and all other judgments of the system are decidable.The λ ΠΣ S ≤ calculus models type constructors and kinds in the intermediate language used by the TILT compiler for Standard ML to implement the SML module system. The decidability of λ ΠΣ S ≤ term equivalence allows us to show decidability of type checking for TILT's intermediate language. We also obtain a consistency result that allows us to prove type safety for the intermediate language. The algorithms derived here form the core of the type checker used for internal type checking in TILT.

Computation with a term rewrite system (TRS) consists in the application of rules from a given starting term until a normal form is reached. Two natural questions arise from this definition: whether all terms can reach at least one normal form (weak normalization property), and whether all terms can reach at most one normal form (unique normalization property). Innermost rewriting is one of the most studied and used strategies for rewriting, since it corresponds to the “call by value” computation of programming languages. Henceforth, it is meaningful to study whether weak and unique normalization are indeed decidable for a significant class of TRS with the use of the innermost strategy. In this paper we study weak and unique normalization for shallow TRS and innermost rewriting. We show decidability of unique normalization in polynomial time, and decidability of weak normalization in doubly exponential time. We obtain an exptime-hardness proof for the latter case. Nevertheless, when a TRS satisfies the unique normalization property, we conclude the decidability of the weak normalization property in polynomial time, too. Hence, whether all terms reach one and only one normal form is decidable in polynomial time. All of these results are obtained assuming that the maximum arity of the signature is fixed for the problem, which is a usual assumption.

Symbolic objects can deal with domain knowledge expressed by dependency rules. However this leads to exponential computation time. In a previous paper we presented an approach called Normal Symbolic Form (NSF) which is applicable when the dependency rules form a tree or a set of trees. This approach leads to a polynomial computation time, but may sometimes bring about an exponential explosion of space memory requirement. The goal of this paper is to study this possible memory requirement and to see how it is bounded according to the nature of the variables and the natur e of the rules. We will see that the memory growth is bounded, and that in most cases, instead of a growth, we will obtain a reduction.

Symbolic objects can deal with domain knowledge expressed by dependency rules between variables. However taking into account this rules in order to analyze symbolic data can lead to exponential computation time. It’s why we introduced an approach called Normal Symbolic Form (NSF) which lead to a polynomial computation time, but may sometimes bring about an exponential explosion of space memory requirement. In a previous paper we studied this possible memory requirement and we saw how it is bounded according to the nature of the variables and rules. The aim of this paper is to model this memory space requirement. The proposed modelling of this problem is related to the Maxwell-Boltzmann statistics currently used on thermodynamics.