Logic Programming

One recurring problem in program development is that of understanding how to re-use code developed by a third party. In the context of (constraint) logic programming, part of this problem reduces to figuring out how to query a program. If the logic program does not come with any documentation, then the programmer is forced to either experiment with queries in an ad hoc fashion or trace the control-flow of the program (backward) to infer the modes in which a predicate must be called so as to avoid an instantiation error. This paper presents an abstract interpretation scheme that automates the latter technique. The analysis presented in this paper can infer moding properties which if satisfied by the initial query, come with the guarantee that the program and query can never generate any moding or instantiation errors. Other applications of the analysis are discussed. The paper explains how abstract domains with certain computational properties (they condense) can be used to trace control-flow backward (right-to-left) to infer useful properties of initial queries. A correctness argument is presented and an implementation is reported.

We present a selective backtracking method for Horn clause programs, as applied to Prolog (2)[8) (11)[12], a programming language based on first-order predicate calculus (3)(4)~ developed at the university of Marseille (18]. This method is based on the general method expounded in (7] for backtracking intelligently in AND/OR trees. It consists, essentially, in avoiding backtracking to any goal whose alternative solutions cannot possibly prevent the repetition of the failures which caused backtracking. This is a renewed version of an earlier report (8), which was spurred by the work of Bruynooghe (1). In (g] we present an implementation of a selective backtracking interpreter using the methods discussed in this paper.

Most real-world applications have come to rely on the mature technology of relational databases for persistent storage, interacting through SQL embedded in the host programming language. Using logic programming we present a higher-level alternative to SQL, close in spirit to natural language, yielding much more concise expressions that are easier to understand and promote better code maintenance. This is achieved using the flexible operator syntax and the deductive capabilities, first to compile a clausal representation of the database scheme from a high-level description, and then to interpret queries and commands, through the compiled scheme, into SQL statements.

Prolog's very useful expressive power is not captured by traditional logic programming semantics, due mainly to the cut and goal and clause order. Several alternative semantics have been put forward, exposing operational details of the computation state. We propose instead to redesign Prolog around structured alternatives to the cut and clauses, keeping the expressive power and computation model but with a compositional denotational semantics over much simpler states—just variable bindings. This considerably eases reasoning about programs, by programmers and tools such as a partial evaluator, with safe unfolding of calls through predicate definitions. Anif-then-elseacross clauses replaces most uses of the cut, but the cut's full power is achieved by anuntilconstruct. Disjunction, conjunction anduntil, along with unification, are the primitive goal types with a compositional semantics yielding sequences of variable-binding solutions. This extends to programs via the usual tec...

Batanin and Leinster's work on globular operads has provided one of many potential defnitions of a weak $\omega$-category. Through the language of globular operads they construct a monad whose algebras encode weak $\omega$-categories. The purpose of this work is to show how to construct a similar monad which will allow us to formulate weak $\omega$-categorifications of any equational algebraic theory. We first review the classical theory of operads and PROs. We then present how Leinster's globular operads can be extended to a theory of globular PROs via categorical enrichment over the category of collections. It is then shown how a process called globularization allows us to construct from a classical PRO P a globular PRO whose algebras are those algebras for P which are internal to the category of strict $\omega$-categories and strict $\omega$-functors. Leinster's notion of a contraction structure on a globular operad is then extended to this setting of globular PROs in...

