Program Transformation

Performing analysis across module boundaries for an entire program is important for exploiting several runtime performance opportunities. However, due to scalability problems in existing full-program analysis frameworks, such performance opportunities are only realized by paying tremendous compile-time costs. Alternative solutions, such as partial compilations or user assertions, are complicated or unsafe and as a result, not many commercial applications are compiled today with cross-module optimizations. This paper presents SYZYGY, a practical framework for performing efficient, scalable, interprocedural optimizations. The framework is implemented in the HP-UX Itanium® compilers and we have successfully compiled many very large applications consisting of millions of lines of code. We achieved performance improvements of up to 40% over optimization level two and compilation time improvements in the order of 100% and more compared to a previous approach.

The majority of security vulnerabilities published in the literature are due to software bugs. Many researchers have developed program transformation and analysis techniques to automatically detect or eliminate such vulnerabilities. So far, most of them cannot be applied to commercially distributed applications on the Windows/x86 platform, because it is almost impossible to disassemble a binary file with 100% accuracy and coverage on that platform. This paper presents the design, implementation, and evaluation of a binary analysis and instrumentation infrastructure for the Windows/x86 platform called BIRD (Binary Interpretation using Runtime Disassembly), which provides two services to developers of security-enhancing program transformation tools: converting binary code into assembly language instructions for further analysis, and inserting instrumentation code at specific places of a given binary without affecting its execution semantics. Instead of requiring a highfidelity instruction set architectural emulator, BIRD combines static disassembly with an on-demand dynamic disassembly approach to guarantee that each instruction in a binary file is analyzed or transformed before it is executed. It takes 12 student months to develop the first BIRD prototype, which can successfully work for all applications in Microsoft Office suite as well as Internet Explorer and IIS web server, including all DLLs that they use. Moreover, the additional throughput penalty of the BIRD prototype on production server applications such as Apache, IIS, and BIND is uniformly below 4%.

Formal Methods has been proven to improve software quality and provide a method of systematic software construction. However, it has yet to gain widespread acceptance in the software industry. In this paper we look at the benefits to be derived from the use of Formal Methods and examine the obstacles to widespread acceptance. We also introduce the Equivalent Transformation Language (ETL)-A formal specification language that we feel can help to overcome some of these obstacles. We explain how this can be done by first examining the mathematical foundation of the ETL and then demonstrate the capabilities of ETL by systematically constructing an ETL specification for the cell automaton "Life". Finally, we discuss the benefits of using ETL as a formal specification language.

Introduction: Over the last years program analysis methods were widely used for software quality assurance. Different types of program analysis require various levels of program representation, analysis methods, etc. Platforms that provide utilities to implement different types of analysis on their basis become very important because they allow one to simplify the process of development. Purpose: Development of a platform for analysis of JVM programs. Results: In this paper we present Kex, a platform for building program analysis tools for JVM bytecode. Kex provides three abstraction levels. First is Kfg, which is an SSA-based control flow graph representation for bytecode-level analysis and transformation. Second is a symbolic program representation called Predicate State, which consists of first order logic predicates that represent instructions of the original program, constraints, etc. The final level is SMT integration layer for constraint solving. It currently provides an interface for interacting with three SMT solvers. Practical relevance: We have evaluated our platform by considering two prototypes. First prototype is an automatic test generation tool that has participated in SBST 2021 tool competition. Second prototype is a tool for detection of automatic library integration errors. Both prototypes have proved that Kex can be used to implement competitive and powerful program analysis tools.

Introduction: Over the last years program analysis methods were widely used for software quality assurance. Different types of program analysis require various levels of program representation, analysis methods, etc. Platforms that provide utilities to implement different types of analysis on their basis become very important because they allow one to simplify the process of development. Purpose: Development of a platform for analysis of JVM programs. Results: In this paper we present Kex, a platform for building program analysis tools for JVM bytecode. Kex provides three abstraction levels. First is Kfg, which is an SSA-based control flow graph representation for bytecode-level analysis and transformation. Second is a symbolic program representation called Predicate State, which consists of first order logic predicates that represent instructions of the original program, constraints, etc. The final level is SMT integration layer for constraint solving. It currently provides an inte...

