arXiv subjects
Publications and source records attributed to Keehang Kwon.
In this paper, we present two new forms of the $write$ statement: one of the form $write(x);G$ where $G$ is a statement and the other of the form $write(x);D$ where $D$ is a module. The former is a generalization of traditional $write$ statement and is quite useful. The latter is useful for implementing interactive modules.
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.
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.
In this paper, we bring anonymous variables into imperative languages. Anonymous variables represent don't-care values and have proven useful in logic programming. To bring the same level of benefits into imperative languages, we describe an extension to C wth anonymous variables.
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.
Logic programming has traditiLogic programming has traditionally lacked devices for expressing iterative tasks. To overcome this problem, this paper proposes iterative goal formulas of the form $\seqandq{x}{L} G$ where $G$ is a goal, $x$ is a variable, and $L$ is a list. $\seqandq{x}{L}$ is called a parallel bounded quantifier. These goals allow us to specify the following task: iterate $G$ with $x$ ranging over all the elements of $L$. onally lacked devices for expressing iterative tasks. To overcome this problem, this paper proposes iterative goal formulas of the form $\seqandq{x}{L} G$ where $G$ is a goal, $x$ is a variable, and $L$ is a list. $\seqandq{x}{L}$ is called a parallel bounded quantifier. These goals allow us to specify the following task: iterate $G$ with $x$ ranging over all the elements of $L$.
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.
While event handling is a key element in modern interactive programming, it is unfortunate that its theoretical foundation is rather weak. To solve this problem, we propose to adopt a game-logical approach of computability logic \cite{Jap08} to event handling.
Inductions and game semantics are two useful extensions to traditional logic programming. To be specific, inductions can capture a wider class of provable formulas in logic programming. Adopting game semantics can make logic programming more interactive. In this paper, we propose an execution model for a logic language with these features. This execution model follows closely the reasoning process in real life.
Logic programming with fixed-point definitions is a useful extension of traditional logic programming. Fixed-point definitions can capture simple model checking problems and closed-world assumptions. Its operational semantics is typically based on intuitionistic provability. We extend the operational semantics of these languages with game semantics. This extended semantics has several interesting aspects: in particular, it gives a logical status to the $read$ predicate.
Adding interaction to logic programming is an essential task. Expressive logics such as linear logic provide a theoretical basis for such a mechanism. Unfortunately, none of the existing linear logic languages can model interactions with the user. This is because they uses provability as the sole basis for computation. We propose to use the game semantics instead of provability as the basis for computation to allow for more active participation from the user. We illustrate our idea via muprolog, an extension of Prolog with choice-disjunctive clauses.
The class of first-order Hereditary Harrop formulas ($fohh$) is a well-established extension of first-order Horn clauses. Its operational semantics is based on intuitionistic provability. We propose another operational semantics for $fohh$ which is based on game semantics. This new semantics has several interesting aspects: in particular, it gives a logical status to the $read$ predicate in Prolog.
Linear logic programming uses provability as the basis for computation. In the operational semantics based on provability, executing the additive-conjunctive goal $G_1 \& G_2$ from a program $P$ simply terminates with a success if both $G_1$ and $G_2$ are solvable from $P$. This is an unsatisfactory situation, as a central action of \& -- the action of choosing either $G_1$ or $G_2$ by the user -- is missing in this semantics. We propose to modify the operational semantics above to allow for more active participation from the user. We illustrate our idea via muProlog, an extension of Prolog with additive goals.
Logic programming has traditionally lacked devices for expressing mutually exclusive modules. We address this limitation by adopting choice-conjunctive modules of the form $D_0 \& D_1$ where $D_0, D_1$ are a conjunction of Horn clauses and $\&$ is a linear logic connective. Solving a goal $G$ using $D_0 \& D_1$ -- $exec(D_0 \& D_1,G)$ -- has the following operational semantics: $choose$ a successful one between $exec(D_0,G)$ and $exec(D_1,G)$. In other words, if $D_0$ is chosen in the course of solving $G$, then $D_1$ will be discarded and vice versa. Hence, the class of choice-conjunctive modules can capture the notion of mutually exclusive modules.
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.
To represent mutually exclusive procedures, we propose a choice-conjunctive declaration statement of the form $uchoo(S,R)$ where $S, R$ are the procedure declaration statements within a module. This statement has the following semantics: request the machine to choose a successful one between $S$ and $R$. This statement is useful for representing objects with mutually exclusive procedures. We illustrate our idea via C^uchoo, an extension of the core C with a new statement.
Selection statements -- if-then-else, switch and try-catch -- are commonly used in modern imperative programming languages. We propose another selection statement called a {\it choice existentially quantified statement}. This statement turns out to be quite useful for pattern matching among several merits. Examples will be provided for this statement.
Adding versatile interactions to goals and queries in logic programming is an essential task. Unfortunately, existing logic languages can take input from the user only via the $read$ construct. We propose to add a new interactive goal to allow for more controlled and more guided participation from the user. We illustrate our idea via \muprolog, an extension of Prolog with bounded choice goals.