Integration of Forward and Backward Inferences Using Extended Rete Networks

Whole task training, forward chaining, and backward chaining techniques were compared in teaching two different 120-step sequences of behavior to college students. In Exp. 1 participants learned a sequence that began with easy movements, progressed through more difficult movements, and ended with easy movements. Whole task training resulted in more errors than either forward or backward chaining. Differences were found in the location of errors. Both whole task training and forward chaining resulted in fewer errors at the beginning of the sequence and backward chaining resulted in fewer errors at the end of the sequence. Because the results of Exp. 1 may have been affected by the increased difficulty of the middle of the sequence, Exp. 2 was undertaken using a sequence of behavior where all segments were of equal difficulty. Whole task training and forward chaining resulted in fewer errors than backward chaining. The location of errors was similar to that found in Exp. 1.

The popularity of Olympic-style weightlifting in fitness routines is growing, but participating in these exercises with improper technique places lifters at increased risk for injury. Fitness training professionals have developed multiple teaching strategies, but have not subjected these strategies to systematic evaluation, particularly with novice lifters. Two strategies recommended by professional training organizations are akin to forward and backward chaining, which have been shown effective at teaching other novel, complex behaviors. The present study compared these forward- and backward-chaining-like strategies to teach novice lifters "the clean" and "the snatch," two Olympic weightlifting movements frequently incorporated into high-intensity training programs. Participants performed lifts taught with forward chaining more accurately than lifts taught with backward chaining.

Three studies are presented comparing forward and backward chaining techniques. In the Experiment 1, an 8-step Lego® play construct was taught. In one condition, a construct was taught using forward chaining techniques and in the other condition a construct was taught using backward chaining techniques in an alternating treatments design. In the Experiment 2, a 12-step Lego® construct was taught using the same procedures outlined above. Finally, in Experiment 3, a pre-vocational task, building chess pieces, was taught. Efficiency of both chaining procedures was measured by number of trials to acquisition and number of error rates across conditions and participants. Results show that both chaining procedures were equally effective, all participants acquired the behavior chains with both chaining procedures and there was little difference in acquisition time and error rate between the two procedures.

Agent systems are designed to work in complex dynamic environments, which requires an agent to repeatedly deliberate over its choice of actions. A common way to achieve this is to use agent architectures based on the Belief-Desire-Intention (BDI) model, in which an agent continuously deliberates over the best way to achieve its goals in the current environment. In this paper we explore how a BDI approach can be implemented in Lygon, a logic programming language based on linear logic. In particular, we show how backward and forward chaining techniques can be used to provide proactive and reactive agent behaviours. We discuss some extensions to Lygon which allow us to use abduction techniques to generate plans to achieve a given goal, as well as an addition to the syntax of Lygon which greatly simplifies the specification of a sequence of goals to be achieved. We also show how a simple addition to the backward chaining process allows us to specify proactive checking of maintenance goals.

Price, consumption, and production influence global food estimation. Food consumption and food production needs improving affordability, government policy and expert proposition in decision making. Expert have developed a scenario combining direct weather impact on key grain producing regions, indirect impact through crop pathogens, consequences for markets, and stock of global food. Global food production tended to increase, meanwhile consumption under production. In Indonesia, production is under consumption. It is anomaly by global situation and world condition. Government policy is tariff, export, and import. Export food influenced by price food commodity is not stable, meanwhile food import tended to increase because by national food consumption increasing demand. Government policy and expert proposition to modern society, need Expert System is increasing rapidly. In Artificial Intelligence, Expert System is a computer system that emulates the decision making ability of a human expert. There are two reasoning strategies in Expert System: Forward Chaining and Backward Chaining. The aim of this paper is to identify which reasoning strategy system (Forward Chaining). This paper focus on the concept of knowledge representation in Artificial Intelligence and implementing of Forward Chaining on Food Affordability. Food Affordability used to planning of food in the future. Finally, Inference using Forward Chaining on Food Affordability, the result it is good and can be used to planning and policy on national food.

