Name: Sung Il Choi

Course: CIS 203

Subject: Project Paper

Instructor: Dr Wang

                                                Active Logic

 

            In AI. many researchers tries to make a system which is flexible enough able to take in a lot of different kinds of incoming information  such as contradiction, nonsense, change of topic, ambiguity, and so on.  To make such system, we need a system that includes detailed information about its own history. A system with its own history can be more flexible under varied conditions.  Active Logic provides good system for IA. Program.

 

What is Active logic?

 

Active logic is a family of inference engines, that use a history of their own reasoning as they run. Thus at any time T, an active logic has a record of its reasoning at all times prior to T, and it also knows that the current time is T. As it continues to reason from time T, that reasoning is also recorded in the history, marked at time T+1 as having occurred at time T. Thus an active logic records the passage of time in discrete steps, and the "current" time slides forward as the system runs. It is convenient to regard its current inferences as occurring in a working memory, then is transferred to the history (or long-term memory) in the next time-step.

Example of Active Logic

There is simple examples:

Basic rule:

t:               now(t)

-------------------

t(t + 1)     now(t + 1)

                        -

                        -

                        -

t(t + n)       now(t + n)

Now has the value t, the next step, value of t is increased by 1(t +1) and so on. This feature give the Active Logic to keep track of step numbers and time.

The contradiction rule:

t:                      p, not(p)

            -----------------------

t +1               not(p, not(p))

The database has p and not(p), at next step, add not(p, not(p)) to the database. There will be other rules that will cause the consequences of p and not(p) from the first step. The rule will try to resolve the not(p, not(p)) and reinstate either p or not(p) to the database at later time.

Modus ponens:

t:                      p, p -> q

            ---------------------

t+1                        q

The database has p and p->q , at next step, conclude q.

Application of Active logic

Active logic can be a framework for many application dealing with presence of uncertainties. Some of application are:

·                    Deadline -coupled Planning

The time is tracking and observation mechanisms of active logic give it useful in  such applications that deal with uncertainties while trying to meet a deadline.

·                    Common Sense Reasoning

·                    Simple Default Reasoning

·                    Default Reasoning  with Preferences

·                    Reasoning with contradictions

·                    Dialog

·                    Assumption

·                    Repair

·                    Change in meaning

Future Application of Active logic

Time Sensitive Automated Theorem Prover

A computer runs a given program for hundreds of years in a search for a proof because a computer doesn't have aware of the time. A human mathematician might, after months of pursuing a particular problem, try a different tracks. For this kind of application, Active logic has great advantage. Its built-in time sensitivity provides a good mechanism to become more like a human mathematician.

Active Logic Operation System

There will be several advantages incorporating Active Logic. Operation system with Active logic is able to repair itself because it keeps his old histories in long term memory. OS use old histories to compare with current situation, then makes correction of the problem. Another advantage is OS can update itself for its need.   

  Current Implementation of Active Logic

 There is research group called “Active Logic Research Group” in the Computer Science Department at the University of Maryland at College Park.  This research group is working currently in implementation of Active Logic called Alma/Carne. Alma applies the rule of inference to the formulas in the database at that step to produce a set of new formulas. These are added to the database, and the process repeats at each subsequent step. Carne is a process that communicates with Alma but runs independently. The main use of Carne is to run non-logical computations asynchronous from Alma steps. One of its roles is serve as an input-output interface to Alma.

My contribution to this research

 

I think Active Logic needs future step or future time to make more efficient and reliable. Now (t) is the current time or step and, at same time, create two future steps. These future step will be Now(tp) and Now(tn). Now(tp) are the positive result or conclusion and Now(tn) is the negative or contradiction result. For next step,  Active logic use future positive and negative to obtain next conclusion with current step or time. 

 

Conclusion

I think that Active Logic has theoretical value. A system with Active Logic can have information about its own past, it then might be able to analyze what it has been doing, recognize trouble, and make decisions as to whether it needs to alter any of its past behavior.  Active Logic also can provide mechanism to deal with various forms of uncertainties. It provides a framework for several application programs.

Active Logic has great future in AI. With Active Logic we can pursue a system that can work in misidentifications, contradiction, conflicting advice, context shifts, new words, new meanings for old words, belief revision, tight deadlines, and ambiguities. Maybe in future, we can have operation system with Active logic that can repair and update itself.