Modern software design practice implies widespread use in the development of ready-made components, usually designed as external libraries. The undoubted advantages of reusing third-party code can be offset by integration errors that appear in the developed software. The reason for the appearance of such errors is mainly due to misunderstanding or incomplete understanding by the programmer of the details of external libraries such as an internal structure and the subtleties of functioning. The documentation provided with the libraries is often very sparse and describes only the main intended scenarios for the interaction of the program and the library. In this paper, we propose the approach based on the use of formal library specifications, which allows detecting integration errors using static analysis methods. To do this, the external library is described using the LibSL specification language, the resulting description is translated into the internal data structures of the KEX an...

We present a framework for expressing bottom-up algorithms to compute the well-founded model of non-disjunctive logic programs. Our method is based on the notion of conditional facts and elementary program transformations studied by Brass and Dix in (Brass & Dix, 1994; Brass & Dix, 1999) for disjunctive programs. However, even if we restrict their framework to nondisjunctive programs, their "residual program" can grow to exponential size, whereas for function-free programs our "program remainder" is always polynomial in the size of the extensional database (EDB). We show that particular orderings of our transformations (we call them strategies) correspond to well-known computational methods like the alternating fixpoint approach (Van Gelder, 1989; Van Gelder, 1993), the well-founded magic sets method (Kemp et al., 1995) and the magic alternating fixpoint procedure (Morishita, 1996). However, due to the confluence of our calculi (first noted in (Brass & Dix, 1998)), we come up with computations of the well-founded model that are provably better than these methods. In contrast to other approaches, our transformation method treats magic set transformed programs correctly, i.e. it always computes a relevant part of the well-founded model of the original program. These results show that our approach is a valuable tool to analyze, compare, and optimize existing evaluation methods or to create new strategies that are automatically proven to be correct if they can be described by a sequence of transformations in our framework. We have also developed a prototypical implementation. Experiments illustrate that the theoretical results carry over to the implemented prototype and may be used to optimize real life systems.

Identifying repetitive code changes benefits developers, tool builders, and researchers. Tool builders can automate the popular code changes, thus improving the productivity of developers. Researchers can better understand the practice of code evolution, advancing existing code assistance tools and benefiting developers even further. Unfortunately, existing research either predominantly uses coarse-grained Version Control System (VCS) snapshots as the primary source of code evolution data or considers only a small subset of program transformations of a single kind-refactorings. We present the first approach that identifies previously unknown frequent code change patterns from a fine-grained sequence of code changes. Our novel algorithm effectively handles challenges that distinguish continuous code change pattern mining from the existing data mining techniques. We evaluated our algorithm on 1,520 hours of code development collected from 23 developers, and showed that it is effective, useful, and scales to large amounts of data. We analyzed some of the mined code change patterns and discovered ten popular kinds of high-level program transformations. More than half of our 420 survey participants acknowledged that eight out of ten transformations are relevant to their programming activities.

Despite the enormous success that manual and automated refactoring has enjoyed during the last decade, we know little about the practice of refactoring. Understanding the refactoring practice is important for developers, refactoring tool builders, and researchers. Many previous approaches to study refactorings are based on comparing code snapshots, which is imprecise, incomplete, and does not allow answering research questions that involve time or compare manual and automated refactoring. We present the first extended empirical study that considers both manual and automated refactoring. This study is enabled by our algorithm, which infers refactorings from continuous changes. We implemented and applied this algorithm to the code evolution data collected from 23 developers working in their natural environment for 1,520 hours. Using a corpus of 5,371 refactorings, we reveal several new facts about manual and automated refactorings. For example, more than a half of the refactorings were performed manually. The popularity of automated and manual refactorings differs. More than one third of the refactorings performed by developers are clustered. For some refactoring kinds, up to 64% of performed refactorings do not reach the Version Control System.