A doctor or medical scholar needs a reference book to learn how to diagnose tropical diseases. This reference book is sometimes a hassle if you have to carry it everywhere. This reference book is also impractical if you have to search it first to find the symptoms and diseases you want to study. So that we need a system to make it easier for doctors and medical scholars to study the science of diagnosis and look for symptoms and diseases. Expert systems are knowledge-based programs that provide expert quality solutions to problems in a specific domain. This expert system is used in the fields of medicine, agriculture, business, and others. Expert systems in the field of medicine make it easy to identify diseases suffered by patients through the symptoms present in the patient. This expert system helps doctors make diagnoses to convince doctors about the results of the diagnosis. The expert system in this study uses a combined method. The combined method is forward chaining and backward chaining. The forward chaining method is used to determine specific symptoms that appear, while the backward chaining method is used to trace general symptoms that arise from specific symptoms that have been previously selected. The result of combining these methods provides a diagnostic percentage of 100%. Meanwhile, the user's assessment of the system gives a good response.

The Web-based intelligent decision support system(Web-IDSS) is pivotal for a Virtual Team (VT) to successfully execute business-related tasks. The current generation of Web-IDSS built on top of semantic web technologies for VTs lacks the capability to provide decision support when underlying information is incomplete and/or contradictory. In this article, we address this limitation of current Web-IDSS through defeasible logic based argumentation formalism. The proposed Web-IDSS uses a hybrid reasoning approach: forward chaining(data-driven) for the construction of arguments over incomplete information, and backward chaining (goal-driven) for conflict identification and resolution with explanation. The proposed Web-IDSS adheres to web standards and publishes the outcome of argumentative reasoning in Argument Interchange Format (AIF).

An experiment was performed to investigate the relationship between two-dimensional (2-D) or three-dimensional (3-D) graphs displayed on paper or computer and the problem-solving performance of experienced and novice managers. The effects of these variables on solution times, confidence in answers and effectiveness of solutions for a production management case were examined. It was predicted that experienced managers would engage in forward chaining as a problem-solving strategy, while novices would use backward chaining as a problem-solving technique (Larkin et al. 1980). Results indicated that solution times were faster for computer than for paper presentations of data, but no significant relationship between response times and dimensionality of graphs was found. Novice subjects produced more accurate answers using 2-D paper presentations of graphs, while experienced managers produced more accurate answers when provided with 3-D graphs on computer. Further, experienced and novice managers were ...

We address the problem of efficient generation of structured argumentation systems. We consider a simplified variant of an ASPIC argumentation system and provide a backward chaining mechanism for the generation of structured argumentation graphs. We empirically compare the efficiency of this new approach with existing approaches (based on forward chaining) and characterise the benefits of using backward chaining for argumentation-based query answering.

This paper introduces first an expert system shell based on stratified forward chaining. The stratified forward chaining was proposed as a generalization for the inheritance networks with exception since it allows more than one antecedent in the premises part of a rule. Expert systems built with this tool are rule based and the user interface is web based. The practical use of this chaining is presented here through the three chaining methods: forward chaining, backward chaining and mixed chaining. Our current aim is to make use of these inference mechanisms to help the user in his interaction with administration to identify in an efficient way the relevant information he needs. This is done through a question-response dialog to determine the user profile. The paper considers also in a second part a special kind of inference called deontic inference. The rationale behind this kind of inference is the possible presence of deontic rules which may impose a change in the base of current facts to make it comply with the obligations they prescribe.

