Lucid : a formal system for writing and proving programs

Lucid is both a programming language and a formal system for proving properties of Lucid programs. The programming language is unconventional in many ways, although programs are readily understood as using assignment statements and loops in a 'structured' fashion. Semantically, an assignment statement is really an equation between 'histories', and a whole program is simply an unordered set of such equations. From these equations, properties of the program can be derived by straightforward mathematical reasoning, using the Lucid formal system. The rules of this system are mainly those of first order logic, together with extra axioms and rules for the special Lucid functions. This paper formally describes the syntax and semantics of programs and justifies the axioms and rules of the formal system

Integrating Logic Rules with Everything Else, Seamlessly

This paper presents a language, Alda, that supports all of logic rules, sets, functions, updates, and objects as seamlessly integrated built-ins. The key idea is to support predicates in rules as set-valued variables that can be used and updated in any scope, and support queries using rules as either explicit or implicit automatic calls to an inference function. We have defined a formal semantics of the language, implemented a prototype compiler that builds on an object-oriented language that supports concurrent and distributed programming and on an efficient logic rule system, and successfully used the language and implementation on benchmarks and problems from a wide variety of application domains. We describe the compilation method and results of experimental evaluation.Comment: To be published in Theory and Practice of Logic Programming, Special issue for selected papers from 39nd International Conference on Logic Programming. arXiv admin note: substantial text overlap with arXiv:2205.1520

Combining Proofs and Programs in a Dependently Typed Language

Most dependently-typed programming languages either require that all expressions terminate (e.g. Coq, Agda, and Epigram), or allow infinite loops but are inconsistent when viewed as logics (e.g. Haskell, ATS, mega). Here, we combine these two approaches into a single dependently-typed core language. The language is composed of two fragments that share a common syntax and overlapping semantics: a logic that guarantees total correctness, and a call-by-value programming language that guarantees type safety but not termination. The two fragments may interact: logical expressions may be used as programs; the logic may soundly reason about potentially nonterminating programs; programs can require logical proofs as arguments; and “mobile” program values, including proofs computed at runtime, may be used as evidence by the logic. This language allows programmers to work with total and partial functions uniformly, providing a smooth path from functional programming to dependently-typed programming. Categories and Subject Descriptors D.3.1 [Programming Languages]: Formal Definitions and Theory Keywords Dependent types; Termination; General recursio

Consequences and Design in General and Transcendental Logic

In this article, I consider Kant’s dichotomy between general and transcendental logic in light of a retrospective reconstruction of two approaches originating in 14th century scholasticism that are used to demarcate formal and material consequences. The first approach (e. g., John Buridan, Albert of Saxony, Marsilius of Inghen) holds that a consequence is formal if it is valid — because of its form only — for any matter. Since the matter of a consequence is linked to categorematic terms, its formal validity is defined as being invariant under substitutions for such terms. According to the second approach (e. g., Richard Billingham, Robert Fland, Ralph Strode, Richard Lavenham), the validity of a formal consequence stems from the formal understanding of the consequent in the consequence’s antecedent. I put forward the hypothesis that in his logical taxo­nomy, Kant attempted to reconcile the substitutional interpretation of formal consequences and a formal analysis of the transcendental relations of objects of experience. However, if we interpret the limi­tations imposed by transcendental logic on the power of judgement in the spirit of the scholastic ontology of transcendental relations, it would contradict Kant’s critique of dogmatic ontology. Following in Luciano Floridi’s path, I thus propose to consider transcendental logic, not as a system of consequences equipped with ontologically grounded transcendental limitations, but rather as the logic of design. The logic of design has the benefit of enriching traditional logical tools with a series of notions borrowed primarily from computer programming. A conceptual system designer sets out feasibility requirements and defines a system’s functions that make it possible to achieve the desired outcome using available resources. Kant’s project forbids a dogmatic appeal to the transcendental relations and eternal truths of scholasticism. However, the constitutive nature of the rules of transcendental logic in regard to the power of judgement precludes the pluralism of conceptual systems that can be interpreted within possible experience. Thus, the optimisation problem of finding the best conceptual design from all feasible designs is beyond the competence of transcendental logic

Quality of the information : the application in the winification process in wine production

Knowledge representation techniques as a way to describe the real world, based on mechanical, logical or other means, will be, always, a function of the systems ability to describe the existing world. Knowledge and belief are generally incomplete, contradictory, or error sensitive, being desirable to use formal tools to deal with the problems that arise from the use of incomplete, contradictory, ambiguous, imperfect, or missing information. It is important to evaluate the quality-of-information of the knowledge around the time in order to analyze the best conditions of the universe of the discourse. Based on the vinification process of the wine production this paper analyzes the quality-of-information in the various stages of the process applying Extended Logic Programming as logic mathematical functions

An Operational Semantics for Declarative Multi-Paradigm Languages1 1This work has been partially supported by CICYT TIC 2001-2705-C03-01, by the MCYT under grants HA2001-0059, HU2001-0019 and HI2000-0161, and by the DFG under grant Ha 2457/1-2.

AbstractPractical declarative multi-paradigm languages combine the main features of functional, logic and concurrent programming (e.g., laziness, sharing, higher-order, logic variables, non-determinism, search strategies). Usually, these languages also include interfaces to external functions as well as to constraint solvers. In this work, we introduce the first formal description of an operational semantics for realistic multi-paradigm languages covering all the aforementioned features in a precise and understandable manner. We also provide a deterministic version of the operational semantics which models search strategies explicitly. This deterministic semantics becomes essential to develop language-specific tools like program tracers, profilers, optimizers, etc. Finally, we extend the deterministic semantics in order to model concurrent computations. An implementation of the complete operational semantics has been undertaken