Frege and the Logic of Sense and Reference

A meta-program, regardless of the nature of the programming language, is a program whose data denotes another (object) program. The importance of meta-programming can be gauged from its large number of applications. These include compilers, interpreters, program analysers, and program transformers. Furthermore, if the object program is a logic or functional program formalizing some knowledge, then the meta-program may be regarded as a meta-reasoner for reasoning about this knowledge. In this chapter, the meta-program is assumed to be a logic program. The object program does not have to be a logic program although much of the work in this chapter assumes this. We have identified three major topics for consideration. These are the theoretical foundations of meta-programming, the suitability of the alternative meta-programming techniques for different applications, and methods for improving the efficiency of meta-programs. As with logic programs generally, meta-programs have declarative and procedural semantics. The theoretical study of meta-programming shows that both aspects of the semantics depend crucially on the manner in which object programs are represented as data in a meta-program. The second theme of the paper is the problem of designing and choosing appropriate ways of specifying important meta-programming problems, including dynamic metaprogramming and problems involving self-application. The third theme concerns efficient implementation of meta-programs. Meta-programming systems require representations with facilities that minimize the overhead of interpreting the object program. In addition, efficiency can be gained by transforming the meta-program, specializing it for the particular object program it is reasoning about. This chapter, which concentrates on these aspects of meta-programming, is not intended to be a survey of the field. A more complete survey of meta-programming for logic programming can be found in [Barklund, 1995]. Many issues in meta-programming have their roots in problems in logic which have been studied for several decades. This chapter emphasizes meta-programming solutions. It is not intended to give a full treatment of the underlying logical problems, though we try to indicate some connections to wider topics in meta-logic. The meta-programs in this chapter are logic programs based on first order logic.

The Hajós calculus is a simple, nondeterministic procedure that generates the class of non-3-colorable graphs. Mansfield and Welsch posed the question of whether there exist graphs that require exponential-sized Hajós constructions. Unless ${\text{NP}} \ne {\text{coNP}}$, there must exist graphs that require exponential-sized constructions, but to date, little progress has been made on this question, despite considerable effort. In this paper, we prove that the Hajós calculus generates polynomial-sized constructions for all non-3-colorable graphs if and only if extended Frege systems are polynomially bounded. Extended Frege systems are a very powerful family of proof systems for proving tautologies, and proving superpolynomial lower bounds for these systems is a long-standing, important problem in logic and complexity theory. We also establish a relationship between a complete subsystem of the Hajós calculus and bounded-depth Frege systems; this enables us to prove exponential lower bounds on this subsystem of the Hajós calculus.

Comparison of Programmable Logic and Setting Group Methods for adaptive overcurrent protection in microgrids

The authors study the decidability of redundancy detection in logic programs which are composed of inference rules with functions in their arguments. They formally define redundancies based on the solution sets in logic programs, and represent solution sets in well-defined domains. They prove that redundancy detection in inference rules with functions is undecidable. The theoretical results obtained here complete the previously unknown properties of redundancy detection of logic programs. Except for nonrecursive inference rules, redundancy detection is undecidable in general. Although general results reveal the inherent difficulty of efficient execution of logic programs through redundancy detection, special redundant cases can still be detected and pruned. Tradeoffs between compile-time analysis of decidable cases and run-time checking of undecidable cases can still be made. >

Game semantics for non-monotonic intensional logic programming

Formal verification involves the use of logical and computational methods to establish claims that are expressed in precise mathematical terms. These can include ordinary mathematical theorems, as well as claims that pieces of hardware or software, network protocols, and mechanical and hybrid systems meet their specifications. In practice, there is not a sharp distinction between verifying a piece of mathematics and verifying the correctness of a system: formal verification requires describing hardware and software systems in mathematical terms, at which point establishing claims as to their correctness becomes a form of theorem proving. Conversely, the proof of a mathematical theorem may require a lengthy computation, in which case verifying the truth of the theorem requires verifying that the computation does what it is supposed to do. The gold standard for supporting a mathematical claim is to provide a proof, and twentieth-century developments in logic show most if not all conventional proof methods can be reduced to a small set of axioms and rules in any of a number of foundational systems. With this reduction, there are two ways that a computer can help establish a claim: it can help find a proof in the first place, and it can help verify that a purported proof is correct. Automated theorem proving focuses on the “finding” aspect. Resolution theorem provers, tableau theorem provers, fast satisfiability solvers, and so on provide means of establishing the validity of formulas in propositional and first-order logic. Other systems provide search procedures and decision procedures for specific languages and domains, such as linear or nonlinear expressions over the integers or the real numbers. Architectures like SMT (“satisfiability modulo theories”) combine domain-general search methods with domain-specific procedures. Computer algebra systems and specialized mathematical software packages provide means of carrying out mathematical computations, establishing mathematical bounds, or finding mathematical objects. A calculation can be viewed as a proof as well, and these systems, too, help establish mathematical claims. Automated reasoning systems strive for power and efficiency, often at the expense of guaranteed soundness. Such systems can have bugs, and it can be difficult to ensure that the results they deliver are correct. In contrast, interactive theorem proving focuses on the “verification” aspect of theorem proving, requiring that every claim is supported by a proof in a suitable axiomatic foundation. This sets a very high standard: every rule of inference and every step of a calculation has to be justified by appealing to prior definitions and theorems, all the way down to basic axioms and rules. In fact, most such systems provide fully elaborated “proof objects” that can be communicated to other systems and checked independently. Constructing such proofs typically requires much more input and interaction from users, but it allows us to obtain deeper and more complex proofs. The Lean Theorem Prover aims to bridge the gap between interactive and automated theorem proving, by situating automated tools and methods in a framework that supports user interaction and the construction of fully specified axiomatic proofs. The goal is to support both mathematical reasoning and reasoning about complex systems, and to verify claims in both domains.

