Copy Link
Add to Bookmark
Report
NL-KR Digest Volume 04 No. 14
NL-KR Digest (2/08/88 20:22:26) Volume 4 Number 14
Today's Topics:
Chinese character generator
need help on Common-Window/KEE/IntelliCorp
Chinese-English translation.
Seminar - Learning Search Control Knowledge (AT&T)
From CSLI Calendar, January 28, 3:15
Seminar - The Thinkertools Project (BBN)
Seminar - BREAD, FRAPPE, and CAKE: Automated Deduction (SRI)
Seminar - Qualitative Probabilistic Networks (MIT)
Seminar - AI, NL, and Object-Oriented Databases at HP (NASA)
BBN AI Seminar: Edwin Pednault
Submissions: NL-KR@CS.ROCHESTER.EDU
Requests, policy: NL-KR-REQUEST@CS.ROCHESTER.EDU
----------------------------------------------------------------------
Date: Tue, 2 Feb 88 13:10 EST
From: Alan Munn <212624%UMDD.BITNET@CUNYVM.CUNY.EDU>
Subject: Chinese character generator
We are doing psycholinguistic research in language processing. We need
a way of generating Chinese characters from pinyin input. A full fledged
word processor would not suffice since we need to create the characters
in conjuntion with our testing software. Does anyone have or know of
software to do this? Any machine type would do, although our first
preference would be an IBM AT, second a Sun.
Alan Munn
Linguistics Program
University of Maryland
College Park MD 20742
(301) 454-7002
BITNET: 212624@umdd
Internet: 212624@umdd.umd.edu
------------------------------
Date: Wed, 3 Feb 88 16:37 EST
From: nico nieh <steinmetz!steinmetz!hudson!nieh@uunet.UU.NET>
Subject: need help on Common-Window/KEE/IntelliCorp
I am doing some software development on KEE (Knowledge
Engineering Environment, IntelliCorp). I tried to
display a large file using Common-Window with extent
scrolling feature and each token (word) is represented as a hostspot.
Users may use mouse to pick up any token and to click a mouse button
to activate an action. It worked OK. However the scrolling
is extremely slow. I knew that I must did something stupid.
Related code is enclosed. Can any one out there give me some help?
Thanks in advance,
PS: Please forward this message to whomever who may help me out.
$$cut$$
;; -*- Mode: LISP; Syntax:Common-lisp; Package:KEE; Base:10. -*-
(defvar ww nil) ;; working window
(defvar *working-file-name* nil)
(defvar *active-hs* nil)
(defun make-fop-window ()
(setq ww (make-window-stream :left 10
:bottom 10
:width 1100
:height 800
:inner-left 10
:inner-bottom 10
:activate-p t
:title "FOP Parsing Table Generator"
:parent *kee-root-window*
:font-set (list (open-font 'fixed-width
'plain
'medium))))
)
(defvar *script-file* nil)
(defvar *text* nil)
(defun initialize-everything (file-name)
(setq *text* nil)
(setq *text* (revert-buffer-file file-name))
)
(defun fop (&optional (file-name "c.dat") (script-file "script.lisp"))
(setq *script-file* script-file)
(setq *working-file-name* file-name)
(make-fop-window)
(initialize-everything file-name)
(enable-window-stream-extent-scrolling ww)
(setf (window-stream-extent-height ww) 3000)
(setf (window-stream-repaint ww) 'test-repaint)
(setf (window-stream-button ww) 'button-fn)
(setf (window-stream-y-offset ww) 2250)
(repaint ww)
)
(defun test-repaint (window region)
(setf (window-stream-hotspot-list window) nil)
(bitblt window
(window-stream-x-offset window)
(window-stream-y-offset window)
window
(window-stream-x-offset window)
(window-stream-y-offset window)
(window-stream-inner-width window)
(window-stream-inner-height window)
boole-clr)
(setf (window-stream-x-position window) 0)
(setf (window-stream-y-position window) (- (window-stream-extent-height window)
(window-stream-ascent window)))
(write-title ww (concat "FOP working buffer "
" ---------- "
*working-file-name*))
(setq khn *text*)
(do (tmp line line-id word-id (seg-id 1)) ((null khn))
(if (< (nth 0 (car khn)) 0)
(progn
(format ww "~2D --: " seg-id)
(setq seg-id (1+ seg-id)))
(format ww "~5D: " (nth 0 (car khn))))
(setq line-id (nth 0 (car khn)))
(setq line (nth 1 (car khn)))
(setq word-id 0)
(setq tmp (break-line line))
(do (str ) ((null tmp))
(setq str (car tmp))
(if (eq '#\space (char str 0))
(format ww str)
(progn
(generate-hotspot
(window-stream-x-position window)
(window-stream-y-position window)
str line-id word-id window)
(setq word-id (1+ word-id))))
(setq tmp (cdr tmp)))
(terpri window)
(setq khn (cdr khn)))
)
(defstruct HOTSPOT region)
(defstruct (MY-HOTSPOT
(:include hotspot))
menu-to-pop-up
yes-no-menu
line-id word-id
function-to-call)
(defun generate-hotspot (x y text line-id word-id window
&optional
(function-to-call 'default-fn)
(menu insert-mark-menu)
(y-or-n-menu yes-or-no-menu))
(let* ((old-hs (window-stream-hotspot-list window))
(hs (make-my-hotspot))
(font (window-stream-font window))
(width (font-string-width font text))
(height (font-character-height font)))
(setf (window-stream-x-position window) x)
(setf (window-stream-y-position window) y)
(format window text)
(setf (my-hotspot-region hs)
(make-region :left x
:bottom (- y (window-stream-baseline window))
:width width :height height))
(setf (my-hotspot-function-to-call hs) function-to-call)
(setf (my-hotspot-menu-to-pop-up hs) menu)
(setf (my-hotspot-line-id hs) line-id)
(setf (my-hotspot-word-id hs) word-id)
(setf (my-hotspot-yes-no-menu hs) y-or-n-menu)
(setf (window-stream-hotspot-list window)
(cons hs old-hs))))
(defun button-fn (window mouse-state)
(let ((hs (hotspot-under-position window
(mouse-state-position mouse-state))))
(if hs
(progn
(setq *active-hs* hs)
(funcall (my-hotspot-function-to-call hs) window mouse-state hs))
(documentation-print "nothing is picked"))
))
(defun default-fn (window mouse-state hs)
(let ((region (my-hotspot-region hs)))
(bitblt window
(region-left region) (region-bottom region)
window
(region-left region) (region-bottom region)
(region-width region) (region-height region)
boole-c1)
(if (equal *hs-action-type* 'select-any-key-word)
(pop-up-cascading-menu-choose (my-hotspot-yes-no-menu hs))
(pop-up-cascading-menu-choose (my-hotspot-menu-to-pop-up hs)))
(bitblt window
(region-left region) (region-bottom region)
window
(region-left region) (region-bottom region)
(region-width region) (region-height region)
boole-c1)))
Ko-Haw Nieh
General Electric Company | ARPA: nieh@ge-crd.arpa
Corporate Research and Development | UUCP: nieh@moose.steinmetz.ge.com
P.O BOX 8, K1-ES224 | UUCP: {uunet!}steinmetz!nieh!crd
Schenectady, NY 12301 | 518-387-7431
------------------------------
Date: Thu, 4 Feb 88 16:16 EST
From: De Yang Song <dsong@hawk.ulowell.edu>
Subject: Chinese-English translation.
Can somebody give me a brief list of references on Chinese-
English translation? We are currently working on this project
and we find it hard to find literatures. Any suggestions are
appreciated.
Chris Song. dsong@hawk.ulowell.edu
------------------------------
Date: Wed, 27 Jan 88 14:47 EST
From: dlm%research.att.com@RELAY.CS.NET
Subject: Seminar - Learning Search Control Knowledge (AT&T)
Learning Effective Search Control Knowledge: An Explanation-Based Approach
Steven Minton
Carnegie-Mellon University
Monday, February 1, 1988
10:30 AM
AT&T Bell Laboratories - Murray Hill 3C-436
In order to solve problems more effectively with accumulating
experience, a problem solver must be able to learn and exploit search
control knowledge. In this talk, I will discuss the application of
explanation-based learning (EBL) techniques for acquiring
domain-specific control knowledge. Although previous research has
demonstrated that EBL is a viable approach for acquiring control
knowledge, in practice EBL may not always generate useful control
knowledge. For control knowledge to be effective, the cumulative
benefits of applying the knowledge must outweigh the cumulative costs of
testing whether the knowledge is applicable. Generating effective
control knowledge may be difficult, as evidenced by the complexities
often encountered by human knowledge engineers. In general, control
knowledge cannot be indiscriminately added to a system; its costs and
benefits must be carefully taken into account.
To produce effective control knowledge, an explanation-based learner
must generate "good" explanations -- explanations that can be profitably
employed to control problem solving. In this talk, I will discuss the
utility of EBL and describe the PRODIGY system, a problem solver that
learns by searching for good explanations. I will also briefly describe
a formal model of EBL and a proof that PRODIGY's generalization
algorithm is correct.
Sponsor: Ron Brachman
------------------------------
Date: Wed, 27 Jan 88 20:08 EST
From: Emma Pease <emma@alan.stanford.edu>
Subject: From CSLI Calendar, January 28, 3:15
[Extracted from CSLI Calendar]
NEXT WEEK'S TINLUNCH
Reading: "Some Uses of Higher-Order Logic
in Computational Linguistics"
by Dale A. Miller and Gopalan Nadathur
from "24th Annual Meeting of the Association for Computational
Linguistics: Proceedings of the Conference" (1986)
Discussion led by Douglas Edwards
(edwards@warbucks.ai.sri.com)
4 February 1988
Miller and Nadathur present a system of higher-order logic (typed
lambda-calculus) as a suitable formalism for the representation of
syntactic and semantic information in computational linguistics. They
argue that such a formalism is clearer and more natural than available
alternatives. They also reply point by point to certain standard
criticisms of the computational use of higher-order logic. In
particular, they argue that:
(1) Theoretical linguistics is often heavily committed to higher-order
logic anyway (Montague Semantics, for example) and it will be
easier to design working systems to fit a theory if the
computational formalism mirrors the ontology of the theory.
(2) Even if a first-order formalism is used to represent the semantics
of sentences, *reasoning* about semantics is an inherently
higher-order process and cannot be represented with full
naturalness in the same formalism. This fact leads to the use of
ad hoc procedures for semantics and to the development of separate
semantic and syntactic formalisms. The use of higher-order logic
allows easier integration of semantic and syntactic processing.
(3) The formalization of semantic processing in first-order formalisms
like Prolog is bedevilled by the need to consider explicitly the
intricate processes of substitution and variable binding. A logic
programming language for higher-order logic, like Miller and
Nadathur's LambdaProlog, obviates this need through the use of
beta-conversion in the language itself.
(4) The difficulty of theorem-proving in higher-order logic is evaded
by confining attention to a restricted set of formulas (analogous
to Horn clauses in first-order logic) and lowering sights from
full theorem-proving to logic programming, using a highly
restricted proof procedure. If more is needed, restricted
theorem-provers can easily be designed *within* LambdaProlog.
It would also appear that much ordinary reasoning even outside of
linguistic semantics is higher-order. Are Miller and Nadathur right
in thinking that their formalism can help to bridge the gap between
linguistic theory and computational practice?
--------------
NEXT WEEK'S SEMINAR
A Nonmonotonic Account of Causation
Yoav Shoham
(shoham@score.stanford.edu)
4 February 1988
We suggest that taking into account considerations that traditionally
fall within the scope of computer science in general, and artificial
intelligence in particular, may shed light on the concept of
causation. We argue that causal reasoning is a mechanism for making
coarse, but fairly reliable, inferences in the absence of full
information. Specifically, we propose that the concept of causation is
intimately bound to that of nonmonotonic reasoning. We offer an
account of causation which relies on this connection, and briefly
compare our proposal to previous accounts of causation within
philosophy.
------------------------------
Date: Thu, 28 Jan 88 14:20 EST
From: Marc Vilain <MVILAIN@G.BBN.COM>
Subject: Seminar - The Thinkertools Project (BBN)
BBN Science Development Program
AI/Education Seminar Series Lecture
THE THINKERTOOLS PROJECT:
CAUSAL MODELS, CONCEPTUAL CHANGE, AND SCIENCE EDUCATION
Barbara Y. White and Paul Horwitz
BBN Labs, Education Dept.
(BYWHITE@G.BBN.COM, PHORWITZ@G.BBN.COM)
BBN Labs
10 Moulton Street
2nd floor large conference room
10:30 am, Thursday February 4 (NOTE UNUSUAL DAY)
This talk will describe an approach to science education that enables
sixth graders to learn principles underlying Newtonian mechanics, and to
apply them in unfamiliar problem solving contexts. The students'
learning is centered around problem solving and experimentation within a
set of computer microworlds (i.e., interactive simulations). The
objective is for students to acquire gradually an increasingly
sophisticated causal model for reasoning about how forces affect the
motion of objects. To facilitate the evolution of such a mental model,
the microworlds incorporate a variety of linked alternative
representations for force and motion, and a set of game-like problem
solving activities designed to focus the students' inductive learning
processes. As part of the pedagogical approach, students formalize what
they learn into a set of laws, and critically examine these laws, using
criteria such as correctness, generality, and parsimony. They then go
on to apply their laws to a variety of real world problems. The
approach synthesizes the learning of the subject matter with learning
about the nature of scientific knowledge -- what are scientific laws,
how do they evolve, and why are they useful? Instructional trials found
that the curriculum is equally effective for males and females, and for
students of different ability levels. Further, sixth graders taught
with this approach do better on classic force and motion problems than
high school students taught using traditional methods.
------------------------------
Date: Thu, 28 Jan 88 15:23 EST
From: Amy Lansky <lansky@venice.ai.sri.com>
Subject: Seminar - BREAD, FRAPPE, and CAKE: Automated Deduction (SRI)
BREAD, FRAPPE, AND CAKE:
THE GOURMET'S GUIDE TO AUTOMATED DEDUCTION
Yishai A. Feldman (YISHAI@AI.AI.MIT.EDU)
AI Laboratory, MIT
11:00 AM, WEDNESDAY, February 3
SRI International, Building E, Room EJ228
Cake is the knowledge representation and reasoning system developed as
part of the Programmer's Apprentice project. Cake can be thought of
as an active database, which performs quick and shallow deduction
automatically; it supports both forward-chaining and backward-chaining
reasoning. The Cake system has a layered architecture: the kernel of
the system, called Bread (for Basic REAsoning Device), is a
truth-maintenance system with equality and demons. Built on top of
this is Frappe (for FRAmes in a ProPositional Engine), which
implements a typed logic with special-purpose decision procedures for
various algebraic properties of operators (such as commutativity and
associativity), sets, partial functions, and structured objects
(frames). Only the topmost layer of Cake, which implements the Plan
Calculus, is specific to reasoning about programs. This talk will
describe the architecture and features of Bread, Frappe, and Cake,
including a transcript of a demonstration session. This is joint work
with Charles Rich.
VISITORS: Please arrive 5 minutes early so that you can be escorted up
from the E-building receptionist's desk. Thanks!
------------------------------
Date: Mon, 1 Feb 88 15:14 EST
From: Peter de Jong <DEJONG%OZ.AI.MIT.EDU@XX.LCS.MIT.EDU>
Subject: Seminar - Qualitative Probabilistic Networks (MIT)
[Extracted from cog-sci-calendar digest]
Date: Monday, 1 February 1988 11:31-EST
From: Paul Resnick <pr at ht.ai.mit.edu>
Re: Revolving Seminar Thursday Feb. 4-- Mike Wellman
Thursday 4, February 4:00pm Room: NE43- 8th floor Playroom
The Artificial Intelligence Lab
Revolving Seminar Series
Qualitative Probabilistic Networks
Mike Wellman
Many knowledge representation schemes model the world as a collection of
variables connected by links that describe their interrelationships.
The representations differ widely in the nature of the fundamental
objects and in the precision and expressiveness of the relationship
links. Qualitative probabilistic networks occupy a region in
representation space where the variables are arbitrary and the
relationships are qualitative constraints on the joint probability
distribution among them.
Two basic types of qualitative relationship are supported by the
formalism. Qualitative influences describe the direction of the
relationship between two variables and qualitative synergies describe
interactions among influences. The probabilistic semantics of these
relationships justify sound and efficient inference procedures based on
graphical manipulations of the network. These procedures answer queries
about qualitative relationships among variables separated in the
network. An example from medical therapy planning illustrates the use
of QPNs to formulate tradeoffs by determining structural properties of
optimal assignments to decision variables.
------------------------------
Date: Tue, 2 Feb 88 13:46 EST
From: JARED%PLU@ames-io.ARPA
Subject: Seminar - AI, NL, and Object-Oriented Databases at HP (NASA)
National Aeronautics and Space Administration
Ames Research Center
SEMINAR ANNOUNCEMENT
SPEAKER: Dr. Steven Rosenberg
Hewlett Packard, HP Labs
TOPIC: AI, Natural Language, and Object-Oriented Databases at HP
ABSTRACT:
Hewlett Packard Labs is the research arm of the Hewlett Packard Corporation.
HP labs conducts research in technologies ranging from AI to super-
conductivity. A brief overview of computer science research at HP Labs
will be presented with a focus on AI, Natural Language, and object-oriented
databases.
BIOGRAPHY:
Dr. Steven Rosenberg is the former department manager, Expert Systems
Department, Hewlett-Packard Laboratories. Prior to joining HP, he worked
at the Lawrence Berkeley Laboratories, and at the MIT AI Lab. At HP
he has led the development of expert systems such as Photolithography
Advisor, an expert system that diagnoses wafer flaws due to photolithography
errors, and recommends corrective action. He has also led the development
of expert system programming languages such as HP-RL, an expert system
language that has been used within HP and at several universities for
constructing expert systems. He is currently involved in developing new
research collaborations between HP and the university community.
DATE: Tuesday, TIME: 1:30 - 3:00 pm BLDG. 244 Room 103
February 9, 1988 --------------
POINT OF CONTACT: Marlene Chin PHONE NUMBER: (415) 694-6525
NET ADDRESS: chin%plu@ames-io.arpa
VISITORS ARE WELCOME: Register and obtain vehicle pass at Ames Visitor
Reception Building (N-253) or the Security Station near Gate 18. Do not
use the Navy Main Gate.
Non-citizens (except Permanent Residents) must have prior approval from the
Director's Office one week in advance. Submit requests to the point of
contact indicated above. Non-citizens must register at the Visitor
Reception Building. Permanent Residents are required to show Alien
Registration Card at the time of registration.
------------------------------
Date: Wed, 3 Feb 88 16:38 EST
From: Marc Vilain <MVILAIN@G.BBN.COM>
Subject: BBN AI Seminar: Edwin Pednault
BBN Science Development Program
AI Seminar Series Lecture
SYNTHESIZING PLANS THAT CONTAIN ACTIONS
WITH CONTEXT-DEPENDENT EFFECTS
Edwin P.D. Pednault
AT&T Bell Laboratories
Holmdel, New Jersey
(!vax135!epdp@UCBVAX.BERKELEY.EDU)
BBN Labs
10 Moulton Street
3rd floor large conference room
10:30 am, Tuesday February 9th
Conventional domain-independent planning systems have typically excluded
actions whose effects depend on the situations in which they occur,
largely because of the action representations that are employed.
However, some of the more interesting actions in the real world have
context-dependent effects. In this talk, I will present a planning
technique that specifically addresses such actions. The technique is
compatible with conventional methods in that plans are constructed via
an incremental process of introducing actions and posting subgoals. The
key component of the approach is the idea of a secondary precondition.
Whereas primary preconditions define executability conditions of actions,
a secondary precondition defines a context in which an action produces a
desired effect. By introducing and then achieving the appropriate
secondary preconditions as additional subgoals to actions, we ensure
that the actions are carried out in contexts conducive to producing the
effects we desire. The notion of a secondary preconditions will be
defined and analyzed. It will also be shown how secondary preconditions
can be derived in a general and domain-independent fashion for actions
specified in ADL, a STRIPS-like language suitable for describing
context-dependent effects.
------------------------------
End of NL-KR Digest
*******************
