Results 1 
9 of
9
Metatheory and Reflection in Theorem Proving: A Survey and Critique
, 1995
"... One way to ensure correctness of the inference performed by computer theorem provers is to force all proofs to be done step by step in a simple, more or less traditional, deductive system. Using techniques pioneered in Edinburgh LCF, this can be made palatable. However, some believe such an appro ..."
Abstract

Cited by 57 (2 self)
 Add to MetaCart
One way to ensure correctness of the inference performed by computer theorem provers is to force all proofs to be done step by step in a simple, more or less traditional, deductive system. Using techniques pioneered in Edinburgh LCF, this can be made palatable. However, some believe such an approach will never be efficient enough for large, complex proofs. One alternative, commonly called reflection, is to analyze proofs using a second layer of logic, a metalogic, and so justify abbreviating or simplifying proofs, making the kinds of shortcuts humans often do or appealing to specialized decision algorithms. In this paper we contrast the fullyexpansive LCF approach with the use of reflection. We put forward arguments to suggest that the inadequacy of the LCF approach has not been adequately demonstrated, and neither has the practical utility of reflection (notwithstanding its undoubted intellectual interest). The LCF system with which we are most concerned is the HOL proof ...
Axiomatizing Reflective Logics and Languages
 Proceedings of Reflection'96
, 1996
"... The very success and breadth of reflective techniques underscores the need for a general theory of reflection. At present what we have is a wideranging variety of reflective systems, each explained in its own idiosyncratic terms. Metalogical foundations can allow us to capture the essential aspects ..."
Abstract

Cited by 35 (20 self)
 Add to MetaCart
The very success and breadth of reflective techniques underscores the need for a general theory of reflection. At present what we have is a wideranging variety of reflective systems, each explained in its own idiosyncratic terms. Metalogical foundations can allow us to capture the essential aspects of reflective systems in a formalismindependent way. This paper proposes metalogical axioms for reflective logics and declarative languages based on the theory of general logics [34]. In this way, several strands of work in reflection, including functional, equational, Horn logic, and rewriting logic reflective languages, as well as a variety of reflective theorem proving systems are placed within a common theoretical framework. General axioms for computational strategies, and for the internalization of those strategies in a reflective logic are also given. 1 Introduction Reflection is a fundamental idea. In logic it has been vigorously pursued by many researchers since the fundamental wor...
Formal Interoperability
, 1998
"... this paper I briefly sketch recent work on metalogical foundations that seems promising as a conceptual basis on which to achieve the goal of formal interoperability. Specificaly, I will briefly discuss: ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
this paper I briefly sketch recent work on metalogical foundations that seems promising as a conceptual basis on which to achieve the goal of formal interoperability. Specificaly, I will briefly discuss:
Formalization and Reasoning in a Reflective Architecture
, 1995
"... This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC. An encoding of ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC. An encoding of this object calculus within itself comprises the metalevel, and reflection principles are provided for switching between di#erent levels. These reflection principles are used to mix object and metalevel reasoning, to generate "standard" units by executing metaoperators, and to apply formal tactics that allow for abstraction from the base logic.
Reflection in Rewriting Logic and its Applications in the Maude Language
 In IMSA'97, pages 128139. InformationTechnology Promotion Agency
, 1997
"... this paper applications of reflection in rewriting logic and Maude to the following areas: ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
this paper applications of reflection in rewriting logic and Maude to the following areas:
A Reflective Framework for Formal Interoperability
, 1998
"... In practice we find ourselves in constant need of moving back and forth between different formalizations capturing different aspects of a system. For example, in a large software system we typically have very different requirements, such as functional correctness, performance, realtime behavior, co ..."
Abstract
 Add to MetaCart
