140 research outputs found
Research in mathematical theory of computation
Research progress in the following areas is reviewed: (1) new version of computer program LCF (logic for computable functions) including a facility to search for proofs automatically; (2) the description of the language PASCAL in terms of both LCF and in first order logic; (3) discussion of LISP semantics in LCF and attempt to prove the correctness of the London compilers in a formal way; (4) design of both special purpose and domain independent proving procedures specifically program correctness in mind; (5) design of languages for describing such proof procedures; and (6) the embedding of ideas in the first order checker
An Entailment Relation for Reasoning on the Web
Reasoning on the Web is receiving an increasing attention because of emerging fields such as Web adaption and Semantic Web. Indeed, the advanced functionalities striven for in these fields call for reasoning capabilities. Reasoning on the Web, however, is usually done using existing techniques rarely fitting the Web. As a consequence, additional data processing like data conversion from Web formats (e.g. XML or HTML) into some other formats (e.g. classical logic terms and formulas) is often needed and aspects of the Web (e.g. its inherent inconsistency) are neglected. This article first gives requirements for an entailment tuned to reasoning on the Web. Then, it describes how classical logic’s entailment can be modified so as to enforce these requirements. Finally, it discusses how the proposed entailment can be used in applying logic programming to reasoning on the Web
Second-Order Functions and Theorems in ACL2
SOFT ('Second-Order Functions and Theorems') is a tool to mimic second-order
functions and theorems in the first-order logic of ACL2. Second-order functions
are mimicked by first-order functions that reference explicitly designated
uninterpreted functions that mimic function variables. First-order theorems
over these second-order functions mimic second-order theorems universally
quantified over function variables. Instances of second-order functions and
theorems are systematically generated by replacing function variables with
functions. SOFT can be used to carry out program refinement inside ACL2, by
constructing a sequence of increasingly stronger second-order predicates over
one or more target functions: the sequence starts with a predicate that
specifies requirements for the target functions, and ends with a predicate that
provides executable definitions for the target functions.Comment: In Proceedings ACL2 2015, arXiv:1509.0552
Abstraction in situation calculus action theories
We develop a general framework for agent abstraction based on the situation calculus and the ConGolog agent programming language. We assume that we have a high-level specification and a low-level specification of the agent, both repre- sented as basic action theories. A refinement mapping specifies how each high-level action is implemented by a low- level ConGolog program and how each high-level fluent can be translated into a low-level formula. We define a notion of sound abstraction between such action theories in terms of the existence of a suitable bisimulation between their respective models. Sound abstractions have many useful properties that ensure that we can reason about the agent’s actions (e.g., executability, projection, and planning) at the abstract level, and refine and concretely execute them at the low level. We also characterize the notion of complete abstraction where all actions (including exogenous ones) that the high level thinks can happen can in fact occur at the low level
Abstraction in situation calculus action theories
We develop a general framework for agent abstraction based on the situation calculus and the ConGolog agent programming language. We assume that we have a high-level specification and a low-level specification of the agent, both repre- sented as basic action theories. A refinement mapping specifies how each high-level action is implemented by a low- level ConGolog program and how each high-level fluent can be translated into a low-level formula. We define a notion of sound abstraction between such action theories in terms of the existence of a suitable bisimulation between their respective models. Sound abstractions have many useful properties that ensure that we can reason about the agent’s actions (e.g., executability, projection, and planning) at the abstract level, and refine and concretely execute them at the low level. We also characterize the notion of complete abstraction where all actions (including exogenous ones) that the high level thinks can happen can in fact occur at the low level
Hierarchical agent supervision
Agent supervision is a form of control/customization where a supervisor restricts the behavior of an agent to enforce certain requirements, while leaving the agent as much autonomy as possible. To facilitate supervision, it is often of interest to consider hierarchical models where a high level abstracts over low-level behavior details. We study hierarchical agent supervision in the context of the situation calculus and the ConGolog agent programming language, where we have a rich first-order representation of the agent state. We define the constraints that ensure that the controllability of in-dividual actions at the high level in fact captures the controllability of their implementation at the low level. On the basis of this, we show that we can obtain the maximally permissive supervisor by first considering only the high-level model and obtaining a high- level supervisor and then refining its actions locally, thus greatly simplifying the supervisor synthesis task
Feedback Generation for Performance Problems in Introductory Programming Assignments
Providing feedback on programming assignments manually is a tedious, error
prone, and time-consuming task. In this paper, we motivate and address the
problem of generating feedback on performance aspects in introductory
programming assignments. We studied a large number of functionally correct
student solutions to introductory programming assignments and observed: (1)
There are different algorithmic strategies, with varying levels of efficiency,
for solving a given problem. These different strategies merit different
feedback. (2) The same algorithmic strategy can be implemented in countless
different ways, which are not relevant for reporting feedback on the student
program.
We propose a light-weight programming language extension that allows a
teacher to define an algorithmic strategy by specifying certain key values that
should occur during the execution of an implementation. We describe a dynamic
analysis based approach to test whether a student's program matches a teacher's
specification. Our experimental results illustrate the effectiveness of both
our specification language and our dynamic analysis. On one of our benchmarks
consisting of 2316 functionally correct implementations to 3 programming
problems, we identified 16 strategies that we were able to describe using our
specification language (in 95 minutes after inspecting 66, i.e., around 3%,
implementations). Our dynamic analysis correctly matched each implementation
with its corresponding specification, thereby automatically producing the
intended feedback.Comment: Tech report/extended version of FSE 2014 pape
On algorithmic equivalence of instruction sequences for computing bit string functions
Every partial function from bit strings of a given length to bit strings of a
possibly different given length can be computed by a finite instruction
sequence that contains only instructions to set and get the content of Boolean
registers, forward jump instructions, and a termination instruction. We look
for an equivalence relation on instruction sequences of this kind that captures
to a reasonable degree the intuitive notion that two instruction sequences
express the same algorithm.Comment: 27 pages, the preliminaries have textual overlaps with the
preliminaries in arXiv:1308.0219 [cs.PL], arXiv:1312.1529 [cs.PL], and
arXiv:1312.1812 [cs.PL]; 27 pages, three paragraphs about Milner's
algorithmic equivalence hypothesis added to concluding remarks; 26 pages,
several minor improvements of the presentation mad
Three Simulation Algorithms for Labelled Transition Systems
Algorithms which compute the coarsest simulation preorder are generally
designed on Kripke structures. Only in a second time they are extended to
labelled transition systems. By doing this, the size of the alphabet appears in
general as a multiplicative factor to both time and space complexities. Let
denotes the state space, the transition relation, the
alphabet and the partition of induced by the coarsest simulation
equivalence. In this paper, we propose a base algorithm which minimizes, since
the first stages of its design, the incidence of the size of the alphabet in
both time and space complexities. This base algorithm, inspired by the one of
Paige and Tarjan in 1987 for bisimulation and the one of Ranzato and Tapparo in
2010 for simulation, is then derived in three versions. One of them has the
best bit space complexity up to now,
, while another one has the
best time complexity up to now, . Note the
absence of the alphabet in these complexities. A third version happens to be a
nice compromise between space and time since it runs in
time, with a branching factor generally
far below , and uses
bits
- …