The Semantic Web is a vision for the future of the Web in which information is given explicit meaning, making it easier for machines to automatically process and integrate information available on the Web[1]. In semantic web, Knowledge can be encoded using a formal language termed as OWL (Ontology Web Language). To keep this language alive Progression of OWL2 from OWL is one such major step. OWL2 is a strong Modeling language and extends the W3C OWL with a small but useful set of features. The objective of this study is an attempt to highlight those features and to provide and indepth analysis on: a. Introduction to three profiles of OWL2 with a particular focus on how these profiles differ and why the differences are important. b. Comparison of OWL Profiles on the basis of Usage, Reasoning Time, Complexity and Algorithms. c. Reasoning in OWL RL Profile and comparison of Reasoners in OWL RL Profiles. Keywords: OWL – Ontology Web Language, OWL axioms – Inference rules

Does Frege have a metatheory for his logic? There is an obvious and uncontroversial sense in which he does. Frege introduces and discusses his new logic in natural language; he argues, in response to criticisms of Begriffsschrift, that his logic is superior to Boole's by discussing formal features of both systems. In so far as the enterprise of using natural language to introduce, discuss, and argue about features of a formal system is metatheoretic, there can be no doubt: Frege has a metatheory. There is also an obvious and uncontroversial sense in which Frege does not have a metatheory for his logic. The model theoretic semantics with which we are familiar today are a post-Fregean development. The question I address in this paper is, does Frege have a metatheory in the following sense: do his justifications of his basic laws and rules of inference employ, or even require, ineliminable use of a truth predicate and metalinguistic variables? My answer is ‘no’ on both counts. I argue that Frege neither uses, nor has any need to use, a truth predicate or metalinguistic variables in his justifications of his basic laws and rules of inference. Quine's famous explanation of the need for semantic ascent simply does not apply to Frege's logic. The purpose of the discussions that are typically understood as constituting Frege's metatheory is, rather, elucidatory. And once we see what the aim of these particular elucidations is, we can explain Frege's otherwise puzzling eschewal of the truth predicate in his discussions of the justification of the laws and rules of inference.

Logical rationalism asserts that we can acquire immediate, non-inferential justification for beliefs in basic logical principles. The intuitions that arise when we consider particular cases of validity can offer justification for our foundational logical beliefs about rules of inference. I motivate rationalism through an argument from the indispensability of intuitions. This argument shows that rationalism is the theory best equipped to solve the problem of background logic. This is the challenge of explaining how we gain justified beliefs in rules of inference without using those rules in a viciously circular way to arrive at the beliefs. As rationalism is the best epistemology which solves this important challenge, it is our best account of logical knowledge. In addition, I argue that a second major motivation for logical rationalism arises from work on logical practice. Recently, it has been claimed that we should attend to the practices of logicians when selecting an epistemology of logic. I argue that these considerations from logical practice also favour the adoption of logical rationalism.

The Maldivian language, better known as Dhivehi, is an Indo-European language closely related to Singhalese spoken in nearby Sri Lanka and other languages found on the Indian subcontinent. The Maldivians choose language, Dhivehi or English, and writing system, Taana or Roman letters, to publish their messages. Taana is characterized by DeSilva as a mixture of both Indic and Semitic (Perso-Arabic) traditions. By this he means that it has the characteristics of an alpha-syllabary and of the Arabic writing system. The Dhivehi writing system Taana survived the introduction of typewriters and computers. This success of Taana has resulted in blend of Taana and Roman writing. English words may be given in Taana or Roman script while Dhivehi words may be given in Roman or Taana script. It is not unusual for two scripts to co-exist for the same language. When language changes orthography, this situation is common. Keywords: DeSilva; Dhivehi; Maldivian language; Roman script; Roman writing; Taana script; writing system