In practice we find ourselves in constant need of moving back and forth between different formalizations capturing different aspects of a system. For example, in a large software system we typically have very different requirements, such as functional correctness, performance, realtime behavior, concurrency, security, and fault tolerance, which correspond to different views of the system and that are typically expressed in different formal systems. Often these requirements affect each other, but it can be extremely difficult to reason about their mutual interaction, and no tools exist to support such reasoning. This situation is very unsatisfactory, and presents one of the biggest obstacles to the use of formal methods in software engineering because, given the complexity of large software systems, it is a fact of life that no single perspective, no single formalization or level of abstraction suffices to represent a system and reason about its behavior. We need (meta)formal methods and tools to achieve Formal Interoperability, that is, the capacity to move in a mathematically rigorous way across the different formalizations of a system, and to use in a rigorously integrated way the different tools supporting these formalizations. We will develop new, formal interoperability methodologies and generic metatools that are expected to achieve dramatic advances in software technology and formal methods:
Reflection and its Use:
, 2002
"... this paper is inspired by that notion, but focuses on a special aspect: zooming out in reflection works via the mechanism of coding. The 9 main thesis of Hofstadter is that `strange loops' are at the basis of selfconsciousness. I partly agree with this thesis and would like to add that mindful ..."
Abstract
 Add to MetaCart
this paper is inspired by that notion, but focuses on a special aspect: zooming out in reflection works via the mechanism of coding. The 9 main thesis of Hofstadter is that `strange loops' are at the basis of selfconsciousness. I partly agree with this thesis and would like to add that mindfulness serves as the necessary zooming mechanism in the strange loop of selfconsciousness. On the other hand, the thesis only explains the `self' aspect, the consciousness part still remains obscure. I disagree with the title of Dennet [1993]: `Consciousness explained'. No matter how many levels of cognition and feedback we place on top of sensory input in a model of the mind, it a prioiri seems not able to account for experiences. We always could simulated these processes on an oldfashioned computer consisting of relais, or even play it as a social game with cards. It is not that I object to base our consciousness on outer agents like the cardplayers (we depend on nature in a similar way). It is the claimed emergence of consciousness as a side e#ect of the cardgame that seems absurd
and
, 2014
"... Effective support for custom proof automation is essential for largescale interactive proof development. However, existing languages for automation via tactics either (a) provide no way to specify the behavior of tactics within the base logic of the accompanying theorem prover, or (b) rely on adva ..."
Abstract
 Add to MetaCart
Effective support for custom proof automation is essential for largescale interactive proof development. However, existing languages for automation via tactics either (a) provide no way to specify the behavior of tactics within the base logic of the accompanying theorem prover, or (b) rely on advanced typetheoretic machinery that is not easily integrated into established theorem provers. We present Mtac, a lightweight but powerful extension to Coq that supports dependentlytyped tactic programming. Mtac tactics have access to all the features of ordinary Coq programming, as well as a new set of typed tactical primitives. We avoid the need to touch the trusted kernel typechecker of Coq by encapsulating uses of these new tactical primitives in a monad, and instrumenting Coq so that it executes monadic tactics during type inference. 1
Formalization and Reasoning in a Reflective Architecture
"... Abstract This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC. An en ..."
Abstract
 Add to MetaCart
Abstract This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC. An encoding of this object calculus within itself comprises the metalevel, and reflection principles are provided for switching between different levels. These reflection principles are used to mix object and metalevel reasoning, to generate &quot;standard &quot; units by executing metaoperators, and to apply formal tactics that allow for abstraction from the basic inference rules. 1 Introduction Formalizing artifacts of software development and software engineering activities that produce these artifacts is, according to [2], a central issue of knowledgebased software engineering. Here we propose a reflective architecture based on a typetheoretic calculus that is capable of expressing most units of the software development process like theorems, specifications, proofs, programs, and relative implementations between specifications in order to formalize schematic developments as operators on the metalevel. These metaoperators are applied to specific problems by means of reflection principles that connect object and metalevel. Formalizing software development steps as executable (meta) operators supports several aspects of the by now almost universally accepted goal of reusability, which involves not only reuse of program fragments but also of designs and developments, and, in the context of fully formal approaches, proofs.