Adaptive MPI, or AMPI, is an implementation of the Message Passing Interface (MPI) standard. AMPI benefits MPI applications with features such as dynamic load balancing, virtualization, and checkpointing. Because AMPI uses multiple user-level threads per physical core, global variables become an obstacle. It is thus necessary to convert MPI programs to AMPI by eliminating global variables. Manually removing the global variables in the program is tedious and error-prone. In this paper, we present a Photran-based tool that automates this task with a source-to-source transformation that supports Fortran. We evaluate our tool on the multi-zone NAS Benchmarks with AMPI. We also demonstrate the tool on a real-world large-scale FLASH code and present preliminary results of running FLASH on AMPI. Both results show significant performance improvement using AMPI. This demonstrates that the tool makes using AMPI easier and more productive.

A number of computational applications lack instruction-level parallelism. This loss is particularly acute on sequences of dependent instructions on wide-issue or deeply pipelined architectures. We consider four real applications from computational biology, cryptanalysis, and data compression. These applications are characterized by long sequences of dependent instructions, irregular control-flow and intricate scalar and memory dependence patterns. While these benchmarks exhibit good memory locality and branch-predictability, state-of-the-art compiler optimizations fail to exploit much instruction-level parallelism. This paper shows that major performance gains are possible on such applications, through a loop transformation called deep jam. This transformation reshapes the control-flow of a program to facilitate the extraction of independent computations through classical back-end techniques. Deep jam combines accurate dependence analysis and control speculation, with a generalized form of recursive, multi-variant unroll-and-jam; it brings together independent instructions across irregular control structures, removing memory-based dependences through scalar and array renaming. This optimization contributes to the extraction of fine-grain parallelism in irregular applications. We propose a feedback-directed deep jam algorithm, selecting a jamming strategy, function of the architecture and application characteristics.

The research also delves into the study of inter-trans-multidisciplinary scientific research as an overarching method to integrate multiple disciplines towards reconciliation, conflict transformation, and peace studies. It aims to transform disciplines as a comprehensive paradigm for reconciliation, conflict transformation, and promoting peace. This includes introducing a theoretical framework for conducting research from theory to practice and implementing it as a real-life problem-solving solution mechanism in conflict disputes. The goal is also to handle crises, transform conflict, address human rights violations and injustices, and create a scientific dialogue for developing a common future that enables the transformation of conflict towards the path of peace. Keywords Reconciliation • Digital peacebuilding • Digital humanities • Digital social science • Netnography • Artificial intelligence • Digital research methods Digital humanities in applied digital studies in social sciences have arrived to promote the integration of digital strategies, methods, tools, and applications, such as integrating Artificial Intelligence, machine learning, and other applications into social media applications for social transformation, thriving for promoting new ideologies and new technologies; not a single industry is safe from the unstoppable wave of digitization integration and transformation that is sweeping through social sciences studies, finance, retail, transportation, and more. In 2019, there are more transformative developments that will change our scientific research, careers, and lives that gives a need for researching applied digital humanities in social sciences, such as Artificial I. M. AlDajani (B) The Academic Alliance for Reconciliation in the MENA,

