Important Questions

Que1: what are normal form?
Ans1: sentences written in PL& FOPL are connected into some standards forms for further processing. These forms are called as Normal forms. Further processing of sentences is done with the help of inference methods like unification or resolution which take these sentences as input but in normal forms.
Two type of normal form in PL& FOPL are :
Conjunctive normal form (CNF): given wff’s F1,F2,……….Fn, each possibly containing the disjunction of literals only, we say F1&F2….&Fn is in CNF

Disjunctive normal form(DNF): given wff F!,F2……….Fn each possibly containing the conjunction of literals only. We say F1 V F2 V………V Fn. Is in DNF.

Que2: wht is the system predicate CUT? Discus the operational behaviour and imp use of CUT.

Ans2: the system predicate CUT, also called as CUT operator allows you to tell prolog which previous choices it need not consider again when it back tracks through the choice of satisfied goals. CUT operator is already defined in prolog and is represented with the help of the symbol ‘!’ in prolog program. By using CUT, ur prog will operate faster coz it would nt waste time attempting to satisfy gaols that u can tell before hand will never contribute to a solution. Your program will occupy less of comp. memory space by using CUT because more economical use of memory can be made if backtracking points don’t have to record for later examination.
Operationl behaviour and importance use of CUT :
confirming choice of a rule: first use of CUT isin places where we want to tell prolog system that it has found a right rule for a particular goal. It means CUT says if you get this for you have picked the correct rule for this goal. This rule of CUT can be explained with help of following example:
sum(N,S) is used to store sum of first N natural numbers in S. it can be defined as:
sum(1,1):-! %rule 1

sum(N,S) :-N>1, N1 is N-1, sum (N1,S1),, s is S1+N %rule 2

here rule 1 is used for boundary condition. Here, we have used CUT! So that if value of N is 1, prolog system checks first rule & display answer 1 and if failure, second rule is checked for N=1 and it will indefinitely go for recursive calls without any boundary condition to stop recursive calls. This ! in the definition is to say that in case of N=1, we just have to check rule 1


the “CUT-fail” combination: the second use of CUT is the place where we want to tell prolog system to fail a particular goal immediately without trying for alternative solutions. Here, CUT is used conjunction with the “fail” predicate to say “if you get to here, you should stop trying to satisfy the goal.” “fail” predicate is to built-in predicate having no argument , fail is defined in such a way that as a goal it always fails and causes backtracking to take place, following examples shows the use of CUT.

Taxpayer (X) :- foreigner (X), !,fail.
Taxpayer (X) :- female(X) , income(X,I),
I<85000, !, fail.
Taxpayer (X) :- male(X),income (X, I),
I<150000, !, fail.

Here if in rule 1 , foreigner (X) predicate is true, taxpayer(X) predicate will fail and ! is used to tell that we do not need to check any other rule if this rule does not satisfy goal taxpayer.

terminate general & test sequence: this use of CUT is in the places where we want to terminate the generation of alternative solutions through backtracking. Here, CUT means if you get to here, you have found only solution to the problem and there is no point in ever looking for alternatives. In prolog program, there is a sequence of goals that can succeed in many ways and which generates many possible solutions on backtracking. After this there are goals fail, backtracking will lead to another solution being proposed. This will be tested for appropriates and so on. This process will be found (failure). We can call the goal that are yielding all the alternative the “generator” and those that check whether a solution is acceptable the”tester”. For example
program to implement integer division using addition and multiplication

divide(N1,N2, result) :-
is integer (result),
product 1 is result*N2
product 2 I (result+1) * N2
product 1 = <> N1, !

integer is used as generator to generate result of dividing N1 by N2. rest of goals are tester! is placed at the nd to say that if we ever successfully generate a result that passes the test for being result of division. We need never try any more.


Que 3: short note on normal forms

Ans 3: sentences written in first order predicate logic or propositional logic are converted into some standard form for their further processing. These standard form are called as normal forms. Sentences in FOL and propositional logic are just giving us some information or knowledge about a particular thing. In order to infer new knowledge from these sentences, we need to process these sentences by using inference methods. Almost all the inference methods take these sentences as input but in normal forms.
Following are types of normal forms used in FOL and prepositional logic:

Conjunctive normal form (CNF)

Gives wff’s F1,F2,F3……Fn each possibly consisting of disjunction of literals only, we say F1, & F2&………….Fn is in conjunctive normal form. In these words, we can say each Fi, where i= 1,2,3………n consists only of the disjunction of literals but Fi are connected together with conjunctions.

Disjunctive Normal Form (DNF)
Given wff’s F1,F2,…………Fn, each possibly consisting of the conjunction of literals only, we say F1V F2 V F3…………. V Fn is in disjunction form. In other words if each Fi, i= 1,2,3…………n consists only of the conjunction of literals, we say F1 V F2………. , Fn is in disjunctive normal form.

For example the sentences