Logic programming, as exemplified by datalog, defines the meaning of a program as its unique smallest model: the deductive closure of its inference rules. However, many problems call for an enumeration of models that vary along some set of choices while maintaining structural and logical constraints—there is no single canonical model. The notion of stable models for logic programs with negation has successfully captured programmer intuition about the set of valid solutions for such problems, giving rise to a family of programming languages and associated solvers known as answer set programming. Unfortunately, the definition of a stable model is frustratingly indirect, especially in the presence of rules containing free variables. We propose a new formalism, finite-choice logic programming, that uses choice, not negation, to admit multiple solutions. Finite-choice logic programming contains all the expressive power of the stable model semantics, gives meaning to a new and useful class of programs, and enjoys a least-fixed-point interpretation over a novel domain. We present an algorithm for exploring the solution space and prove it correct with respect to our semantics. Our implementation, the Dusa logic programming language, has performance that compares favorably with state-of-the-art answer set solvers and exhibits more predictable scaling with problem size.

Binary code similarity analysis (BCSA) is widely used for diverse security applications, including plagiarism detection, software license violation detection, and vulnerability discovery. Despite the surging research interest in BCSA, it is significantly challenging to perform new research in this field for several reasons. First, most existing approaches focus only on the end results, namely, increasing the success rate of BCSA, by adopting uninterpretable machine learning. Moreover, they utilize their own benchmark, sharing neither the source code nor the entire dataset. Finally, researchers often use different terminologies or even use the same technique without citing the previous literature properly, which makes it difficult to reproduce or extend previous work. To address these problems, we take a step back from the mainstream and contemplate fundamental research questions for BCSA. Why does a certain technique or a certain feature show better results than the others? Specifically, we conduct the first systematic study on the basic features used in BCSA by leveraging interpretable feature engineering on a large-scale benchmark. Our study reveals various useful insights on BCSA. For example, we show that a simple interpretable model with a few basic features can achieve a comparable result to that of recent deep learning-based approaches. Furthermore, we show that the way we compile binaries or the correctness of underlying binary analysis tools can significantly affect the performance of BCSA. Lastly, we make all our source code and benchmark public and suggest future directions in this field to help further research.

Multiset rewriting has proved to be a useful presentation of process synchronization [1, 2, 3, 6]. Since sequent calculus presentations of logics that do not use the structural rules of contractions and weakening are based on using multisets of formulas as left and right contexts, it is natural to identify processes with formulas, multisets with sequent contexts, and multiset rewriting as an inference rule. Given earlier work on using sequent calculus to describe logic programming as goal-directed search for proofs [8], it is most natural to use right-hand contexts of sequents to represent multisets of processes. This choice requires the identification of the multiset constructor and the empty multiset with the multiplicative disjunction and false (the and ⊥ of linear logic [4]), and backchaining with a single step of multiset rewriting. While the logic programming language λProlog [10] and its linear logic refinement Lolli [5] contain rich sources of abstraction (such as modular programming, abstract data types, and higher-order programming), they contain no primitives for specifying concurrency, communications, or synchronization. If multiset rewriting is added to Lolli via the logical connectives and ⊥, the result is a language that contains primitives for both abstraction and concurrency. Surprisingly, the resulting logic, called Forum [7], is a presentation of all of linear logic in the sense that all of the connectives of linear logic can be defined via logical equivalences using only the connectives of Forum. Thus the rich meta-theory of linear logic, for example, the de Morgan dualities and cut-elimination, can be applied to the analysis of Forum programs. Several examples to illustrate the expressiveness of this presentation of linear logic will be given. These examples will involve a specification of sequent calculi for object-level logics, a specification of the π-calculus [9], and a specification of a functional programming language that contains side-effects and concurrency operators. In each of these examples, we shall argue that the specification is perspicuous and modular and that the meta-theory of linear logic can be used to derive properties of the specification.

This essay explores the early history of Herbert Simon's principle of bounded rationality in the context of his Artificial Intelligence research in the mid 1950s. It focuses in particular on how Simon and his colleagues at the RAND Corporation translated a model of human reasoning into a computer program, the Logic Theory Machine. They were motivated by a belief that computers and minds were the same kind of thing--namely, information-processing systems. The Logic Theory Machine program was a model of how people solved problems in elementary mathematical logic. However, in making this model actually run on their 1950s computer, the JOHNNIAC, Simon and his colleagues had to navigate many obstacles and material constraints quite foreign to the human experience of logic. They crafted new tools and engaged in new practices that accommodated the affordances of their machine, rather than reflecting the character of human cognition and its bounds. The essay argues that tracking this implementation effort shows that "internal" cognitive practices and "external" tools and materials are not so easily separated as they are in Simon's principle of bounded rationality--the latter often shaping the dynamics of the former.

The paper introduces a knowledge representation language that combines the event calculus with description logic in a logic programming framework. The purpose is to provide the user with an expressive language for modelling and analysing systems that evolve over time. The approach is exemplified with the logic programming language as implemented in the Fusemate system. The paper extends Fusemate's rule language with a weakly DL-safe interface to the description logic $\cal ALCIF$ and adapts the event calculus to this extended language. This way, time-stamped ABoxes can be manipulated as fluents in the event calculus. All that is done in the frame of Fusemate's concept of stratification by time. The paper provides conditions for soundness and completeness where appropriate. Using an elaborated example it demonstrates the interplay of the event calculus, description logic and logic programming rules for computing possible models as plausible explanations of the current state of the modelled system.