Most real-world applications inevitably face the issue of persistence, generally understood as how to design, maintain and interact with a database. The standard approach relies on the mature technology of relational databases, with interaction specified through SQL embedded in the host programming language. Attempts to raise the level of the error-prone interaction code have been in the direction of object-oriented databases or deductive databases, with simpler queries but less mature technology on the database part. Here we present a different high-level approach, close in spirit to natural language, using variable-free conceptual expressions that are quite concise, natural and easy to read and understand, promoting much better code maintenance than the alternative approaches. This is achieved by using the flexible operator syntax and the deductive capabilities of logic programming in two ways, first to compile the database scheme from a modular structural description into a clausal representation, and then to translate (using the compiled scheme) terms expressing queries and commands into SQL statements. The approach relies crucially on the use of attributes, whose inheritance and composition avoid many explicit joins. Expressions become natural by choosing the right noun phrases (rather than verbal) for the attributes. A useful feature is the use of global parameters for implicit current values. Our deductive handle on the scheme allows the query translation to automatically split the needed joins into inner and outer joins. The abstraction power is further raised by having manifold attributes, whose values actually vary along a parametric domain, the main examples being the handling of temporal and multilingual data. Commands can also be very high-level, for example the simple statement of update of an identity value (part of the primary key) of an individual results in its replacement in all tuples of all concepts where the individual was referenced, this being done in the correct order to prevent violation of foreign keys. We present the ideas incrementally, with examples along with a rigorous account of the used syntax and semantics.

Novel approaches for dynamic information flow monitoring are promising since they enable permissive (accepting a large subset of executions) yet sound (rejecting all unsecure executions) enforcement of non-interference. In this paper, we present a dynamic information flow monitor for a language supporting pointers. Our flow-sensitive monitor relies on prior static analysis in order to soundly enforce non-interference. We also propose a program transformation that preserves the behavior of initial programs and soundly inlines our security monitor. This program transformation enables both dynamic and static verification of non-interference.

Symbolic computation is an important approach in automated program analysis. Most state-of-the-art tools perform symbolic computation as interpreters and directly maintain symbolic data. In this paper, we show that it is feasible, and in fact practical, to use a compilerbased strategy instead. Using compiler tooling, we propose and implement a transformation which takes a standard program and outputs a program that performs semantically equivalent, but partially symbolic, computation. The transformed program maintains symbolic values internally and operates directly on them hence the program can be processed by a tool without support for symbolic manipulation. The main motivation for the transformation is in symbolic verification, but there are many other possible use-cases, including test generation and concolic testing. Moreover using the transformation simplifies tools, since the symbolic computation is handled by the program directly. We have implemented the transformation at the level of LLVM bitcode. The paper includes an experimental evaluation, based on an explicit-state software model checker as a verification backend.

This paper presents the transformation of OpenMP source code to a Macro-Task Graph, an internal representation of the parallel program as a collection of tasks, which later can be asynchronously scheduled for out-of-order execution and optimized for locality reuse. The transformation is based on array region analysis. We also show the potential benefits of targeting OpenMP code to a macro-task graph, instead of directly generating a multi-threaded program. We show experimental results for a Jacobi kernel and part of the POP code in OpenMP and compiled traditionally versus macro-dataflow execution model using the SMARTS runtime system on SGI Origin 2000.

Analysis of program running time is important for several applications, including reactive systems, interactive environments, compiler optimizations and performance evaluation. Automatic and efficient prediction of accurate time bounds is particularly important, and being able to do so for high-level languages is particularly desirable. This paper presents a general approach for automatic and accurate time-bound analysis for a functional high-level language, that combines methods and techniques studied in theory, languages, and systems. The approach consists of transformations for building time-bound functions in the presence of partially known input structures, symbolic evaluation of the time-bound function based on input parameters, optimizations to make the analysis efficient as well as accurate, and measurements of primitive parameters, all at the source-language level. To handle higher-order functions, special transformations are needed to build lambda expressions for computing...

This paper provides a un,fying mathematical proof which replaces a mechanical certification of the optimal paraiieiization of sorting networks on a case by case basis. Paraiielization of sequentiai program traces by means of a semantic-preserving transformation is alscussed in the literature in the context of a method for synthesis of systolic architecture. The issue of optimal paraiieiization is important in systolic design. The mathematical proof provides a better insight into the fundamental aspects of the transformation.

