2,795 research outputs found
A realizability semantics for inductive formal topologies, Church's Thesis and Axiom of Choice
We present a Kleene realizability semantics for the intensional level of the
Minimalist Foundation, for short mtt, extended with inductively generated
formal topologies, Church's thesis and axiom of choice. This semantics is an
extension of the one used to show consistency of the intensional level of the
Minimalist Foundation with the axiom of choice and formal Church's thesis in
previous work. A main novelty here is that such a semantics is formalized in a
constructive theory represented by Aczel's constructive set theory CZF extended
with the regular extension axiom
Eliminating Recursion from Monadic Datalog Programs on Trees
We study the problem of eliminating recursion from monadic datalog programs
on trees with an infinite set of labels. We show that the boundedness problem,
i.e., determining whether a datalog program is equivalent to some nonrecursive
one is undecidable but the decidability is regained if the descendant relation
is disallowed. Under similar restrictions we obtain decidability of the problem
of equivalence to a given nonrecursive program. We investigate the connection
between these two problems in more detail
Computer Science and Metaphysics: A Cross-Fertilization
Computational philosophy is the use of mechanized computational techniques to
unearth philosophical insights that are either difficult or impossible to find
using traditional philosophical methods. Computational metaphysics is
computational philosophy with a focus on metaphysics. In this paper, we (a)
develop results in modal metaphysics whose discovery was computer assisted, and
(b) conclude that these results work not only to the obvious benefit of
philosophy but also, less obviously, to the benefit of computer science, since
the new computational techniques that led to these results may be more broadly
applicable within computer science. The paper includes a description of our
background methodology and how it evolved, and a discussion of our new results.Comment: 39 pages, 3 figure
The Need to Support of Data Flow Graph Visualization of Forensic Lucid Programs, Forensic Evidence, and their Evaluation by GIPSY
Lucid programs are data-flow programs and can be visually represented as data
flow graphs (DFGs) and composed visually. Forensic Lucid, a Lucid dialect, is a
language to specify and reason about cyberforensic cases. It includes the
encoding of the evidence (representing the context of evaluation) and the crime
scene modeling in order to validate claims against the model and perform event
reconstruction, potentially within large swaths of digital evidence. To aid
investigators to model the scene and evaluate it, instead of typing a Forensic
Lucid program, we propose to expand the design and implementation of the Lucid
DFG programming onto Forensic Lucid case modeling and specification to enhance
the usability of the language and the system and its behavior. We briefly
discuss the related work on visual programming an DFG modeling in an attempt to
define and select one approach or a composition of approaches for Forensic
Lucid based on various criteria such as previous implementation, wide use,
formal backing in terms of semantics and translation. In the end, we solicit
the readers' constructive, opinions, feedback, comments, and recommendations
within the context of this short discussion.Comment: 11 pages, 7 figures, index; extended abstract presented at VizSec'10
at http://www.vizsec2010.org/posters ; short paper accepted at PST'1
Mechanizing Principia Logico-Metaphysica in Functional Type Theory
Principia Logico-Metaphysica contains a foundational logical theory for
metaphysics, mathematics, and the sciences. It includes a canonical development
of Abstract Object Theory [AOT], a metaphysical theory (inspired by ideas of
Ernst Mally, formalized by Zalta) that distinguishes between ordinary and
abstract objects.
This article reports on recent work in which AOT has been successfully
represented and partly automated in the proof assistant system Isabelle/HOL.
Initial experiments within this framework reveal a crucial but overlooked fact:
a deeply-rooted and known paradox is reintroduced in AOT when the logic of
complex terms is simply adjoined to AOT's specially-formulated comprehension
principle for relations. This result constitutes a new and important paradox,
given how much expressive and analytic power is contributed by having the two
kinds of complex terms in the system. Its discovery is the highlight of our
joint project and provides strong evidence for a new kind of scientific
practice in philosophy, namely, computational metaphysics.
Our results were made technically possible by a suitable adaptation of
Benzm\"uller's metalogical approach to universal reasoning by semantically
embedding theories in classical higher-order logic. This approach enables one
to reuse state-of-the-art higher-order proof assistants, such as Isabelle/HOL,
for mechanizing and experimentally exploring challenging logics and theories
such as AOT. Our results also provide a fresh perspective on the question of
whether relational type theory or functional type theory better serves as a
foundation for logic and metaphysics.Comment: 14 pages, 6 figures; preprint of article with same title to appear in
The Review of Symbolic Logi
kLog: A Language for Logical and Relational Learning with Kernels
We introduce kLog, a novel approach to statistical relational learning.
Unlike standard approaches, kLog does not represent a probability distribution
directly. It is rather a language to perform kernel-based learning on
expressive logical and relational representations. kLog allows users to specify
learning problems declaratively. It builds on simple but powerful concepts:
learning from interpretations, entity/relationship data modeling, logic
programming, and deductive databases. Access by the kernel to the rich
representation is mediated by a technique we call graphicalization: the
relational representation is first transformed into a graph --- in particular,
a grounded entity/relationship diagram. Subsequently, a choice of graph kernel
defines the feature space. kLog supports mixed numerical and symbolic data, as
well as background knowledge in the form of Prolog or Datalog programs as in
inductive logic programming systems. The kLog framework can be applied to
tackle the same range of tasks that has made statistical relational learning so
popular, including classification, regression, multitask learning, and
collective classification. We also report about empirical comparisons, showing
that kLog can be either more accurate, or much faster at the same level of
accuracy, than Tilde and Alchemy. kLog is GPLv3 licensed and is available at
http://klog.dinfo.unifi.it along with tutorials
Monoidal computer III: A coalgebraic view of computability and complexity
Monoidal computer is a categorical model of intensional computation, where
many different programs correspond to the same input-output behavior. The
upshot of yet another model of computation is that a categorical formalism
should provide a much needed high level language for theory of computation,
flexible enough to allow abstracting away the low level implementation details
when they are irrelevant, or taking them into account when they are genuinely
needed. A salient feature of the approach through monoidal categories is the
formal graphical language of string diagrams, which supports visual reasoning
about programs and computations.
In the present paper, we provide a coalgebraic characterization of monoidal
computer. It turns out that the availability of interpreters and specializers,
that make a monoidal category into a monoidal computer, is equivalent with the
existence of a *universal state space*, that carries a weakly final state
machine for any pair of input and output types. Being able to program state
machines in monoidal computers allows us to represent Turing machines, to
capture their execution, count their steps, as well as, e.g., the memory cells
that they use. The coalgebraic view of monoidal computer thus provides a
convenient diagrammatic language for studying computability and complexity.Comment: 34 pages, 24 figures; in this version: added the Appendi
Induction of First-Order Decision Lists: Results on Learning the Past Tense of English Verbs
This paper presents a method for inducing logic programs from examples that
learns a new class of concepts called first-order decision lists, defined as
ordered lists of clauses each ending in a cut. The method, called FOIDL, is
based on FOIL (Quinlan, 1990) but employs intensional background knowledge and
avoids the need for explicit negative examples. It is particularly useful for
problems that involve rules with specific exceptions, such as learning the
past-tense of English verbs, a task widely studied in the context of the
symbolic/connectionist debate. FOIDL is able to learn concise, accurate
programs for this problem from significantly fewer examples than previous
methods (both connectionist and symbolic).Comment: See http://www.jair.org/ for any accompanying file
Evaluating Datalog via Tree Automata and Cycluits
We investigate parameterizations of both database instances and queries that
make query evaluation fixed-parameter tractable in combined complexity. We show
that clique-frontier-guarded Datalog with stratified negation (CFG-Datalog)
enjoys bilinear-time evaluation on structures of bounded treewidth for programs
of bounded rule size. Such programs capture in particular conjunctive queries
with simplicial decompositions of bounded width, guarded negation fragment
queries of bounded CQ-rank, or two-way regular path queries. Our result is
shown by translating to alternating two-way automata, whose semantics is
defined via cyclic provenance circuits (cycluits) that can be tractably
evaluated.Comment: 56 pages, 63 references. Journal version of "Combined Tractability of
Query Evaluation via Tree Automata and Cycluits (Extended Version)" at
arXiv:1612.04203. Up to the stylesheet, page/environment numbering, and
possible minor publisher-induced changes, this is the exact content of the
journal paper that will appear in Theory of Computing Systems. Update wrt
version 1: latest reviewer feedbac
Reasoning About a Simulated Printer Case Investigation with Forensic Lucid
In this work we model the ACME (a fictitious company name) "printer case
incident" and make its specification in Forensic Lucid, a Lucid- and
intensional-logic-based programming language for cyberforensic analysis and
event reconstruction specification. The printer case involves a dispute between
two parties that was previously solved using the finite-state automata (FSA)
approach, and is now re-done in a more usable way in Forensic Lucid. Our
simulation is based on the said case modeling by encoding concepts like
evidence and the related witness accounts as an evidential statement context in
a Forensic Lucid program, which is an input to the transition function that
models the possible deductions in the case. We then invoke the transition
function (actually its reverse) with the evidential statement context to see if
the evidence we encoded agrees with one's claims and then attempt to
reconstruct the sequence of events that may explain the claim or disprove it.Comment: 18 pages, 3 figures, 7 listings, TOC, index; this article closely
relates to arXiv:0906.0049 and arXiv:0904.3789 but to remain stand-alone
repeats some of the background and introductory content; abstract presented
at HSC'09 and the full updated paper at ICDF2C'11. This is an updated/edited
version after ICDF2C proceedings with more references and correction
- …