We show that the framework for unfold/fold transformation of logic programs, first proposed by Tamaki and Sato and later extended by various researchers, preserves various nonmonotonic semantics of normal logic programs, especially preferred extension, partial stable models, regular model, and stable theory semantics. The primary aim of this research is to adopt a uniform approach for every semantics of normal programs, and that is elegantly achieved through the notion of semantic kernel. Later, we show that this framework can also be applied to extended logic programs, preserving the answer set semantics. a The use of unfold/fold transformation in synthesis of logic programs has been realized as early as 1977 [ll, 231 and a framework for this transformation was proposed in 1984 by Tamaki and Sato [44]. Later, the relationship between unfold/fold transformation and partial deduction has been studied, indicating that unfold/fold transformation can also be used for program specialization and optimization [28, 431. The primary requisite of an unfold/fold transformation system is its correct- ness: it should preserve the meaning of the original program, i.e., the original and transformed programs should be equivalent w.r.t. the chosen semantics. The original unfold/fold transformation system of Tamaki and Sato [44] is meant for definite programs,

Logic programs are considered as abductive programs with negative literals as abductive hypotheses. A simple framework for semantics of logic programming is introduced based on the notion of acceptable hypotheses. We show that our framework captures, generalizes, and unifies different semantic concepts (e.g., well-founded models, stable models, stationary semantics, etc.) in logic programming. We demonstrate that our framework accommodates in a natural way both the minimalism and maximalism intuitions to semantics of logic programming. Further, we show that Eshghi and Kowalski's procedure is a proof procedure for the abductive semantics. We also give sufficient conditions for the coincidence between different semantics.

We study the conceptual relationship between the semantics of nonmonotonic inheritance reasoning and argumentation. We show that the credulous semantics of nonmonotonic inheritance network can be captured by the stable semantics of argumentation. We present a transformation of nonmonotonic inheritance networks into equivalent extended logic programs.

An information agent is viewed as a deductive database consisting of 3 parts: • an observation database containing the facts the agent has observed or sensed from its surrounding environment. • an input database containing the information the agent has obtained from other agents • an intensional database which is a set of rules for computing derived information from the information stored in the observation and input databases. Stabilization of a system of information agents represents a capability of the agents to eventually get correct information about their surrounding despite unpredictable environment changes and the incapability of many agents to sense such changes causing them to have temporary incorrect information. We argue that the stabilization of a system of cooperative information agents could be understood as the convergence of the behavior of the whole system toward the behavior of a "superagent", who has the sensing and computing capabilities of all agents combined. We show that unfortunately, stabilization is not guaranteed in general, even if the agents are fully cooperative and do not hide any information from each other. We give sufficient conditions for stabilization. We discuss the consequences of our results.

We provide a logical analysis of private international law, a rather esoteric, but increasingly important, domain of the law. Private international law addresses overlaps and conflicts between legal systems by distributing cases between the authorities of such systems (jurisdiction) and establishing what rules these authorities have to apply to each case (choice of law). A formal model of the resulting interactions between legal systems is proposed based on modular argumentation. It is argued that this model may also be useful for governing the interactions between heterogeneous agents, belonging to different and differently regulated virtual societies, without recourse to a central regulatory agency. The model also provides for multiple interpretations concerning rules of private international law as well as substantive rules of the different legal systems.

We present an abstract framework for default reasoning, which includes Theorist, default logic, logic prog~mming, autoe~is~mic logic, non-monotonic modal logics, and certain instances of circumscription as special cases. The framework can be understood as a generalisation of Theorist. The generalisation allows any theory formulated in a monotonic logic to be extended by a defeasible set of assumptions. An assumption can be defeated (or "attacked") if its "contrary" can be proved, possibly with the aid of other conflicting assumptions. We show that, given such a framework, the standard semantics of most logics for default reasoning can be understood as sanctioning a set of assumptions, as an extension of a given theory, if and only if the set of assumptions is conflict-free (in the sense that it does not attack itself) and it attacks every assumption not in the set. We propose a more liberal, argumentation-theoretic semantics, based upon the notion of admissible extension in logic programming. We regard a set of assumptions, in general, as admissible if and only if it is conflict-free and defends itself (by attacking) every set of assumptions which attacks it. We identify conditions for the existence of extensions and for the equivalence of different semantics. (EJ 1997 Elsevier Science B.V.

يتجه الفكر في زمن سلطة العلم والتّخصص نحو جعل كل حقل من حقول الفكر علما قائما بذاته، على غرار ما حدث في علم النّفس وعلم الاجتماع والسّياسة والاقتصاد... حيث حاول بعض المُتخصصين في الجمال أن يجعلوه علما قائمًا بذاته، يشترك مع الفن في المقدمات العامة غير أنّه يتميز عنه بقواعد ومعايير ومجالات خاصة، نظرا لأن الجمال حقلٌ أكثر تخصصا من الفن، من حيث موضوعُه الرّئيسُ وقيمه المتعالية نظرا لارتباطه بالذّات كموضوع غير مفصول عن موضوعات الإدراك والذّوق.

Existing approaches for querying OWL DL do either only operate on syntactic constructs without taking into account the semantics of OWL or do only have a restricted access to the T-Box. We present SAIQL, the novel Schema And Instance Query Language for OWL DL, that is well suited for ontology extraction. We describe its syntax and explain a basic evaluation strategy. We illustrate the use of SAIQL with an example for ontology extraction and re-use.

Existing approaches for querying OWL DL do either only operate on syntactic constructs without taking into account the semantics of OWL or do only have a restricted access to the T-Box. We present SAIQL, the novel Schema And Instance Query Language for OWL DL, that is well suited for ontology extraction. We describe its syntax and explain a basic evaluation

Abstract: The Managed Readiness Simulator (MARS) is a versatile program that allows the user to quickly simulate a wide range of Canadian Forces readiness Scenarios to determine if the Resources of an Establishment are able to satisfy the requirements of a set of ...

The unification algorithm has long been a target for program synthesis research, but a fully automatic derivation remains a research goal. In deductive program synthesis, computer programming is phrased as a task in theorem proving; a declarative specification is expressed in logical form and presented to an automatic theorem prover, and a program meeting the specification is extracted from the proof. The correctness of the program is supported by the proof, which also provides an explanation of how the program works. The proof is conducted in an appropriate axiomatic subject-domain theory, which defines the concepts in the specification and the constructs in the target programming language and provides the background knowledge necessary to connect them.

We study nonmonotonic rule systems with rules that admit infinitely many restraints. We concentrate on the case when the constraints of rules form a recursive sets and there is a uniform enumeration of codes for rules. We show that the theory developed for nonmonotnic rule systems admitting the rules with finite number of restraints can be lifted to such rule systems. We give tight estimates on the complexity of the set of extensions of such rule systems.

This paper extends and updates our earlier survey and analysis of work on the extension of logic programming to perform abductive reasoning [Kakas et al., 1993]. The purpose of the paper is to provide a critical overview of some of the main research results, in order to develop a common framework for evaluating these results, to identify the main unresolved problems, and to indicate directions for future work. The emphasis is not on technical details but on relationships and common features of different approaches. Some of the main issues we will consider are the contributions that abduction can make to the problems of reasoning with incomplete or negative information, the evolution of knowledge, and the semantics of logic programming and its extensions. We also discuss recent work on the argumentation-theoretic interpretation of abduction, which was introduced in the earlier version of this paper. The philosopher Peirce first introduced the notion of abduction. In [Peirce, 1931-58]...

We present an extension of Logic Programming (LP) which, in addition to ordinary LP clauses, also includes integrity constraints, explicit representation of disjunction in the bodies of clauses and in goals, and suspension of atoms as in concurrent logic languages. The resulting framework aims to unify Constraint Logic Programming (CLP), Abductive Logic Programming (ALP) and Semantic Query Optimisation (SQO) in deductive databases. We present a proof procedure for the new framework, simplifying and generalising previously proposed proof procedures for ALP. We discuss applications of the framework, formulating traditional problems from LP, ALP, CLP and SQO.

In previous work, we proposed a logic-based framework in which computation is the execution of actions in an attempt to make reactive rules of the formif antecedent then consequenttrue in a canonical model of a logic program determined by an initial state, sequence of events, and the resulting sequence of subsequent states. In this model-theoretic semantics, reactive rules are the driving force, and logic programs play only a supporting role. In the canonical model, states, actions, and other events are represented with timestamps. But in the operational semantics (OS), for the sake of efficiency, timestamps are omitted and only the current state is maintained. State transitions are performed reactively by executing actions to make theconsequentsof rules true whenever theantecedentsbecome true. This OS is sound, but incomplete. It cannot make reactive rules true by preventing theirantecedentsfrom becoming true, or by proactively making theirconsequentstrue before theirantecedentsbec...

In this paper we analyse the di erences between rational and reactive agent architectures, and propose a uniform agent architecture that aims to capture both as special cases. For this purpose we employ a proof procedure, to control the agent's behaviour, which combines de nitions with integrity constraints. The proof procedure is general, and has been shown elsewhere to unify abductive logic programming, constraint logic programming and semantic query optimisation. We also employ a resource-bounded formalisation of the proof procedure which allows the agent's reasoning to be interrupted and resumed, so that observations and actions can be performed.

In this paper we present an agent language that combines agent functionality with an action theory and model-theoretic semantics. The language is based on abductive logic programming (ALP), but employs a simplified state-free syntax, with an operational semantics that uses destructive assignment to manipulate a database, which represents the current state of the environment. The language builds upon the ALP combination of logic programs, to represent an agent's beliefs, and integrity constraints, to represent the agent's goals. Logic programs are used to define macro-actions, intensional predicates, and plans to reduce goals to sub-goals including actions. Integrity constraints are used to represent reactive rules, which are triggered by the current state of the database and recent agent actions and external events. The execution of actions and the assimilation of observations generate a sequence of database states. In the case of the successful solution of all goals, this sequence, taken as a whole, determines a model that makes the agent's goals and beliefs all true.

programs are a variety of production systems with a destructively updated database that represents the current state of the environment. They combine proactive behaviour, which is goal-oriented, with reactive behaviour, which is sensitive to the changing environment. They can take advantage of situations in which the environment opportunistically solves the system's goals, recover gracefully when the environment destroys solutions of its goals, and abort durative actions when higher priority goals need more urgent attention. In this paper, we present an abductive logic programming (ALP) representation of TR programs, following the example of our ALP representation of the logic-based production system language LPS. The operational semantics of the representation employs a destructively updated database, which represents the current state of the environment, and avoids the frame problem of explicitly reasoning about the persistence of facts that are not affected by the updates. The model-theoretic semantics of the representation is defined by associating a logic program with the TR program, the sequence of observations and actions, and the succession of database states. In the semantics, the task is to generate actions so that all of the program's goals are true in a minimal model of this associated logic program.

Computer Science today lacks a unified view of Computing. Instead, the main subareas, most notably artificial intelligence, database systems and programming languages, offer different and often competing approaches to knowledge representation, problem-solving and computation. In this paper we propose a unifying logic-based, framework for Computing, inspired by artificial intelligence, but scaled down for practical database and programming applications. Computation in the framework is viewed as the task of generating a sequence of state transitions, with the purpose of making an agent's goals all true. States are represented by sets of atomic sentences (or facts), representing the values of program variables, tuples in a coordination language, facts in relational databases, or Herbrand models. In the model-theoretic semantics, the entire sequence of states and events are combined into a single model-theoretic structure, by associating time stamps with facts. But in the operational semantics, facts are updated destructively, without time stamps. We show that the model generated by destructive updates is identical to the model generated by reasoning with facts containing time stamps. We also extend the model with intentional predicates and composite event predicates defined by logic programs containing conditions in first-order logic (FOL). We extend the notions of local stratification and weak stratification to generate the associated model.

In this paper we propose a logic-based, framework inspired by artificial intelligence, but scaled down for practical database and programming applications. Computation in the framework is viewed as the task of generating a sequence of state transitions, with the purpose of making an agent's goals all true. States are represented by sets of atomic sentences (or facts), representing the values of program variables, tuples in a coordination language, facts in relational databases, or Herbrand models. In the model-theoretic semantics, the entire sequence of states and events are combined into a single model-theoretic structure, by associating timestamps with facts and events. But in the operational semantics, facts are updated destructively, without timestamps. We show that the model generated by destructive updates is identical to the model generated by reasoning with facts containing timestamps. We also extend the model with intentional predicates and composite event predicates defined by logic programs containing conditions in first-order logic, which query the current state.

This paper is a survey and critical overview of recent w ork on the extension of Logic Programming to perform Abductive Reasoning (Abductive Logic Programming). It updates the earlier paper \Abductive Logic Programming" 88]. We outline the general framework of Abduction and its applications to Knowledge Assimilation and Default Reasoning we describe the argumentation-theoretic approach to the use of abduction as an interpretation for Negation as Failure, introduced in the earlier version 88] of this paper and we present recent w ork on the generalisation of the argumentation-theoretic approach t o provide a framework for default reasoning in general. We also analyse the links between Abduction and Constraint Logic Programming, as well as between Abduction and the extension of Logic Programming obtained by adding a form of explicit negation. Finally we discuss the relation between Abduction and Truth Maintenance.

In this paper we present an agent language that combines agent functionality with a state transition theory and model-theoretic semantics. The language is based on abductive logic programming (ALP), but employs a simplified state-free syntax, with an operational semantics that uses destructive updates to manipulate a database, which represents the current state of the environment. The language builds upon the ALP combination of logic programs, to represent an agent's beliefs, and integrity constraints, to represent the agent's goals. Logic programs are used to define macro-actions, intensional predicates, and plans to reduce goals to sub-goals including actions. Integrity constraints are used to represent reactive rules, which are triggered by the current state of the database and recent agent actions and external events. The execution of actions and the assimilation of observations generate a sequence of database states. In the case of the successful solution of all goals, this sequence, taken as a whole, determines a model that makes the agent's goals and beliefs all true.

This paper presents the starting point to adverse event reporting and learning systems designed to describe and prevent unfavorable happenings in Public Services organizations. To achieve this goal, the Eindhoven's Classification Method was changed to house such incidents. On the other hand, the evolutionary process of the knowledge body of such systems is to be understood as a process of energy devaluation, i.e., their data/information/knowledge will be represented and handled as pure energy transactions, being such procedures and the respective outcomes object of formal proof under a Proof Theoretical approach to Problem Solving.

Botswana citizens experience energy shortage especially at the rural areas where grid transmission is not accessible. Therefore, rural dwellers find it difficult to use their gadgets and sometimes they are compelled to travel to nearby places or towns in order to get electricity. Sun energy is available and is a cheaper alternative that could be used to address the problem of power accessibility especially in remote areas. Photovoltaic panels are normally used to harvest the solar energy however they generate a DC electrical signal but majority of modern appliances use AC voltage signal. A power inverter is used to convert DC voltage signal to AC signal, suitable for most house hold appliances. The conversion principle output rely on how efficient the converter is, in terms of losses. The aim of this paper is to compare three (3) different circuits modeled via PSIM software in terms of their efficiency, cost and complexity of circuit construction. The PSIM software uses inbuilt gate...

Time and change are notions that seems unavoidable in some areas of work and investigation, languages that can deal with these notions are necessary. At the same time, methods for a proper time handling are quite complex, mainly because problem's complexity and variety of solutions. Between the languages developed to cover these expectations, under a specific view of time, are [Cobo and Augusto, 1999a] EMTLP and a metric temporal logic's fragment, bounded universal Horn formulae analyzed by Brzoska . Although both of them performed metric temporal programming, they face this fact from different perspectives. In this work we are going to try a comparison between them after a short overview over each. In this first stage we present a way of representing EMTPL's in first order logic using Brzoska's approximation as a bridge, and we also compare some aspects of both programming languages.

Resumen Con el avance de las tecnologías de la informacion se hace cada vez más facil generar y procesar datos con mayor precision acerca de lo que ocurre en un dominio complejo. Las aplicaciones que se desen vuelven en estos entornos se caracterizan por recibir grandes cantidades de datos en poco tiempo, con altas tasas de cambio, como así tambien in certidumbre e incompletitud; a este tipo de torrente de datos -que no se puede almacenar para ser procesado mas adelante -se los conoce con el nombre de "flujos" . En este trabajo presentamos una propuesta para rea lizar procesamiento de flujos de manera inteligente a traves de sistemas argumentativos, proponiendo una combinacion novedosa de (i) tecnicas de procesamiento de flujos de datos y eventos complejos, (ii) herramien tas de argumentacion estructurada, (iii) razonamiento probabilístico y (iv) operadores de revisioín de creencias. Palabras clave: Procesamiento de flujo de datos, Argumentaciín Es tructurada, Razonamiento bajo incertidumbre, Revision de creencias.

This year marks the 40th anniversary of Alan Robinson's seminal paper on "A Machine-Oriented Logic Based on the Resolution Principle" that forms a basis for automated deduction and in particular logic programming, that started some three decades ago with the work of Robert Kowalski and Alain Colmerauer. The workshop on (constraint) logic programming is the annual meeting of the Society of Logic Programming (GLP e.V.) and brings together researchers interested in logic programming, constraint programming, and related areas like databases and artificial intelligence. Previous workshops have been held in Germany, Austria, and Switzerland. The technical program of the workshop included an invited talk, presentations of refereed and accepted papers and system descriptions, as well as non-refereed system demonstrations and poster presentations. The contributions in this volume were reviewed by at least two referees. We would like to thank all authors who submitted papers and all workshop participants for their fruitful discussions. We are grateful to the members of the program committee and of the local organisation as well as to the referees. We would like to express our thanks to the Society of Logic Programming (GLP e.V.) for handling finances and the University of Ulm for hosting the workshop.

This tutorial shows how to use the object-oriented Java constraint programming library firstcs to solve constraint problems. Beyond the architecture of the system and the supported constraints, this presentation focuses on the implementation of new constraints, the modeling of problems and their solutions using constraint propagation and search. The presentation is completed a practical application realized with this constraint library.

Preferential rules occur very often in application domains like timetabling. Besides absolutelyvalid rules like"Ground courseshavetostart in the morningi no ne of the main lecture rooms", there are very often preferential rules like" Aw ish fort he starting timeo falecture should be satisfied with less deviations" or "A wish foraroom of alecture should be satisfied if possible". Our aim is to develop easy-to-use techniques fora pplying preferential rules and to demonstrate their use and efficiency. We are motivated by the non-availabilityo f suitable implementations and the need of efficient execution. The problem,w hich results fromt he twot ypes of knowledge( Fig. ) -a bsolutelyv alid rulesand preferentialr ules -consistsincombining thecalculi to obtainaconsistentand efficient proceduref or knowledgep rocessing.Ausefulp aradigmf or dealingw ith combinatorialc omplex problems, sucha st imetabling, is theirf ormulationa sC onstraint SatisfactionP roblems( CSP).ACSPi sd efinedb yP=( V, D, C) with as et of variables V={V1,...,Vn}, adomainofvaluesfor each of thevariablesD={D1,...,Dn}, andasetof relations (constraints) C={C1,...Cm}. AllC iare considered as hard constraints( part of strict rules),i .e.t heya re true or false.Asolutiono faCSPi saconsistentc omplete assignment of values from Dt oV ,i .e.a ll constraintsh avet ob es atisfied.B esides the rulest hatm ust always be fulfilledt here mayb ea lsor ules in ap roblem that should be fulfilledi fp ossible or in theb estp ossible way. Such rulesa re called" wishes" andt hey can have differentpriorities. Some examples forwishesintimetablingare:

This year marks the 40th anniversary of Alan Robinson's seminal paper on "A Machine-Oriented Logic Based on the Resolution Principle" that forms a basis for automated deduction and in particular logic programming, that started some three decades ago with the work of Robert Kowalski and Alain Colmerauer. The workshop on (constraint) logic programming is the annual meeting of the Society of Logic Programming (GLP e.V.) and brings together researchers interested in logic programming, constraint programming, and related areas like databases and artificial intelligence. Previous workshops have been held in Germany, Austria, and Switzerland. The technical program of the workshop included an invited talk, presentations of refereed and accepted papers and system descriptions, as well as non-refereed system demonstrations and poster presentations. The contributions in this volume were reviewed by at least two referees. We would like to thank all authors who submitted papers and all workshop participants for their fruitful discussions. We are grateful to the members of the program committee and of the local organisation as well as to the referees. We would like to express our thanks to the Society of Logic Programming (GLP e.V.) for handling finances and the University of Ulm for hosting the workshop.

ρ Log-prox is a calculus for rule-based programming with strategies, which supports both exact and approximate computations. Rules are represented as conditional transformations of sequences of expressions, which are built from variadic function symbols and four kinds of variables: for terms, hedges, function symbols, and contexts. ρ Log-prox extends ρ Log by permitting in its programs fuzzy proximity relations, which are reflexive and symmetric, but not transitive. We introduce syntax and operational semantics of ρ Log-prox, illustrate its work by exam-ples, and present a terminating, sound, and complete algorithm for the ρ Log-prox expression matching problem.

PρLog is an experimental extension of logic programming with strategic conditional transformation rules, combining Prolog with ρLog calculus. The rules perform nondeterministic transformations on hedges. Queries may have several results that can be explored on backtracking. Strategies provide a control on rule applications in a declarative way. With stra tegy combinators, the user can construct more complex strategies from simpler ones. Matching with four different kinds of variables provides a flexible mechanism of selecting (sub)terms during executi on. We give an overview on programming with strategies in PρLog and demonstrate how rewriting strategies can be expressed. PρLog (pronounced Pe-ro-log) is an experimental tool that extends logic programming with strategic conditional transformation rules, combining Prolog with ρLog calculus (14). ρLog deals with hedges (sequences of terms), transforming them by conditional rules. Transformations are nondeterministic and may yield sever...

Functional logic programming extends the functional programming style with two important features: the possibility to define nondeterministic operations with overlapping rules, and the usage of logic variables in both defining rules and expressions to evaluate. Conditional constructor-based term rewrite systems (CB-CTRSs) emerged as a suitable model for functional logic programs, because they can be easily transformed into an equivalent program in a core language where computations can be performed more efficiently.We consider a recent proposal by Antoy and Hanus, of translating CB-CTRSs into an equivalent class of programs where computation can be performed by mere rewriting. His computational model has the limitation of computing only ground answer substitutions for equations with strict semantics interpreted as joinability to a value.We propose two adjustments of their computational models, which are capable to compute non-ground answers.

We describe origami programming methodology based on constraint functional logic programming. The basic operations of origami are reduced to solving systems of equations which describe the geometric properties of paper folds. We developed two software components: one that provides primitives to construct, manipulate and visualize paper folds and the other that solves the systems of equations. Using these components, we illustrate computer-supported origami construction and show the significance of the constraint functional logic programming paradigm in the program development.

Common Logic (CL) is a recent ISO standard for exchanging logic-based information between disparate computer systems. Sharing and reasoning upon knowledge represented in CL require equation solving over terms of this language. We study computationally well-behaved fragments of such solving problems and show how they can influence reasoning in CL and transformations of CL expressions.

We describe the foundations of a system for rule-based programming which integrates two powerful mechanisms: (1) matching with context variables, sequence variables, and regular constraints for their matching values; and (2) strategic programming with labeled rules. The system is called ρLog, and is built on top of the pattern matching and rule-based programming capabilities of Mathematica.

Abstract. We describe a matching algorithm for terms built over flexible arity function symbols and context, function, sequence, and individual variables. The algorithm is called a context sequence matching algorithm. Context variables allow matching to descend in term-trees ...

Maude is a wide-spectrum reflective logical language based on rewriting logic that can be used to specify, prototype, and formally analyze concurrent software systems, specification languages, logics, and theorem provers. Because of its efficient implementation, it can also be used as a programming language and as a meta-tool to generate other tools. This paper gives a brief introduction to the language and illustrates with examples some of the features of the current version, available free of charge together with examples, documentation, and papers from SRI: see . The key characteristics of Maude can be summarized as follows: -Based on rewriting logic. This makes it particularly well suited to express concurrent and state-changing aspects of systems declaratively. -Wide-spectrum. Rewriting logic is a logical and semantic framework for both specification and efficient execution. -Multiparadigm. Since rewriting logic conservatively extends equational logic, an equational style of functional programming is naturally supported in a sublanguage. A declarative style of concurrent object-oriented programming is also supported with a simple logical semantics. -Reflective. Rewriting logic is reflective . The design of Maude capitalizes on this fact to support a novel style of metaprogramming with very powerful module-combining and module-transforming operations that surpass those of traditional parameterized programming. -Internal Strategies. The strategies controlling the rewriting process can be defined by rewrite rules and can be reasoned about inside the logic [4, 5, 1]. Maude's implementation has been designed with the explicit goals of supporting executable specification and formal methods applications, of being easily extensible, and of supporting reflective computations. Although it is an interpreter, its advanced semicompilation techniques support flexibility and traceability without sacrificing the performance of up to 1.665 million rewrites per second in the free theory and between 131 thousand, and 1 million rewrites per second if associativity and commutativity axioms are used, on a 500MHz Alpha.

Maude i s a h igh-level l anguage a nd a h igh-performance s ystem s upporting e xecutable speciÿ-cation a nd d eclarative p rogramming i n r ewriting l ogic. S ince r ewriting l ogic contains e quational l ogic, Maude a lso s upports e quational s peciÿcation a nd p rogramming i n its s ublanguage o f f unc-tional modules a nd t heories. T he u nderlying e quational l ogic chosen f or Maude i s membership e quational l ogic, t hat h as s orts, s ubsorts, o perator overloading, a nd p artiality d eÿnable b y mem-bership a nd e quality c onditions. Rewriting l ogic is r e ective, i n t he s ense o f b eing a ble t o e xpress i ts o wn metalevel a t t he o bject l evel. Re ection i s s ystematically e xploited i n Maude e ndowing t he l anguage with p owerful metaprogramming c apabilities, i ncluding b oth u ser-deÿnable module o perations a nd declarative s trategies t o g uide t he d eduction p rocess. T his p aper e xplains a nd i llustrates with e xamples t he main c oncepts o f Maude's l anguage d esign, i ncluding i ts u nder-lying logic, f unctional, s ystem a nd o bject-oriented modules, a s well a s p arameterized modules, theories, a nd v iews. We a lso e xplain h ow Maude s upports r e ection, metaprogramming a nd in-ternal s trategies. T he p aper o utlines t he p rinciples u nderlying t he Maude s ystem implementation, i ncluding i ts s emicompilation t echniques. We c onclude with s ome r emarks about a pplications, work o n a f ormal e nvironment f or Maude, a nd a mobile l anguage extension o f Maude.