This paper presents a catalog of code refactorings that are intended to improve different quality attributes of Fortran programs. We classify the refactorings according to their purpose, that is, the internal or external quality attribute(s) that each refactoring targets to improve. We sketch the implementation of one refactoring in Photran, a refactoring tool for Fortran.

We study the existence and the characterization of function transformers that minimally or maximally modify a function in order to reveal or conceal a certain property. Based on this general formal framework we develop a strategy for the design of the maximal obfuscating transformation that conceals a given property while revealing the desired observational behaviour.

Metamorphic malware apply semantics-preserving transformations to their own code in order to foil detection systems based on signature matching. In this paper we consider the problem of automatically extract metamorphic signatures from these malware. We introduce a semantics for self-modifying code, later called phase semantics, and prove its correctness by showing that it is an abstract interpretation of the standard trace semantics. Phase semantics precisely models the metamorphic code behavior by providing a set of traces of programs which correspond to the possible evolutions of the metamorphic code during execution. We show that metamorphic signatures can be automatically extracted by abstract interpretation of the phase semantics, and that regular metamorphism can be modelled as finite state automata abstraction of the phase semantics.

In a typical client-server scenario, a trusted server provides valuable services to a client, which runs remotely on an untrusted platform. Of the many security vulnerabilities that may arise (such as authentication and authorization), guaranteeing the integrity of the client code is one of the most difficult to address. This security vulnerability is an instance of the malicious host problem, where an adversary in control of the client's host environment tries to tamper with the client code. We propose a novel client replacement strategy to counter the malicious host problem. The client code is periodically replaced by new orthogonal clients, such that their combination with the server is functionally-equivalent to the original client-server application. The reverse engineering efforts of the adversary are deterred by the complexity of analysis of frequently changing, orthogonal program code. We use the underlying concepts of program obfuscation as a basis for formally defining and providing orthogonality. We also give preliminary empirical validation of the proposed approach.

A Higher Order Method for Determining Nonisolated Solutions of a System of Nonlinear Equations. In this note, we obtain a method of order at least four to solve a singular system of nonlinear algebraic equations. This is achieved by enlarging the system to a higher dimensional one whose solution is isolated. For the larger system we use a method developed by B. Neta.

We present a comparative evaluation of some generalization strategies which are applied by a method for the automated verification of infinite state reactive systems. The verification method is based on (1) the specialization of the constraint logic program which encodes the system with respect to the initial state and the property to be verified, and (2) a bottom-up evaluation of the specialized program. The generalization strategies are used during the program specialization phase for controlling when and how to perform generalization. Selecting a good generalization strategy is not a trivial task because it must guarantee the termination of the specialization phase itself, and it should be a good balance between precision and performance. Indeed, a coarse generalization strategy may prevent one to prove the properties of interest, while an unnecessarily precise strategy may lead to high verification times. We perform an experimental evaluation of various generalization strategies on several infinite state systems and properties to be verified.

Die Dokumente auf EconStor dürfen zu eigenen wissenschaftlichen Zwecken und zum Privatgebrauch gespeichert und kopiert werden. Sie dürfen die Dokumente nicht für öffentliche oder kommerzielle Zwecke vervielfältigen, öffentlich ausstellen, öffentlich zugänglich machen, vertreiben oder anderweitig nutzen. Sofern die Verfasser die Dokumente unter Open-Content-Lizenzen (insbesondere CC-Lizenzen) zur Verfügung gestellt haben sollten, gelten abweichend von diesen Nutzungsbedingungen die in der dort genannten Lizenz gewährten Nutzungsrechte. Terms of use: Documents in EconStor may be saved and copied for your personal and scholarly purposes. You are not to copy documents for public or commercial purposes, to exhibit the documents publicly, to make them publicly available on the internet, or to distribute or otherwise use the documents in public. If the documents have been made available under an Open Content Licence (especially Creative Commons Licences), you may exercise further usage rights as specified in the indicated licence.