This paper describes a process-planning model using mixed-type reasoning designed for processing prismatic parts on CNC machine tools in a batch manufacturing environment. This mixed-type reasoning handles feature interactions by combining forward chaining for feature sequencing and backward chaining for the construction of a process plan. In such a model, the human problem-solving strategies are decoupled from the tools for analysis and sorting algorithms. Two databases are used to contain the results from forward and backward chaining. The process-planning algorithm combines the processes of modeling the given information in four stages: (1) defining the important information for features and feature-related concerns; (2) interpreting and rearranging the given feature according to the given constraints and sorting guideline; (3) sequencing the features; (4) attaching the needed operations to the features in machine/process/feature/set-up/tool/time/cost format.

MARVEL is a kernel for software development environments that enacts a processing modeling notation, called the MARVEL Strategy Language (MSL). The software process is defined in MSL as a collection of modular strategies, where different (sets of these) strategies are appropriate for different tool suites, user roles, phases of the lifecycle, management policies, etc. Each strategy specifies a partial object-oriented data model and a partial rule-based process model. The strategies are supplemented by a collection of envelopes, each of which describes how to apply one or more of the external tools used during software development activities; this includes the mapping from the inputs/outputs of these tools and the MARVEL objectbase and the command lines to invoke these tools. Multiple MSL strategies are merged to obtain the full data and process models for enaction by the MARVEL kernel.Each software development activity is described in MSL by a rule specifying the precondition and multiple postconditions of the activity. Both preconditions and postconditions are written in a subset of the first order predicate logic, stylized to incorporate directives for efficient queries and updates. A precondition is a logical statement that must be true before the activity is initiated; a postcondition is a logical statement asserted to be true when the activity completes. Multiple mutually exclusive postconditions reflect the multiple possible results of many activities. An activity is typically a particular combination of software development tool, options specific to that tool, and typed arguments. The notion of activity could be extended to include loading a new set of strategies to take over at this point in the process, to support both nesting of hierarchical activities and successive activity phases.Enaction of an MSL process model is implemented by what we call opportunistic processing, consisting primarily of forward and backward chaining among the rules. When a user initiates an activity, MARVEL applies backward chaining to attempt to satisfy its precondition. If this is not possible, MARVEL could use the rules in the style of an expert system to explain the problem. Once an activity has completed, MARVEL asserts one of its postconditions and uses forward chaining to automatically carry out other activities whose results are presumed to be needed in the near future.We have designed two facilities for controlling this processing, to prevent runaway automation. Hints are additional MSL preconditions that affect automatic but not user-initiated invocation of tools. Implicit queries represent a reflective capacity to keep tabs on estimated costs of automatic behavior and request user confirmation when certain user-selected thresholds are reached.MARVEL version 2.10 was recently completed, an upgrade over the version 2.01 that was demonstrated at the 3rd PSDE conference in November 1988. This latest version of MARVEL adds an X11 windows graphical user interface and new subsystems called Marvelizer and Organ. Marvelizer is a tool for immigrating existing software systems from the Unix file system or (a restricted class of) existing software development environment into a MARVEL objectbase. Organ is a set of commands for reorganizing MARVEL objectbases as the project and/or system structure evolves. Marvelizer has been used to immigrate Marvel itself, including about 35,000 lines of C code, into a C/Marvel objectbase. We would like to use the C/Marvel set of MSL strategies, which support activities using the user's favorite editor, lint, cc, ar, ranlib, less (and soon rcs, dbx and mail), for our own further development of MARVEL. Both MARVEL and C/Marvel were in use during the Spring 1989 semester by students in my E6123y Programming Environments and Software Tools course (admittedly a captive audience).We have discovered several difficulties with the MARVEL paradigm that seem likely to apply at least partially to enaction of other notations for software process modeling. First, constructing and debugging a process model is hard. We have run into many unanticipated interactions among rules, particularly among those defined in different strategies that happen to be loaded into the MARVEL kernel at the same time. We are working on debugging facilities that will uncover all direct and transitive dependencies by constructing a graphical dataflow graph of the currently loaded rules. It is feasible for a user to enable and disable individual rules, both during debugging to see how that affects the dataflow among rules and also during operation because certain behavior is not currently desired. This would be dangerous, however, if done by a naive user: if rules were turned off and on at arbitrary points, it would be possible for MARVEL to get into what is an inconsistent state with respect to the full set of rules in such a way that automatic recovery is impossible.Similar difficulties seem likely to arise for any enactable process modeling paradigm. The following questions need to be answered: How does an implementor go about writing, testing and debugging a process model? For non-trivial processes, the model is likely to be very large and hence should be modularized. What is the appropriate style of interface among process model modules and how is it enforced? Is the process model visible to the users and, if so, how is it presented? If the users can modify the process model during enaction, how does this affect continuing the process? Should (can) consistency be enforced or should (can) inconsistencies be detected and repaired?Second, constructing envelopes is even harder. We currently use the Shell languages (e.g., CShell) as notations for defining envelopes. Writing the Shell scripts requires an intimate knowledge of both the tool and the mapping of the MARVEL objectbase onto the file system. Although there is no way to avoid the former, we hope to minimize the latter by developing a higher level envelope language that understands the MARVEL objectbase implementation so the envelope writer doesn't have to. However, this is currently a relatively low priority due to lack of manpower.Again, similar difficulties seem inevitable for other enaction mechanisms intended to work with external tools. The questions: Is it possible (or desirable) to support existing tools, particularly tools where retrofitting is impractical? If only new tools are supported, can a relatively simple standard interface be developed and published so these tools can be developed separately by vendors? Would such an interface pre-empt too many design decisions, or would it be feasible for vendors to upgrade their current products?Third, supporting multiple users is hardest of all. The current MARVEL kernel does not provide any facilities for concurrency control. It would be easy to add locking of the entire objectbase, but a more flexible transaction model is needed. We are working on a number of alternative models that we think are promising for incorporation into the MARVEL kernel. Commit-serializability introduces two new transaction operations, split-transaction and join-transaction, that manipulate in-progress transactions to support coordination among multiple users. Participant transactions (AKA participation domains) distinguishes participants in group software development tasks from observers, and relaxes serializability as viewed by participants to permit cooperation.It is essential for enactable process models to support coordination and cooperation among the members of software development teams. There are two sets of questions: First, what are appropriate processes for programming-in-the-many? This is itself an active area of research, and there is certainly no consensus. One opinion, voiced at the previous workshop, is that the community should not be enacting process models until we understand the processes we are modeling. An opposing opinion is that enaction gives the community the capability to experiment with different processes without prematurely making a full scale commitment to a particular process. Assuming agreement with the second view, what process modeling notations and enaction mechanisms can support a reasonable range of cooperative work facilities?The database and operating system communities have agreed on atomic and serializable transactions, which can be implemented using a wide variety of technologies, as the basis for data consistency, failure recovery and concurrency control across their traditional application areas. Can the software engineering community develop an equally all-encompassing “transaction” model? Or is there some characteristic of the software development process such that coordination and cooperation policies will always require special support on a case-by-case basis? If so, what does this say about enaction of process models in general?In summary, MARVEL is implemented and in limited use, it works in some cases, it doesn't work in others, it raises a lot of questions, and both we the MARVEL group and we the software engineering community have a lot more work to do.

On rules with existential variables: Walking the decidability line

Legal Inferencing with Computers: An Inference Engine

Datalog-based systems often materialise all consequences of a datalog program and the data, allowing users' queries to be evaluated directly in the materialisation. This process, however, can be computationally intensive, so most systems update the materialisation incrementally when input data changes. We argue that existing solutions, such as the well-known Delete/Rederive (DRed) algorithm, can be inefficient in cases when facts have many alternate derivations. As a possible remedy, we propose a novel Backward/Forward (B/F) algorithm that tries to reduce the amount of work by a combination of backward and forward chaining. In our evaluation, the B/F algorithm was several orders of magnitude more efficient than the DRed algorithm on some inputs, and it was never significantly less efficient.