Francisco-Jesús Martín-Mateos

Foundational challenges in automated semantic Web data and ontology cleaning

Nowadays, Web-based data management needs tools to ensure secure, trustworthy performance. The Utopian future shows a semantic Web providing dependable framework that can solve many of todays data problems. However, the realistic immediate future raises several challenges, including foundational semantic Web issues, the abstract definition of data, and incomplete, evolving ontologies. In either case, the marriage of data and ontologies is indissoluble and represents the knowledge database (KDB), a basic ingredient of the semantic Web. In this article, we look closely at problems in data analysis, the first phase of data cleaning. Applying automated reasoning systems to semantic Web data cleaning and to cleaning-agent design raises many challenges. We can build trust in semantic Web logic only if its based on certified reasoning.

Formal Proofs About Rewriting Using ACL2

We present an application of the ACL2 theorem prover to reason about rewrite systems theory. We describe the formalization and representation aspects of our work using the first-order, quantifier-free logic of ACL2 and we sketch some of the main points of the proof effort. First, we present a formalization of abstract reduction systems and then we show how this abstraction can be instantiated to establish results about term rewriting. The main theorems we mechanically proved are Newmans lemma (for abstract reductions) and Knuth–Bendix critical pair theorem (for term rewriting).

ACL2 Verification of Simplicial Degeneracy Programs in the Kenzo System

Kenzo is a Computer Algebra system devoted to Algebraic Topology, and written in the Common Lisp programming language. It is a descendant of a previous system called EAT (for Effective Algebraic Topology). Kenzo shows a much better performance than EAT due, among other reasons, to a smart encoding of degeneracy lists as integers. In this paper, we give a complete automated proof of the correctness of this encoding used in Kenzo. The proof is carried out using ACL2, a system for proving properties of programs written in (a subset of) Common Lisp. The most interesting idea, from a methodological point of view, is our use of EAT to build a model on which the verification is carried out. Thus, EAT, which is logically simpler but less efficient than Kenzo, acts as a mathematical model and then Kenzo is formally verified against it.

Formal verification of a generic framework to synthesize SAT-provers

We present in this paper an application of the ACL2 system to generate and reason about propositional satisfiability provers. For that purpose, we develop a framework in which we define a generic S AT-prover based on transformation rules, and we formalize this generic framework in the ACL2 logic, carrying out a formal proof of its termination, soundness, and completeness. This generic framework can be instantiated to obtain a number of verified and executable SAT-provers in ACL2, and this instantiation can be done in an automated way. Three instantiations of the generic framework are considered: semantic tableaux, sequent calculus, and Davis-Putnam-Logeman-Loveland methods.

Formalization of a normalization theorem in simplicial topology

In this paper we present a complete formalization of the Normalization Theorem, a result in Algebraic Simplicial Topology stating that there exists a homotopy equivalence between the chain complex of a simplicial set, and a smaller chain complex for the same simplicial set, called the normalized chain complex. Even if the Normalization Theorem is usually stated as a higher-order result (with a Category Theory flavor) we manage to give a first-order proof of it. To this aim it is instrumental the introduction of an algebraic data structure called simplicial polynomial. As a demonstration of the validity of our techniques we developed a formal proof in the ACL2 theorem prover.

Formal Correctness of a Quadratic Unification Algorithm

We present a case study using ACL2 to verify a nontrivial algorithm that uses efficient data structures. The algorithm receives as input two first-order terms, and it returns a most general unifier of these terms if they are unifiable, failure otherwise. The verified implementation stores terms as directed acyclic graphs by means of a pointer structure. Its time complexity is

A Formal Proof of Dickson's Lemma in ACL2

O(n^2)

Formalizing Rewriting in the ACL2 Theorem Prover

and its space complexity

Verifying the bridge between simplicial topology and algebra: the Eilenberg–Zilber algorithm

O(n)

Applying ACL2 to the formalization of algebraic topology: simplicial polynomials

, and it can be executed in ACL2 at a speed comparable to a similar C implementation. We report the main issues encountered to achieve this formally verified implementation.