We present an approach for the static detection of possible assertion violations in Java. The main idea is to use an existing test-case generator in combination with a new program transformation. A possible assertion violation is indicated by a generated specific test case. In addition, this test case specifies the path in the program leading to the assertion violation. This heuristic approach is a compromise between the usual but too late detection of an assertion violation at runtime and an often too expensive complete analysis based on a model checker. Keywords–assertion; automatic test-case generation; program transformation.

Аннотация. Расширение числа и ассортимента компонентов программного обеспечения в значительной степени подчеркивает необходимость защиты прав интеллектуальной собственности (IPR), затрудняемую компьютерным пиратством, для борьбы с которым требуются эффективные меры. Выявление характерных особенностей программного обеспечения предназначено для противодействия незаконному заимствованию права собственности на программное обеспечение путем установления его происхождения. В этой статье предлагается новый подход к выявлению характерных особенностей программ, основанный на сочетании методов интеллектуального анализа текстов и графов. Элементы кода программы и их связи с другими элементами идентифицируются на основе их особенностей (конструкций кода) и преобразуются в конструкции языка манипулирования графами. Характерные особенности программного обеспечения, выводимые путем исследования теоретических свойств графа (на основе коэффициента кластеризации), используются для установления сходства или различия двух программ. Предложенная методика была оценена по показателям достоверности, устойчивости, заимствования методов, обнаружения модифицированного кода и самокопирования. Результаты подтверждают эффективность предложенного подхода для противодействия незаконному заимствованию права собственности. Сравнительный анализ предложенного подхода с современными решениями показывает лучшие результаты при выявлении свойств и связей узлов программы и при использовании динамических методов анализа графов без дополнительных накладных расходов (таких как увеличение размера программы и затрат на обработку). Ключевые слова: право интеллектуальной собственности; незаконное использование программного обеспечения; характерные особенности программного обеспечения; интеллектуальный анализ графов; достоверность и устойчивость.

Formal methods and testing are two important approaches that assist in the development of high-quality software. While traditionally these approaches have been seen as rivals, in recent years a new consensus has developed in which they are seen as complementary. This article reviews the state of the art regarding ways in which the presence of a formal specification can be used to assist testing.

The goal of knowledge compilation is to transform programs in order to speed up their evaluation. In Inductive Logic Programming, two major approaches to speed-up learning exist: Approaches that intertwine the learning and the optimization process and approaches that separate these two processes. We follow the latter approach and present a new equivalencepreserving transformation method for programs with ordered clauses. It eliminates redundancies that make forward inference procedures slow. We introduce general chain rules, a speci®c class of ordered clauses, whose syntactical features are exploited in a new forward inference method. The comparison of the time needed by this method to evaluate the transformed program with the time needed by a standard forward inference procedure for the original program con®rms the expected speed-up.

The Revised 6 Report on Scheme introduces three fundamental changes involving Scheme's recursive variable binding constructs. First, it standardizes the sequential recursive binding construct, letrec*, which evaluates its initialization expressions in a strict leftto-right order. Second, it specifies that internal and library definitions have letrec* semantics. Third, it prohibits programs from invoking the continuation of a letrec or letrec* init expression more than once. The first two changes increase the incentive for handling letrec* efficiently, while the third change gives the compiler more options for transforming letrec and letrec* expressions. This paper extends an earlier effort of Waddell, Sarkar, and Dybvig to handle the Revised 5 Report letrec and the (then nonstandard) letrec* efficiently. It presents more aggressive transformations for letrec and letrec* that take advantage of the new prohibition on invoking the continuations of initialization expressions multiple times. The implementation employs Tarjan's algorithm for finding strongly connected components in a graph that encodes the dependencies among the bindings.

We present a very general language for expressing tactic programs. The paper describes some essential tactic combinators (tacticals), and gives them a formal semantics. Those definitions are used to produce a complete calculus for reasoning about tactics written in this language. The language is extended to cover structural combinators which enable the tactics to be precisely targeted upon particular sub-expressions.

