arXiv subjects

Daeseong Kang

Publications and source records attributed to Daeseong Kang.

9 recordsLinked to original sources

arXiv2022

Choice Disjunctive Queries in Logic Programming

One of the long-standing research problems on logic programming is to treat the cut predicate in a logical, high-level way. We argue that this problem can be solved by adopting linear logic and choice-disjunctive goal formulas of the form $G_0 \add G_1$ where $G_0, G_1$ are goals. These goals have the following intended semantics: $choose$ the true disjunct $G_i$ and execute $G_i$ where $i (= 0\ {\rm or}\ 1)$, while $discarding$ the unchosen disjunct. Note that only one goal can remain alive during execution. These goals thus allow us to specify mutually exclusive tasks in a high-level way.

cs.LO↗

arXiv2022

Removing Qualified Names in Modular Languages

Although the notion of qualified names is popular in module systems, it causes severe complications. In this paper, we propose an alternative to qualified names. The key idea is to import the declarations in other modules to the current module before they are used. In this way, all the declarations can be accessed locally. However, this approach is not efficient in memory usage. Our contribution is the {\it module weakening} scheme which allows us to import the minimal parts. As an example of this approach, we propose a module system for functional languages.

cs.PL↗

arXiv2020

Agent-Based Proof Design via Lemma Flow Diagram

We discuss an agent-based approach to proof design and implementation, which we call {\it Lemma Flow Diagram} (LFD). This approach is based on the multicut rule with $shared$ cuts. This approach is modular and easy to use, read and automate. Thus, we consider LFD an appealing alternative to `flow proof' which is popular in mathematical education. Some examples are provided.

cs.LO↗

arXiv2017

Local Modules in Imperative Languages

We propose a notion of local modules for imperative langauges. To be specific, we introduce a new implication statement of the form $D \supset G$ where $D$ is a module (i.e., a set of procedure declarations) and $G$ is a statement. This statement tells the machine to add $D$ to the program in the course of executing $G$. Thus, $D$ acts as a local module and will be discarded after executing $G$. It therefore provides efficient module management. We illustrate our idea via C^{mod}, an extension of the core C with the new statement. In addition, we describe a new constructive module language to improve code reuse. Finally, we describe a scheme which considerably improves the heap management in traditional languages.

cs.PL↗

arXiv2017

Towards a Decidable LogicWeb via Length-Bounded Derivations

LogicWeb has traditionally lacked devices for dealing with intractable queries. We address this limitation by adopting length-bounded inference, a form of approximate reasoning. A length-bounded inference is of the form $prov(P,G,n)$ which is a success if a query $G$ can be proved from the web page $P$ within $n$ proof steps. It thus makes LogicWeb decidable and more tractable. During the process, we propose a novel module language for logic programming as a device for structuring programs and queries.

cs.LO↗

arXiv2017

A Concurrent Model for Imperative Languages with Improved Atomicity

We propose a new concurrent model for imperative languages where concurrency occurs at a subprogram level. This model introduces a new {\it block sequential} statement of the form $#(G_1,\ldots,G_n)$ where each $G_i$ is a statement. This statement tells the machine to execute $G_1,\ldots,G_n$ sequentially and atomically (\ie, without interleaving). It therefore enhances atomicity and predictability in concurrent programming. We illustrate our idea via $C^{\|}$, an extension of the core concurrent C with the new block sequential statement.

cs.PL↗

arXiv2015

Bounded-Choice Statements for User Interaction in Imperative and Object-Oriented Programming

Adding versatile interactions to imperative programming -- C, Java and Android -- is an essential task. Unfortunately, existing languages provide only limited constructs for user interaction. These constructs are usually in the form of $unbounded$ quantification. For example, existing languages can take the keyboard input from the user only via the $read(x)/scan(x)$ construct. Note that the value of $x$ is unbounded in the sense that $x$ can have any value. This construct is thus not useful for applications with bounded inputs. To support bounded choices, we propose new bounded-choice statements for user interation. Each input device (the keyboard, the mouse, the touch, $...$) naturally requires a new bounded-choice statement. To make things simple, however, we focus on a bounded-choice statement for keyboard -- kchoose -- to allow for more controlled and more guided participation from the user. It is straightforward to adjust our idea to other input devices. We illustrate our idea via Java(BI), an extension of the core Java with a new bounded-choice statement for the keyboard.

cs.PL↗

arXiv2014

Sequential Operations in LogicWeb

Sequential tasks cannot be effectively handled in logic programming based on classical logic or linear logic. This limitation can be addressed by using a fragment of Japaridze'sSequential tasks cannot be effectively handled in logic programming based on classical logic or linear logic. This limitation can be addressed by using a fragment of Japaridze's computability logic. We propose \seqweb, an extension to LogicWeb with sequential goal formulas. SeqWeb extends the LogicWeb by allowing goals of the form $G\seqand G$ and $G\seqor G$ where $G$ is a goal. These goals allow us to specify both sequential-conjunctive and sequential-disjunctive tasks. computability logic. We propose \seqweb, an extension to LogicWeb with sequential goal formulas. SeqWeb extends the LogicWeb by allowing goals of the form $G\seqand G$ and $G\seqor G$ where $G$ is a goal. These goals allow us to specify both sequential-conjunctive and sequential-disjunctive tasks.

cs.PL↗

arXiv2012

Mutually Exclusive Rules in LogicWeb

LogicWeb has traditionally lacked devices for expressing mutually exclusive clauses. We address this limitation by adopting choice-conjunctive clauses of the form $D_0 \adc D_1$ where $D_0, D_1$ are Horn clauses and $\adc$ is a linear logic connective. Solving a goal $G$ using $D_0 \adc D_1$ -- $\prov(D_0 \adc D_1,G)$ -- has the following operational semantics: choose a successful one between $\prov(D_0,G)$ and $\prov(D_1,G)$. In other words, if $D_o$ is chosen in the course of solving $G$, then $D_1$ will be discarded and vice versa. Hence, the class of choice-conjunctive clauses precisely captures the notion of mutually exclusive clauses.

cs.LO↗