(P(x) & Q(y) & R) V P(x) V (M (x,y) & R) is in disjunctive normal form.



Que 4: define the term recursion
Ans 4: recursion is the process a procedure goes through when one of the steps of the procedure involves rerunning the same procedure. A procedure that goes through recursion is said to be recursive.

EXPECTED QUESTIONS

Important questions from MST & Final Examination point of Vew


1.Diffefentiate between Logic & logic Programming ?
2.what is the need for quantifiers?
3.What do you mean by first order logic?
4What are Horn Clauses?
5Discuss the advantages of Prolog & differentiate between Syntax & Semantics?
6.What is Structural Induction ?
7.How do we represent Structured data in prolog?
8.Explain the concept of SLD trees?
9.What is Resolution? What role does it play in propositional logic?
10.Explain the concept of recursion in prolog?
11.Discuss the interpretation of nondeclarative features of prolog ?
12.What are normal forms. Explain in detail?
13.Discuss the logical limitation of prolog?
14. Write a program in prolog to compute Fibonacci term using recursion in prolog.
15.What is system predicate CUT?Discuss the operational behavior & important uses of CUT?
16.Explain Well formed formula in detail ?
17Discuss the concept of fail predicate in prolog with help of a example?
18Explain the non declarative features of prolog

Important questions from MST & Final Examination point of Vew


1.Diffefentiate between Logic & logic Programming ?
2.what is the need for quantifiers?
3.What do you mean by first order logic?
4What are Horn Clauses?
5Discuss the advantages of Prolog & differentiate between Syntax & Semantics?
6.What is Structural Induction ?
7.How do we represent Structured data in prolog?
8.Explain the concept of SLD trees?
9.What is Resolution? What role does it play in propositional logic?
10.Explain the concept of recursion in prolog?
11.Discuss the interpretation of nondeclarative features of prolog ?
12.What are normal forms. Explain in detail?
13.Discuss the logical limitation of prolog?
14. Write a program in prolog to compute Fibonacci term using recursion in prolog.
15.What is system predicate CUT?Discuss the operational behavior & important uses of CUT?
16.Explain Well formed formula in detail ?
17Discuss the concept of fail predicate in prolog with help of a example?
18Explain the non declarative features of prolog

SOME IMPORTANT QUESTIONS /OLD QUESTION PAPERS

Some Important questions

1.WHAT IS LOGIC PROGRAMMING ?
2.DEFINE FACT AND RULES?
3.Define the term expert system?
4.differentiate between Var & Nonvar?
5.Diferentiate between atom and atomic ?
6.explain the term built in predicate trace?
7.Differenciate between between Assert & Assertz predicate?
8.What is Structural induction?
9. What is the purpose of arg predicate?
10.Define translation from natural language to sumbolic language ?
11.Define heuristics?Give one example?
12.what is WFFS ?
13Differentiate between Syntax and symantics?
14 Explain linear resolution?
15.what is skolemization ?
16.what is inferencing?
17.What are representations & mappings?
18./Differnciate between forward reasoning and bacward reasoning?
19. what is mapping?
20. name the various AI languages?
21.Explain CNF & DNF?
22.write short notes on
a)bottom up parsing
b)modus ponens
c)unification
23 explain the concept of backtracking?
24.What is Conflict Resolution?
25.Explain Breadth first search?
26.define predictive retract?
27.what is resolution principle ?
28Explain the chain rule ?
29. what are the various quantifiers ?explain
30 define functor?
31 Differentiate between procedural knowledge and declatrative language?
32.explain the predicates which are used in making the things equal?
33what is SPY used for?
34what is difference between get & get0 ?
35.Explain in detail the concepts of Horn clauses ?
36

ABOUT HORN CLAUSE

Definition: A Horn clause is a clause with at most one positive literal.
Any Horn clause therefore belongs to one of four categories:
A rule: 1 positive literal, at least 1 negative literal. A rule has the form "~P1 V ~P2 V ... V ~Pk V Q". This is logically equivalent to "[P1^P2^ ... ^Pk] => Q"; thus, an if-then implication with any number of conditions but one conclusion. Examples: "~man(X) V mortal(X)" (All men are mortal); "~parent(X,Y) V ~ancestor(Y,Z) V ancestor(X,Z)" (If X is a parent of Y and Y is an ancestor of Z then X is an ancestor of Z.)
A fact or unit: 1 positive literal, 0 negative literals. Examples: "man(socrates)", "parent(elizabeth,charles)", "ancestor(X,X)" (Everyone is an ancestor of themselves (in the trivial sense).)
A negated goal : 0 positive literals, at least 1 negative literal. In virtually all implementations of Horn clause logic, the negated goal is the negation of the statement to be proved; the knowledge base consists entirely of facts and goals. The statement to be proven, therefore, called the goal, is therefore a single unit or the conjuction of units; an existentially quantified variable in the goal turns into a free variable in the negated goal. E.g. If the goal to be proven is "exists (X) male(X) ^ ancestor(elizabeth,X)" (show that there exists a male descendent of Elizabeth) the negated goal will be "~male(X) V ~ancestor(elizabeth,X)".
The null clause: 0 positive and 0 negative literals. Appears only as the end of a resolution proof