We describe reformation, a new algorithm for the automated repair of faulty logical theories. A fault is revealed by a reasoning failure: either the proof of a false conjecture or the failure to prove a true conjecture. Repair suggestions are systematically extracted via analysis of (un)successful unifications of formulae in (broken) proofs. These suggestions will either unblock a wanted but unsuccessful unification attempt or block an unwanted but successful unification. In contrast to traditional abduction and belief revision mechanisms, the repairs are to the language of the theory as well as to the axioms. The intention is that the language repairs suggested by reformation complement these axiom deleting and adding repairs, adding to the overall capability of theory repair and evolution. Reformation is self-inverse in that any blocking repair can be undone by an unblocking one, and vice versa. This self-inverse property provides some assurance that reformation repairs are minimal.

The Unified Modeling Language (UML) is gaining wide acceptance in industry and we, at Siemens Corporate Research, are seeking ways in which UML diagrams can be used as the basis for functional testing. Our approach focuses on developing effective techniques and tools for test case generation and coupling them with suitable execution tools for unit, integration and system testing. For example, our current approaches focus on integrating our techniques with the Rational Rose UML modeling tool and unit test execution tools such as Junit and system test tools, that is, capture-replay tools such as Compuware Testpartner. The goal of our approach is to generate a set of black-box conformance tests that can be used to validate a component, subsystem or application under test.

The startup phase of an application represents a tiny fraction of the total runtime, but it is considered, nevertheless, a critical phase for both client and server environments. In the JVM, the Just-in-Time compiler (JIT) translates Java bytecodes to native machine code to improve the performances of an application. This thesis investigates whether using two different JIT compilers in the same JVM can improve startup time. A lightweight JIT system (i.e. MicroJIT) has been integrated into the J9 JVM and it has been set up to perform an initial, low-optimized, but fast compilation while, at a latter time, the standard JIT recompiles Java bytecodes with better, but more expensive, optimizations. This solution has been evaluated using different benchmarks and metrics and has been compared to the JVM in different configurations: default configuration, standard JIT tuned for optimal startup time (option Xquickstart) and executing the Java application with Ahead-of-Time code available from the Shared Class Cache. Experimental results show that enabling MicroJIT, compared to the default configuration, significantly reduces the startup time of the considered bench-Table of Contents v List of Tables ix List of Figures x List of Acronyms xii

The first task in that proposal was to develop an external module for implementing tabling primitives that provide direct control over the search strategy. ® The external module will serve as the basis to study how tabling interacts with the EAM and to detect in advance the potential integration problems before incorporating tabling within the EAM environment.

This study aims to determine the environmental management model in coastal areas based on ecosystems; Al-Khairat Islamic Boarding School in Central Sulawesi, Case Study. Optimizing environmental conservation is done through many factors, and religious elements become one of these factors; religion becomes a way to shape the character of its adherents in protecting their environment. Islam as a religion has teachings that direct its supporters to protect the environment adequately so that the instructions are in harmony with the concept of environmental conservation. This research uses ekopesantren theory with several indicators. First, the pesantren policy that carries out environmental management by utilizing the land to create artificial forests. Utilization is based on agroforestry, agro silvopasteur and agro fishery approach. The zone of mangrove forest utilization can help food security and environmental preservation in the boarding school environment. The existence of an artificial lake as a water catchment area supports efforts to conserve water in boarding schools. It also serves as a water reserve through rainwater collection so that it can minimize the occurrence of flooding. Second, participatory activity-based environmental development policies. Islamic boarding schools make santri as an aid team in overcoming natural disasters and ecological disasters to minimize environmental damage, social impacts, and economic losses. The environmental management model carried out by the Al-Khairat Islamic Boarding School in Palu in the coastal area and geographically crossed by the equator, can reduce environmental damage and can be used as a role model in disaster mitigation and eco-implementation implementation.

This work has been partially supported by the EU (FEDER) and the Spanish MEC/MICINN under grants TIN2005-09207-C03-02, TIN2008-06622-C03-02, and Acción Integrada HA2006-0008, by SES-ANUIES and by DGEST (México). 3 We consider the usual binding-times: static (definitely known at partial evaluation time) and dynamic (possibly unknown at partial evaluation time).

We present a characterization of first-order functional programs which are quasiterminating w.r.t. the symbolic execution mechanism of needed narrowing, i.e., computations in these programs consist of a sequence of finitely many different function calls (up to variable renaming). Quasi-terminating programs are particularly useful for program analysis and transformation, since in this context quasi-termination often amounts to full termination.

We address the problem of verifying that the functions of a program meet their contracts, specified by pre/postconditions. We follow an approach based on constrained Horn clauses (CHCs) by which the verification problem is reduced to the problem of checking satisfiability of a set of clauses derived from the given program and contracts. We consider programs that manipulate algebraic data types (ADTs) and a class of contracts specified by catamorphisms, that is, functions defined by simple recursion schemata on the given ADTs. We show by several examples that state-of-the-art CHC satisfiability tools are not effective at solving the satisfiability problems obtained by direct translation of the contracts into CHCs. To overcome this difficulty, we propose a transformation technique that removes the ADT terms from CHCs and derives new sets of clauses that work on basic sorts only, such as integers and booleans. Thus, when using the derived CHCs there is no need for induction rules on AD...

We present a method for verifying the correctness of imperative programs which is based on the automated transformation of their specifications. Given a program prog, we con-sider a partial correctness specification of the form {ϕ} prog {ψ}, where the assertions ϕ and ψ are predicates defined by a set Spec of possibly recursive Horn clauses with linear arithmetic (LA) constraints in their premise (also called constrained Horn clauses). The verification method consists in constructing a set PC of constrained Horn clauses whose satisfiability implies that {ϕ} prog {ψ} is valid. We highlight some limitations of state-of-the-art constrained Horn clause solving methods, here called LA-solving methods, which prove the satisfiability of the clauses by looking for linear arithmetic interpretations of the predicates. In particular, we prove that there exist some specifications that cannot be proved valid by any of those LA-solving methods. These specifications require the proof of satisfiabi...

Abstract. In this paper we present an overview of the unfold/fold proof method, a method for prov-ing theorems about programs, based on program transformation. As a metalanguage for specifying programs and program properties we adopt constraint logic programming (CLP), and we present a set of transformation rules (including the familiar unfolding and folding rules) which preserve the semantics of CLP programs. Then, we show how program transformation strategies can be used, similarly to theorem proving tactics, for guiding the application of the transformation rules and inferring the properties to be proved. We work out three examples: (i) the proof of predicate equiv-alences, applied to the verification of equality between CCS processes, (ii) the proof of first order formulas via an extension of the quantifier elimination method, and (iii) the proof of temporal prop-erties of infinite state concurrent systems, by using a transformation strategy that performs program specialization.

We present a method for verifying the correctness of an imperative program with respect to a specification defined in terms of a set of possibly recursive Horn clauses. Given a program prog, we consider a partial correctness specification of the form {φ} prog {ψ}, where the assertions φ and ψ are predicates defined by a set Spec of Horn clauses. The verification method consists in: (i) encoding the function computed by the program prog (according to the semantics of the imperative language) as a set OpSem of clauses, and then (ii) constructing a set PC of Horn clauses and a predicate p such that if p is false in the least model of PC, that is, M(PC) 6|= p, then {φ} prog {ψ} is valid. We also present an extension of the verification method for showing total correctness of programs. Then we present a general proof technique based on unfold/fold transformations of Horn clauses, for checking whether or not M(PC) |= p holds. We also outline a strategy for guiding the application of the u...