OR
A Horn clause is a clause with at most one expression on the left of the arrow. The expression on the left of the arrow (if there is one) is called the head of the clause. The expression(s) to the right of the arrow (if there are any) make up the body of the clause. The four possible types of Horn clause are conventionally named as follows.
1.Facts
Clauses of the form A¬ . (Facts have a head but no body.)
2.Rules
Clauses of the form A¬ B1,...,Bn. (Rules have both a head and a body.)
3Goals
Clauses of the form ¬ B1,...,Bn . (Goals have a body, but no head.)
4.Empty Clause
The clause \Box, with no head and no body.

converting FOL to Clause Form

Converting FOL Sentences to Clause Form
Every FOL sentence can be converted to a logically equivalent sentence that is in a "normal form" called clause form
Steps to convert a sentence to clause form:
1.Eliminate all <=> connectives by replacing each instance of the form (P <=> Q) by the equivalent expression ((P => Q) ^ (Q => P))
2Eliminate all => connectives by replacing each instance of the form (P => Q) by (~P v Q)
3Reduce the scope of each negation symbol to a single predicate by applying equivalences such as converting ~~P to P; ~(P v Q) to ~P ^ ~Q; ~(P ^ Q) to ~P v ~Q; ~(Ax)P to (Ex)~P, and ~(Ex)P to (Ax)~P
4.Standardize variables: rename all variables so that each quantifier has its own unique variable name. For example, convert (Ax)P(x) to (Ay)P(y) if there is another place where variable x is already used.
5Eliminate existential quantification by introducing Skolem functions. For example, convert (Ex)P(x) to P(c) where c is a brand new constant symbol that is not used in any other sentence. c is called a Skolem constant. More generally, if the existential quantifier is within the scope of a universal quantified variable, then introduce a Skolem function that depend on the universally quantified variable. For example, (Ax)(Ey)P(x,y) is converted to (Ax)P(x, f(x)). f is called a Skolem function, and must be a brand new function name that does not occur in any other sentence in the entire KB.
Example: (Ax)(Ey)loves(x,y) is converted to (Ax)loves(x,f(x)) where in this case f(x) specifies the person that x loves. (If we knew that everyone loved their mother, then f could stand for the mother-of function.
Remove universal quantification symbols by first moving them all to the left end and making the scope of each the entire sentence, and then just dropping the "prefix" part. For example, convert (Ax)P(x) to P(x).
Distribute "and" over "or" to get a conjunction of disjunctions called conjunctive normal form. Convert (P ^ Q) v R to (P v R) ^ (Q v R), and convert (P v Q) v R to (P v Q v R).
Split each conjunct into a separate clause, which is just a disjunction ("or") of negated and un-negated predicates, called literals.
Standardize variables apart again so that each clause contains variable names that do not occur in any other clause.
Example
Convert the sentence (Ax)(P(x) => ((Ay)(P(y) => P(f(x,y))) ^ ~(Ay)(Q(x,y) => P(y))))
Eliminate <=>Nothing to do here.
Eliminate =>(Ax)(~P(x) v ((Ay)(~P(y) v P(f(x,y))) ^ ~(Ay)(~Q(x,y) v P(y))))
Reduce scope of negation(Ax)(~P(x) v ((Ay)(~P(y) v P(f(x,y))) ^ (Ey)(Q(x,y) ^ ~P(y))))
Standardize variables(Ax)(~P(x) v ((Ay)(~P(y) v P(f(x,y))) ^ (Ez)(Q(x,z) ^ ~P(z))))
Eliminate existential quantification(Ax)(~P(x) v ((Ay)(~P(y) v P(f(x,y))) ^ (Q(x,g(x)) ^ ~P(g(x)))))
Drop universal quantification symbols(~P(x) v ((~P(y) v P(f(x,y))) ^ (Q(x,g(x)) ^ ~P(g(x)))))
Convert to conjunction of disjunctions(~P(x) v ~P(y) v P(f(x,y))) ^ (~P(x) v Q(x,g(x))) ^ (~P(x) v ~P(g(x)))
Create separate clauses
~P(x) v ~P(y) v P(f(x,y))
~P(x) v Q(x,g(x))
~P(x) v ~P(g(x))
Standardize variables
~P(x) v ~P(y) v P(f(x,y))
~P(z) v Q(z,g(z))
~P(w) v ~P(g(w))

FIGURE NEURAL NETWEORK

http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol4/cs11/report.html

VISIT THIS WEB PORATL FOR ALL DETAILED INFORMATION ON NEURAL NETWORK AND THE FIGURES PRETAINING TO NEURAL NETWORK DESIGN