ARTIFICIAL INTELLIGENCE

By
Dr B Nandini,
Associate Professor, Dept of CSE, Telangana
University
• There are three kinds of Intelligence:
– One kind understand things for itself,
– The other appreciates what others can understand,
– The third understands neither for itself nor through
others.
• The first kind is excellent, the second good, and
the third kind useless.
Niccolo Machiavelli (1469-1527)
----

Italian diplomat, political philosopher,

musician, poet and playwright
 What is AI?
• There is no single definition that universally captures the
essence of AI.
• Artificial intelligence (AI) can be understood in two ways:
– As a field of study: AI is a branch of computer science
concerned with the development of intelligent machines that
can perform tasks typically requiring human intelligence, such
as learning, reasoning, problem-solving, and decision-making.
– As the intelligence exhibited by machines: AI refers to the
capability of machines to mimic cognitive functions that
humans associate with other human minds, such as
understanding language, learning from experience, and
adapting to new situations.
 Introduction:
• Artificial Intelligence is concerned with the design of intelligence in an
artificial device. The term was coined by John McCarthy in 1956.
• Intelligence is the ability to acquire, understand and apply the knowledge to
achieve goals in the world.
• AI is the study of the mental faculties through the use of computational
models.
• AI is the study of intellectual/mental processes as computational processes.
• AI program will demonstrate a high level of intelligence to a degree that
equals or exceeds the intelligence required of a human in performing some
task.
• AI is unique, sharing borders with Mathematics, Computer Science,
Philosophy, Psychology, Biology, Cognitive Science and many others.
• Although there is no clear definition of AI or even Intelligence, it can be
described as an attempt to build machines that like humans can think and
act, able to learn and use knowledge to solve problems on their own.
 Definitions..
• AI is the study of how to make computers do things
which, at the moment, people do better.
• According to the father of Artificial Intelligence, John
McCarthy, it is “The science and engineering of
making intelligent machines, especially intelligent
computer programs”.
• It is the theory and development of computer
systems capable of performing tasks that historically
required human intelligence, such as recognizing
speech, making decisions, and identifying patterns.
• Artificial Intelligence is a way of making a
computer, a computer-controlled robot, or a
software think intelligently, in the similar
manner the intelligent humans think.
• Artificial intelligence (AI) is a branch of
computer science that deals with the creation
of intelligent agents, which are systems that
can reason, learn, and act autonomously.
• From a business perspective AI is a set of very
powerful tools, and methodologies for using
those tools to solve business problems.
• From a programming perspective, AI includes
the study of symbolic programming, problem
solving, and search.
 AI Vocabulary
• Intelligence relates to tasks involving higher mental processes,
e.g. creativity, solving problems, pattern recognition,
classification, learning, induction, deduction, building
analogies, optimization, language processing, knowledge and
many more. Intelligence is the computational part of the
ability to achieve goals.
• Intelligent behaviour is depicted by perceiving one’s
environment, acting in complex environments, learning and
understanding from experience, reasoning to solve problems
and discover hidden knowledge, applying knowledge
successfully in new situations, thinking abstractly, using
analogies, communicating with others and more.
• Science based goals of AI pertain to
developing concepts, mechanisms and
understanding biological intelligent behaviour.
The emphasis is on understanding intelligent
behaviour.
• Engineering based goals of AI relate to
developing concepts, theory and practice of
building intelligent machines. The emphasis is
on system building.
• AI Techniques depict how we represent, manipulate and
reason with knowledge in order to solve problems. Knowledge
is a collection of ‘facts’. To manipulate these facts by a
program, a suitable representation is required. A good
representation facilitates problem solving.
• Learning means that programs learn from what facts or
behaviour can represent. Learning denotes changes in the
systems that are adaptive in other words, it enables the system
to do the same task(s) more efficiently next time.
• Applications of AI refers to problem solving, search and control
strategies, speech recognition, natural language
understanding, computer vision, expert systems, etc.
 The History of Artificial Intelligence

• Early days (1943-1956)

• Early enthusiasm (1952-1969)
• A dose of reality (1966-1973)
• Expert systems (1969-1986)
• The return of neural networks (1986-present)
• Probabilistic reasoning and machine learning
(1987-present)
• Big data (2001-present)
• Deep learning (2011-present)
• In 1931, Goedel layed the foundation of
Theoretical Computer Science1920-30s: He
published the first universal formal language
and showed that math itself is either flawed or
allows for unprovable but true statements.
• In 1936, Turing reformulated Goedel’s result
and church’s extension thereof.
• In 1956, John McCarthy coined the term
"Artificial Intelligence" as the topic of the
Dartmouth Conference, the first conference
devoted to the subject.
• In 1957, The General Problem Solver (GPS)
demonstrated by Newell, Shaw & Simon.
• In 1958, John McCarthy (MIT) invented the
Lisp language.
• In 1959, Arthur Samuel (IBM) wrote the first
game-playing program, for checkers, to
achieve sufficient skill to challenge a world
champion.
• In 1963, Ivan Sutherland's MIT dissertation on
Sketchpad introduced the idea of interactive
graphics into computing.
• In 1966, Ross Quillian (PhD dissertation,
Carnegie Inst. of Technology; now CMU)
demonstrated semantic nets.
• In 1967, Dendral program (Edward
Feigenbaum, Joshua Lederberg, Bruce
Buchanan, Georgia Sutherland at Stanford)
demonstrated to interpret mass spectra on
organic chemical compounds. First successful
knowledge-based program for scientific
reasoning.
• In 1967, Doug Engelbart invented the mouse
at SRI.
• In 1968, Marvin Minsky & Seymour Papert publish
Perceptrons, demonstrating limits of simple neural
nets.
• In 1972, Prolog developed by Alain Colmerauer.
• In Mid 80’s, Neural Networks become widely used with
the Backpropagation algorithm (first described by
Werbos in 1974).
• 1990, Major advances in all areas of AI, with significant
demonstrations in machine learning, intelligent
tutoring, case-based reasoning, multi-agent planning,
scheduling, uncertain reasoning, data mining, natural
language understanding and translation, vision, virtual
reality, games, and other topics.
• In 1997, Deep Blue beats the World Chess
Champion Kasparov.
• In 2002, iRobot, founded by researchers at the
MIT Artificial Intelligence Lab, introduced
Roomba, a vacuum cleaning robot. By 2006,
two million had been sold.
 Problems of AI:
• Early works focused on formal tasks, like game
playing and theorem proving.
• Samuel wrote a checkers-playing- not only used play
games with opponents but also used its experience
at those games to improve its later performance.
• Chess also received a good deal of attention.
• The Logic Theorist was an early attempt to prove
mathematical theorems.
– Proved many theorems from first chapter of whitehead
and Russell’s Principia Mathematica.
• Gelernter’s theorem prover explored another
area of Mathematics: Geometry.
• Then extended to commonsense reasoning.
Includes-
– Reasoning about physical objects and their
relationships to each other.
– Reasoning about actions and their consequences.
– To investigate this sort of reasoning Novel, shaw,
and Simon built the GPS (General Problem Solver).
• (all these are simple tasks which uses small
amounts of knowledge)
• Later AI research progressed and techniques for
handling large amounts of world knowledge was
developed. These include –
– Perception (vision and speech)
– Natural language understanding, and
– Problem Solving in a specialized domains (medical
diagnosis, chemical analysis etc..)
• Then improvements happened in Natural Language
Processing (NLP)
• Not only to understand vocabulary and grammar but also important
to deal about unstated assumptions can be recognized.
• Later on moved to Engineering design, Scientific
discovery, medical diagnosis, and financial planning.
• Expert Systems came into existence and continuing..
 Task Domains of AI
• AI has applications in all fields of human study,
such as finance and economics, environmental
engineering, chemistry, computer science, and so
on. Some of the applications of AI are listed below:
• Perception
– Machine vision
– Speech understanding
– Touch ( tactile or haptic) sensation
• Robotics
• Natural Language Processing
– Natural Language Understanding
– Speech Understanding
– Language Generation
– Machine Translation
• Planning
• Expert Systems
• Machine Learning
• Theorem Proving
• Symbolic Mathematics
• Game Playing
• Etc.
• The following questions are to be considered
before we embarking on study of specific AI
problems and solution techniques:
– What are the underlying assumptions about
intelligence?
– What kinds of techniques will be useful for solving AI
problems?
– At what level human intelligence can be modelled?
– When will it be realized when an intelligent program
has been built?
 The Underlying Assumption
The field of artificial intelligence (AI) is built upon several underlying assumptions that
guide its research, development, and application. These assumptions are fundamental
to the way AI systems are designed, trained, and deployed. Some of the key underlying
assumptions of AI include:
• Computational Representation of Knowledge: AI assumes that knowledge can be
represented in a computationally tractable form, such as symbols, rules, or
statistical models. This allows AI systems to manipulate and reason with knowledge
to solve problems.
• Learning from Data: AI assumes that learning from data is a powerful approach for
creating intelligent systems. Machine learning algorithms, for example, learn
patterns and make predictions based on training data, allowing AI systems to
improve their performance over time.
• Generalization: AI assumes that patterns and knowledge learned from specific
examples can be generalized to new, unseen examples. This enables AI systems to
make accurate predictions or decisions in novel situations based on their training
data.
• Autonomy: AI assumes that intelligent systems can operate autonomously, making
decisions and taking actions without constant human intervention. This is
particularly relevant in areas such as robotics and autonomous vehicles.
• Rationality: AI assumes that intelligent agents act rationally to achieve
their goals, given their knowledge and beliefs about the world. Rationality
does not necessarily imply perfect decision-making but rather making
decisions that maximize expected utility based on available information.
• Emulation of Human Intelligence: While not a strict requirement, many
AI systems are designed to emulate human intelligence to some extent.
This includes tasks such as natural language processing, computer vision,
and decision-making, which are inspired by human cognitive abilities.
• Scalability: AI assumes that intelligent systems can scale to handle
increasingly complex tasks and large volumes of data. This scalability is
essential for applications such as search engines, recommendation
systems, and data analytics.
• Ethical and Social Considerations: With the increasing deployment of AI
systems in society, there is an assumption that ethical and social
considerations must be addressed to ensure responsible and beneficial
use of AI. This includes issues such as bias, fairness, transparency, and
accountability.
• These assumptions form the foundation of AI research and development,
shaping the design, implementation, and evaluation of AI systems across
various domains and applications.
 AI Technique:
• Artificial Intelligence research during the last three
decades has concluded that Intelligence requires
knowledge. To compensate overwhelming quality,
knowledge possesses less desirable properties
including:
A. It is huge.
B. It is difficult to characterize correctly.
C. It is constantly varying.
D. It differs from data by being organized in a way
that corresponds to its application.
E. It is complicated.
An AI technique is a method that exploits
knowledge that is represented so that:
• The knowledge captures generalizations that
share properties, are grouped together, rather
than being allowed separate representation.
• It can be understood by people who must
provide it—even though for many programs
bulk of the data comes automatically from
readings.
• In many AI domains, how the people
understand the same people must supply the
knowledge to a program.
• It can be easily modified to correct errors and
reflect changes in real conditions.
• It can be widely used even if it is incomplete
or inaccurate.
• It can be used to help overcome its own sheer
bulk by helping to narrow the range of
possibilities that must be usually considered.
AI Problems and series of approaches:
• In order to characterize an AI technique let us
consider initially OXO or tic-tac-toe and use a
series of different approaches to play the
game.
• The programs increase in complexity, their use
of generalizations, the clarity of their
knowledge and the extensibility of their
approach.
• In this way they move towards being
representations of AI techniques.
 Example-1:Tic-Tac-Toe
The first approach (simple) : The Tic-Tac-Toe
game consists of a nine element vector called
BOARD; it represents the numbers 1 to 9 in
three rows.
• An element contains the value
0 for blank, 1 for X and 2 for O.
• A MOVETABLE vector consists of
19,683 elements (39 ) and is needed where each
element is a nine element vector.
• The contents of the vector are especially chosen to
help the algorithm.
• The algorithm makes moves by pursuing the
following:
1. View the vector as a ternary number. Convert it to a
decimal number.
2. Use the decimal number as an index in MOVETABLE
and access the vector.
3. Set BOARD to this vector indicating how the board
looks after the move.
This approach is capable in time but it has several
disadvantages. It takes more space and requires stunning
effort to calculate the decimal numbers. This method is
specific to this game and cannot be completed.
• For example, let's say we have the following Tic Tac Toe
board represented as a vector:
– board = [0, 1, 0, 2, 1, 0, 0, 2, 1]
• To view this vector board as a ternary number, we
concatenate the elements of the vector from left to
right. So the ternary representation would be:
– board_ternary = 010210021
• Now, to convert this ternary number to a decimal
number:
– board_decimal = (0 * 3^8) + (1 * 3^7) + (0 * 3^6) + (2 * 3^5)
+ (1 * 3^4) + (0 * 3^3) + (0 * 3^2) + (2 * 3^1) + (1 * 3^0)
= 0 + 2187 + 0 + 486 + 81 + 0 + 0 + 6 + 1
= 2761
1) Procedure:
• Elements of vector:
– 0: Empty
– 1: X
– 2: O
→ the vector is a ternary number
2) Store inside the program a move-table
(lookuptable):
a) Elements in the table: 19683 (39 )
b) Element = A vector which describes the
most suitable move.
Comments:
1. A lot of space to store the Move-Table.
2. A lot of work to specify all the entries in the Move-Table.
3. Difficult to extend
 The second approach (Program 2)
• The structure of the data is as before but we use 2 for a blank, 3 for an X
and 5 for an O.
• A variable called TURN indicates 1 for the first move and 9 for the last.

The algorithm consists of three actions:

• MAKE2 which returns 5 if the centre square is blank; otherwise it returns
any blank noncorner square, i.e. 2, 4, 6 or 8.
• POSSWIN (p) returns 0 if player p cannot win on the next move and
otherwise returns the number of the square that gives a winning move. It
checks each line using products 3*3*2 = 18 gives a win for X, 5*5*2=50
gives a win for O, and the winning move is the holder of the blank.
• GO(n) makes a move to square n setting BOARD[n] to 3 or 5.

This algorithm is more involved and takes longer but it is more efficient in
storage which compensates for its longer time. It depends on the programmer’s
skill.
• Data Structure:
1) Use vector, called board, as Solution 1
2) However, elements of the vector:
2: Empty
3: X
5: O
3) Turn of move: indexed by integer 1,2,3, etc
Make2:
a) Return a location on a game-board.
IF (board[5] = 2) RETURN 5;
//the center cell.
ELSE RETURN any cell that is not at the
board’s corner; // (cell: 2,4,6,8)
b) Let P represent for X or O
c) can_win(P) : P has filled already at least two
cells on a straight line (horizontal, vertical,
or diagonal)
d) cannot_win(P) = NOT(can_win(P))
2. Posswin(P):
IF (cannot_win(P))
RETURN 0;
ELSE
RETURN index to the empty cell on the line of
can_win(P)
Let odd numbers are turns of X
Let even numbers are turns of O
3. Go(n): make a move
 Algorithm
1. Turn = 1: (X moves)
• Go(1) //make a move at the left-top cell
2. Turn = 2: (O moves)
IF board[5] is empty THEN Go(5)
ELSE Go(1)
3. Turn = 3: (X moves)
IF board[9] is empty THEN Go(9)
ELSE Go(3).
4. Turn = 4: (O moves)
IF Posswin (X) <> 0 THEN Go (Posswin (X)) //Prevent the opponent to win
ELSE Go (Make2)
5. Turn = 5: (X moves)
IF Posswin(X) <> 0 THEN Go(Posswin(X)) //Win for X.
ELSE IF Posswin(O) <> THEN Go(Posswin(O)) //Prevent the opponent to win
ELSE IF board[7] is empty THEN Go(7)
ELSE Go(3).
Comments:
1. Not efficient in time, as it has to check
several conditions before making each move.
2. Easier to understand the program’s strategy.
3. Hard to generalize.
 Program 2’
• This is similar to program 2 but only change in board
representation. 8 3 4

1 5 9

6 7 2

• Numbering of Board produces magic square: all rows,

columns, and diagonals sum upto 15.
• This simplifies the process of checking for a possible win.
• A list is maintained for each player with every move. (pair
of squares)
• And for next move, difference of 15and the sum of squares
is going to be calculated.
 The final approach (Program 3): minimax procedure

• This algorithm looks ahead to make a decision

on the next move by deciding which the most
promising move or the most suitable move at
any stage would be and selects the same.
• Consider all possible moves and replies that
the program can make. Continue this process
for as long as time permits until a winner
emerges, and then choose the move that
leads to the computer program winning, if
possible in the shortest time.
• Define Functions:
• Minimax Algorithm: Implement the Minimax
algorithm to determine the best move for the
computer player ('O'). The Minimax algorithm is a
recursive algorithm that evaluates all possible
future moves and chooses the one that maximizes
the computer player's chances of winning while
minimizing the opponent's chances.
• Evaluate Board: Create a function to evaluate the
current state of the board and assign a score to
the board. This function will be used by the
Minimax algorithm to determine the best move.
• Minimax Algorithm:
– The Minimax algorithm is based on the concept of a game
tree, where each node represents a possible move and
each edge represents a possible outcome.
– The algorithm alternates between two players,
maximizing the computer player's score and minimizing
the opponent's score.
– At each level of the tree, the algorithm considers all
possible moves and recursively evaluates the resulting
board states.
– The algorithm assigns a score to each board state based
on whether it leads to a win, loss, or draw for the
computer player ('O').
– The computer player ('O') chooses the move that leads to
the highest score.
• Evaluate Board Function:
– The Evaluate Board function examines the current
state of the board and assigns a score to it based
on the following criteria:
• If the computer player ('O') wins, assign a high positive
score.
• If the opponent ('X') wins, assign a high negative score.
• If it's a draw, assign a neutral score.
• The score can be adjusted based on the depth of
recursion to favor quicker wins or avoid early losses.
• The minimax algorithm is a decision-making technique used in two-player zero-sum
games like Tic Tac Toe. It helps a player choose the optimal move by considering all
possible future game states and their outcomes.
Here's how minimax works with Tic Tac Toe:
1. Game State and Actions:
• Imagine the game board as the current state. Each empty cell represents a possible
action the current player can take.
2. Recursive Exploration:
• The minimax algorithm works recursively. It starts by evaluating the current state
(board) from the current player's perspective.
• For each available move (empty cell), the algorithm simulates the opponent's
(minimizing player) best possible response. This involves recursively calling minimax
again, but assuming the opponent makes the move that minimizes the current
player's score.
3. Scoring and Backtracking:
• At the end of each simulated game (reaching a win, draw, or full board), the minimax
algorithm assigns a score based on the outcome:
– +10: Current player wins.
– -10: Opponent wins.
– 0: Draw.
• This score is then "backed up" to the previous state (parent node in the game tree).
4. Maximizing vs. Minimizing:
• The current player (maximizing player) wants to choose the move that leads to the
highest score (minimizing the opponent's score).
• The minimax algorithm compares the scores returned from simulating each possible
move and chooses the one with the highest score for the maximizing player.
Tic Tac Toe Example:
• Let's consider a simplified scenario where X is the current player (maximizing) and O
is the opponent (minimizing). The current board state is:

• X can make three moves (empty cells).

• For each move, minimax simulates O's (opponent) best response:
– If X moves to the top left, O can potentially win by placing O in the bottom right. Minimax
assigns a score of -10 for this scenario.
– Similarly, minimax simulates the other two moves and assigns scores based on the best
possible outcome for O.
• Finally, minimax compares the scores for each of X's moves. If X moves to the
center, it forces a draw at worst (score 0). In the other two scenarios, X risks losing
(score -10).
• Therefore, minimax recommends X to move to the center to achieve the best
possible outcome (avoid losing).
• Benefits of Minimax:
• Minimax guarantees an optimal move for the maximizing player,
considering all possible future game states reachable within a
specified depth.
• It's relatively easy to understand and implement for simpler games
like Tic Tac Toe.
• Limitations of Minimax:
• The number of possible game states grows exponentially with the
game's complexity (number of moves and board size). This can make
minimax computationally expensive for complex games like chess.
• It assumes perfect play from both players, which might not be
realistic in real-world scenarios.
• In conclusion, the minimax algorithm provides a powerful tool for
making optimal decisions in two-player zero-sum games like Tic Tac
Toe. However, its computational complexity can be a challenge for
more complex games, leading to the exploration of alternative
techniques like alpha-beta pruning.
• def create_board():
• """
• Creates an empty Tic Tac Toe board.
• """
• return [' '] * 9

• def print_board(board):
• """
• Prints the Tic Tac Toe board in a formatted way.
• """
• for i in range(3):
• print(' | '.join(board[i * 3:(i * 3) + 3]))
• if i < 2:
• print('-' * 9)

• def is_valid_move(board, position):

• """
• Checks if a move is valid (position is empty).
• """
• return board[position] == ' '

• def make_move(board, player, position):

• """
• Places a player's mark on the board at the specified position.
• """
• board[position] = player
• def is_winner(board, player):
• """
• Checks if a player has won the game.
• """
• win_conditions = ((0, 1, 2), (3, 4, 5), (6, 7, 8),
• (0, 3, 6), (1, 4, 7), (2, 5, 8),
• (0, 4, 8), (2, 4, 6))
• for condition in win_conditions:
• if all(board[pos] == player for pos in condition):
• return True
• return False

• def is_board_full(board):
• """
• Checks if all the squares on the board are filled.
• """
• return all(x != ' ' for x in board)

• def main():
• """
• Main function to run the Tic Tac Toe game.
• """
• board = create_board()
• current_player = 'X'

• while True:
• print_board(board)
•
• # Get player input
• position = int(input(f"Player {current_player}, enter your move (1-9): ")) - 1
•
• # Validate move
• if not is_valid_move(board, position):
• print("Invalid move. Please try again.")
• continue

• # Make move
• make_move(board, current_player, position)

• # Check for winner or draw

• if is_winner(board, current_player):
• print_board(board)
• print(f"Player {current_player} wins!")
• break
• elif is_board_full(board):
• print_board(board)
• print("It's a draw!")
• break

• # Switch player
• current_player = 'O' if current_player == 'X' else 'X'

• if __name__ == "__main__":
• main()
 Example-2: Question Answering
• Let us consider Question Answering systems
that accept input in English and provide
answers also in English.
• This problem is harder than the previous one
as it is more difficult to specify the problem
properly.
• Another area of difficulty concerns deciding
whether the answer obtained is correct, or
not, and further what is meant by ‘correct’.
 For example, consider the following situation:

• Text
– Rani went shopping for a new Coat. She found a
red one she really liked. When she got home, she
found that it went perfectly with her favourite
dress.
• Question
1. What did Rani go shopping for?
2. What did Rani find that she liked?
3. Did Rani buy anything?
 Method 1
• Data Structures
– A set of templates that match common questions and
produce patterns used to match against inputs.
Templates and patterns are used so that a template
that matches a given question is associated with the
corresponding pattern to find the answer in the input
text.
– For example, the template who did x y generates x y z
if a match occurs and z is the answer to the question.
The given text and the question are both stored as
strings.
Algorithm: Answering a question requires the
following four steps to be followed:
• Compare the template against the questions
and store all successful matches to produce a
set of text patterns.
• Pass these text patterns through a substitution
process to change the person or voice and
produce an expanded set of text patterns.
• Apply each of these patterns to the text;
• collect all the answers and then print the
answers.
Example:
In question 1 we use the template WHAT DID X Y
which generates Rani go shopping for z and after
substitution we get Rani goes shopping for z and
Rani went shopping for z giving z [equivalence] a
new coat.
In question 2 we need a very large number of
templates and also a scheme to allow the insertion
of ‘find’ before ‘that she liked’; the insertion of
‘really’ in the text; and the substitution of ‘she’ for
‘Rani’ gives the answer ‘a red one’.
Question 3 cannot be answered.
• Comments :
– This is a very primitive approach basically not
matching the criteria we set for intelligence and
worse than that, used in the game. Surprisingly
this type of technique was actually used in ELIZA.
 Method 2
Data Structures:
A structure called English consists of a dictionary, grammar and
some semantics about the vocabulary we are likely to come across.
This data structure provides the knowledge to convert English text
into a storable internal form and also to convert the response back into
English.
The structured representation of the text is a processed form and
defines the context of the input text by making explicit all references
such as pronouns.
There are three types of such knowledge representation systems:
production rules of the form ‘if x then y’,
slot and filler systems
and statements in mathematical logic.
The system used here will be the slot and filler system.
Take, for example sentence: ‘She found a red one she
really liked’.

The question is stored in two forms: as input and in

the above form.
Algorithm:
• Convert the question to a structured form using
English know how, then use a marker to indicate
the substring (like ‘who’ or ‘what’) of the
structure, that should be returned as an answer.
If a slot and filler system is used a special marker
can be placed in more than one slot.
• The answer appears by matching this structured
form against the structured text.
• The structured form is matched against the text
and the requested segments of the question are
returned.
Examples:
Both questions 1 and 2 generate answers via a new
coat and a red coat respectively. Question 3 cannot be
answered, because there is no direct response.

Comments
This approach is more meaningful than the
previous one and so is more effective. The extra power
given must be paid for by additional search time in the
knowledge bases.
A warning must be given here: that is – to generate
unambiguous English knowledge base is a complex task.
The problems of handling pronouns are difficult.
For example:
• Rani walked up to the salesperson: she asked
where the toy department was.
• Rani walked up to the salesperson: she asked
her if she needed any help.
– Whereas in the original text the linkage of ‘she’ to
‘Rani’ is easy, linkage of ‘she’ in each of the above
sentences to Rani and to the salesperson requires
additional knowledge about the context via the
people in a shop.
 Method 3
• Data Structures :
• World model contains knowledge about objects,
actions and situations that are described in the input
text.
• This structure is used to create integrated text from
input text.
• The diagram shows how the system’s knowledge of
shopping might be represented and stored.
• This information is known as a script and in this case
is a shopping script.
Algorithm
• Convert the question to a structured form using
both the knowledge contained in Method 2 and the
World model, generating even more possible
structures, since even more knowledge is being
used. Sometimes filters are introduced to prune the
possible answers.
• To answer a question, the scheme followed is:
Convert the question to a structured form as before
but use the world model to resolve any ambiguities
that may occur. The structured form is matched
against the text and the requested segments of the
question are returned.
• Example
– Both questions 1 and 2 generate answers, as in
the previous program.
– Question 3 can now be answered. The shopping
script is instantiated and from the last sentence
the path through step 14 is the one used to form
the representation. ‘M’ is bound to the red coat-
got home. ‘Rani buys a red coat’ comes from step
10 and the integrated text generates that she
bought a red coat.
• Comments
• This program is more powerful than both the previous
programs because it has more knowledge.
• Thus, like the last game program it is exploiting AI
techniques.
• However, we are not yet in a position to handle any English
question. The major omission is that of a general reasoning
mechanism known as inference to be used when the
required answer is not explicitly given in the input text.
• But this approach can handle, with some modifications,
questions of the following form with the answer—Saturday
morning Rani went shopping. Her brother tried to call her
but she did not answer.
– Question: Why couldn’t Rani’s brother reach her?
– Answer: Because she was not in.
• This answer is derived because we have
supplied an additional fact that a person
cannot be in two places at once. This patch is
not sufficiently general so as to work in all
cases and does not provide the type of
solution we are really looking for.
• Question answering (QA) is a fundamental and challenging problem in the field of Artificial Intelligence (AI),
specifically within Natural Language Processing (NLP). It aims to develop systems that can automatically
answer questions posed by humans in natural language.
Here are some key aspects of the question answering problem:

1. Understanding Natural Language:

• Unlike simple keyword matching, QA systems need to understand the intent behind a question.
• This involves tasks like:
– Identifying the question type: Is it factual, open ended, requiring reasoning, or something else?
– Extracting key entities and their relationships: Who, what, when, where, why, and how are mentioned in the
question and how do they relate to each other?
– Understanding the context: What information is provided in the surrounding text or the user's previous interactions?

2. Finding Relevant Information:

• Once the question is understood, the system needs to find the relevant information to answer it. This may
involve:
– Searching through a massive knowledge base: This could be a general knowledge base or a domain-specific one,
depending on the nature of the question.
– Retrieving relevant documents: If the answer is not explicitly present in a knowledge base, the system might need to
retrieve and process relevant documents from a large corpus of text.

3. Generating the Answer:

• Finally, the system needs to generate an answer in a natural language format that is:
– Factual and accurate: The answer should be based on the retrieved information and not include any misinformation.
– Relevant and concise: The answer should directly address the question and avoid irrelevant details.
– Clear and understandable: The answer should be phrased in natural language that is easy for the user to understand.
Challenges of Question Answering:

• Ambiguity and complexity of natural language: Language can be ambiguous, with multiple meanings for
words and phrases depending on context. Understanding the nuances of language is challenging for AI
systems.
• Open ended and challenging questions: Not all questions have clear-cut answers, and some may require
reasoning, common sense, or knowledge of the real world that is difficult to encode in a computer
program.
• Keeping knowledge bases and information sources up-to-date: As the world and information constantly
change, ensuring the knowledge base and information sources used by QA systems are accurate and up-to-
date is crucial.

Approaches to Question Answering:

• Rule-based systems: These rely on hand-crafted rules to identify question types, extract information, and
generate answers. However, they can be difficult to maintain and scale to handle the diversity of natural
language.
• Statistical learning: Machine learning algorithms are trained on large datasets of questions and answers to
learn patterns and automatically generate responses. This approach is more flexible but requires significant
data and computational resources.

Applications of Question Answering:

• Search engines: QA technology is used to power advanced search functionalities that can understand
complex queries and provide more relevant and informative results.
• Virtual assistants: Chatbots and virtual assistants leverage QA to answer user questions about various
topics and complete tasks.
• Education and training: QA systems can be used to create interactive learning environments where users
can ask questions and receive immediate answers, enhancing the learning experience.
• Overall, question answering is an active area of research in AI with significant progress being made.
However, it remains a challenging problem due to the complexities of natural language and the ever-
• import spacy
• # Load the spaCy language model
• nlp = spacy.load("en_core_web_sm")
• def answer_question(question, text):
• """
• This is a simplified example and doesn't represent a complete QA system.
• It performs basic named entity recognition and keyword matching.
• Args:
• question: The question to be answered (string).
• text: The text to be analyzed (string).

• Returns:
• A potential answer extracted from the text (string), or "No answer found" if no match is found.
• """
• # Process the question and text using spaCy
• doc_question = nlp(question)
• doc_text = nlp(text)
• # Extract named entities from the question
• question_entities = [ent.text for ent in doc_question.ents]
• # Look for entities and keywords in the text that match the question
• for entity in question_entities:
• if entity.lower() in text.lower():
• # Simplistic answer extraction based on keyword matching
• return f"A possible answer based on keyword matching: {entity}"
• return "No answer found"
• # Example usage
• question = "What is the capital of France?"
• text = "France is a European country. Paris is its capital city."
• answer = answer_question(question, text)
• print(answer)

• #output
• = RESTART: C:/Users/NANDINI/AppData/Local/Programs/Python/Python311/Scripts/nlp.py
• A possible answer based on keyword matching: France
 Example:
You are using a search engine and want to know the capital of France. You type the question:
"What is the capital of France?" into the search bar.
• The question answering system performs the following steps:
• Understanding the question: The system identifies the question type (factual question) and
recognizes the named entity "France" as a country.
• Finding relevant information: The system searches its database of information, which may
include text documents and knowledge bases. It retrieves relevant information related to
"France" and its capital city.
• Generating the answer: The system extracts the answer "Paris" from the retrieved
information and presents it to you in a concise and informative way: "The capital of France is
Paris."
• Additional Information:
• This example showcases a retrieval-based approach to question answering. However, other
approaches exist, including generative models that might directly generate an answer like:
"Bonjour! I can tell you that the capital of France is the beautiful city of Paris."
• Furthermore, question answering systems are constantly evolving, and researchers are
exploring ways to improve their capabilities in various aspects, such as:
• Handling more complex and open-ended questions.
• Understanding the context of the question and providing relevant answers based on the
context.
• Generating answers that are not only factually accurate but also grammatically correct and
engaging.
 Example:
• Scenario:
• You're reading an online news article about the latest advancements in electric vehicle technology. You
come across a sentence mentioning "lithium-ion batteries" and are curious about their specific
advantages and disadvantages. Instead of searching the web yourself, you decide to ask the built-in AI
assistant within the news platform: "What are the advantages and disadvantages of lithium-ion
batteries?"
• The question answering system performs the following steps:
• Understanding the context: The system analyzes the surrounding text and recognizes the mention of
"lithium-ion batteries" within the context of the news article about electric vehicles. This helps the
system understand the user's intent and focus on information related to the specific context.
• Finding relevant information: The system leverages its knowledge base and potentially searches the
surrounding article for relevant information about lithium-ion batteries. It retrieves information that
discusses both the advantages (e.g., high energy density, long lifespan) and disadvantages (e.g., cost,
safety concerns).
• Generating the answer: The system summarizes the retrieved information, focusing on the advantages
and disadvantages relevant to the context of electric vehicles. It presents the answer in a concise and
informative way, potentially even referencing specific details from the surrounding article.
• Example Answer:
• "Lithium-ion batteries offer several advantages for electric vehicles, including high energy density,
allowing for longer range on a single charge, and longer lifespans compared to other battery
technologies. However, they also come with disadvantages, such as higher cost compared to some
alternatives and potential safety concerns related to thermal runaway in rare cases."
• This example demonstrates a hybrid approach, combining context understanding with information
retrieval and summarization to provide a focused and informative answer tailored to the user's specific
question within the context of the surrounding information.
 Conclusion:
• In the above 2 problems, the final program
exemplifies what we mean by an AI
Technique. Here come across 3 main AI
Techniques:
– Search
– Use of Knowledge
– Abstraction
The Level of the Model(Approaches to AI)
• Acting humanly: The Turing test approach ..
• Thinking humanly: The cognitive modelling
approach ..
• Thinking rationally: The ``laws of thought''
approach ..
• Acting rationally: The rational agent
approach..
Acting humanly: The Turing test approach
 Cont..
 To pass the Turing Test a machine will need the capabilities of
-natural language processing to enable it to communicate
successfully in English;
- knowledge representation to store what it knows or hears;
- automated reasoning to use the stored information to
answer questions and to draw new conclusions;
- machine learning to adapt to new circumstances and to
detect and extrapolate patterns.
 Total Turing Test: Also tests the subject’s perceptual abilities
through video and passing physical objects; additional
capabilities of
- Computer vision
- Robotics
 Cont..
• Importance: This approach focuses on
creating AI systems that interact with humans
in a natural and understandable way.
• This can improve user experience, trust, and
acceptance of AI.
• Examples include chatbots that use natural
language or robots that move and behave in
ways that are familiar to humans.
"Thinking Humanly: The Cognitive Modeling
Approach":
• the idea of creating computer programs that
think like humans.
• determining how humans think.
• need to get inside the actual workings of
human minds.
• There are three ways to do this: introspection,
psychological experiments, and brain
imaging.
 Cont..
• through introspection—trying to catch our
own thoughts as they go by;
• through psychological experiments—
observing a person in action;
• and through brain imaging—observing the
brain in action.
 Building Cognitive Models:
• Understanding the Mind Through Computation-
Cognitive models are computational
representations of mental processes. They attempt
to capture how humans think, learn, and make
decisions.
• The interdisciplinary field of cognitive science brings
together computer models from AI and
experimental techniques from psychology to
construct precise and testable theories of the
human mind.
 Building these models involves:
1. Defining the Scope:
– What cognitive process are you modeling? (e.g., memory, decision-making, language
comprehension)
– What level of detail is needed? (e.g., individual neurons, brain regions, psychological constructs)
2. Gathering Data:
– Behavioral data (e.g., reaction times, accuracy rates)
– Physiological data (e.g., brain scans, eye movements)
– Introspective data (e.g., verbal reports, self-reflection)
3. Choosing a Computational Framework:
– Symbolic AI (e.g., rules, logic)
– Connectionist AI (e.g., artificial neural networks)
– Bayesian networks (e.g., probabilistic reasoning)
4. Developing the Model:
– Implementing the chosen framework
– Training the model on the gathered data
– Refining the model based on evaluation
5. Testing and Evaluation:
– Comparing model predictions to human behavior
– Analyzing strengths and weaknesses of the model
– Iterating on the model based on the evaluation
 Cont..
• Importance: This approach aims to replicate
human-like cognitive abilities, such as
learning, reasoning, and problem-solving.
• This can lead to more adaptable and
intelligent AI systems.
• Examples include self-driving cars that make
decisions like human drivers or AI systems that
diagnose diseases like doctors.
 Thinking Rationally: The "Laws of Thought" Approach

• The "laws of thought" approach to rationality

aims to establish a set of fundamental
principles for logical reasoning.
• These principles, often referred to as laws of
logic, are considered to be universally true
and provide a framework for evaluating the
validity of arguments and inferences.
 Core principles:
Some of the fundamental laws of thought include:
Law of Identity: A statement is true if and only if
it is true (e.g., "All bachelors are unmarried").
Law of Non-Contradiction: A statement cannot be
both true and false at the same time (e.g., "It is
both raining and not raining outside").
Law of Excluded Middle: Every statement is
either true or false, there is no third option
(e.g., "The ball is either red or not red").
 Applications:
These laws can be used to:
• Identify fallacies in arguments (e.g., pointing
out a violation of the law of non-contradiction).
• Construct valid arguments that are guaranteed
to lead to true conclusions.
• Develop formal systems of logic, such as
propositional logic and predicate logic.
 Cont..
• The "laws of thought" approach provides a
clear and rigorous framework for evaluating
reasoning.
• It can help to identify and avoid common
errors in thinking.
• It has applications in various fields, including
computer science, mathematics, and
philosophy.
 Cont..
• Goal: Aims to create AI systems that make logical and
well-founded decisions based on available information.
• Importance:
– Reduces errors and biases: By following clear reasoning
patterns, AI can avoid mistakes and unfair judgments.
– Improves explainability and transparency: Logical decision-
making processes are easier to understand and
audit, fostering trust in AI systems.
– Enables effective planning and problem-solving: AI can
analyze situations, consider alternatives, and choose
optimal actions rationally.
 Challenges:

• Defining rationality: What constitutes "rational"

behavior can vary depending on the context and
goals of the AI system.
• Handling incomplete information: Real-world
scenarios often involve uncertainty and
ambiguity, requiring AI to reason effectively despite
limitations.
• Balancing logic with other factors: Purely rational
AI might not consider ethical or social
implications, necessitating careful design choices.
Acting Rationally: The Rational Agent Approach

• The rational agent approach is a way of

thinking about artificial intelligence (AI) that
focuses on creating agents that act in a way
that is expected to achieve their goals, given
their beliefs about the world.
• This approach is based on the idea that an
agent's actions should be guided by logic and
reason, rather than emotions or impulse.
Here are some key points about the rational
agent approach:
• Goals and beliefs: A rational agent has well-
defined goals and beliefs about the world. These
goals and beliefs guide the agent's decision-
making.
• Perception and action: The agent perceives the
world through its sensors and takes actions that it
believes will help it achieve its goals.
• Performance measure: The agent's performance is
measured by how well it achieves its goals, given
its limited resources and knowledge.
 Here are some examples:
• Self-driving cars: These systems have the goal of safely navigating
from one point to another. They use sensors to perceive the world
around them and make decisions about how to steer, brake, and
accelerate.
• Chess-playing programs: These programs have the goal of
winning the game of chess. They use their knowledge of the rules
of chess and their evaluation of the current board position to
choose their next move.
• Recommendation systems: These systems have the goal of
recommending products or services that users are likely to be
interested in. They use information about the user's past behavior
and the characteristics of different products or services to make
their recommendations.
 Cont..
• Goal: Aims to create AI systems that behave in ways that
achieve their goals effectively in the real world.
• Importance:
– Increases effectiveness: AI can adapt its actions to different
situations and unforeseen circumstances to achieve its
objectives.
– Enables interaction and collaboration: AI can act in ways that
are understandable and predictable for humans, facilitating
cooperation.
– Promotes responsible AI development: Considering real-
world impacts of AI actions encourages ethical and beneficial
applications.
 Cont..
• Challenges:
• Aligning goals with human values: Ensuring AI actions align
with desired outcomes and societal values requires careful
consideration of potential risks and unintended
consequences.
• Accounting for emotions and social cues: Human
interactions often involve emotions and social nuances that
AI may struggle to understand and respond to appropriately.
• Avoiding manipulation and deception: It's crucial to design
AI that acts transparently and avoids misleading or
exploiting others.
 Pros and Cons of 4 approaches..
• Acting Like Humans:
• Pros: Can make AI more relatable and
understandable to users, potentially fostering trust
and acceptance. Useful for tasks like natural
language processing and human-computer
interaction.
• Cons: Can be misleading or manipulative if AI
doesn't truly understand human emotions or
intentions. Raises ethical concerns about artificial
sentience or consciousness.
 Cont..
• Thinking Like Humans:
• Pros: Could lead to AI with more flexible and adaptable
reasoning abilities, able to handle complex situations
and learn from experience. Useful for tasks like
problem-solving and decision-making in uncertain
environments.
• Cons: Difficult to define and replicate what "thinking like
a human" even means. Human thought is messy and
influenced by emotions, biases, and social
contexts, which might be challenging for AI to model
accurately.
 Cont..
• Thinking Rationally:
• Pros: Provides a clear framework for AI decision-
making, potentially reducing errors and
biases. Useful for tasks requiring logical analysis
and objective reasoning.
• Cons: Can be overly simplistic and struggle with
real-world complexities like incomplete
information or ethical dilemmas. Might not
account for emotional or social factors important in
human interactions.
 Cont..
• Acting Rationally:
• Pros: Ensures AI actions align with its goals and
achieve desired outcomes effectively. Useful for
tasks requiring efficient task completion and
adaptation to changing environments.
• Cons: Needs careful consideration of AI's goals to
ensure they align with human values and don't
cause harm. Must avoid manipulation or
deception, and account for social contexts and
potential unintended consequences.
 Criteria for success
In the very beginning i.e in 1950 Alan Turing designed a test called Turing Test. But now The criteria for success in artificial
intelligence (AI) can vary depending on the specific task, application, and context. Some common criteria used to evaluate the
success of AI systems include:
• Accuracy: This criterion measures how well the AI system performs its intended task. For example, in a machine learning
model for image classification, accuracy refers to the percentage of correctly classified images compared to the total
number of images.
• Precision and Recall: Precision measures the proportion of true positive predictions out of all positive predictions made
by the AI system, while recall measures the proportion of true positive predictions out of all actual positive instances in
the dataset. These metrics are commonly used in tasks such as information retrieval and binary classification.
• Speed and Efficiency: The speed and efficiency of an AI system refer to how quickly it can perform its tasks and how
efficiently it utilizes computational resources such as CPU, memory, and energy. Faster and more efficient systems are
often preferred in real-time applications and resource-constrained environments.
• Robustness: Robustness measures the ability of an AI system to perform consistently and accurately across different
conditions, such as varying input data, noise, or environmental changes. A robust system can maintain its performance
under different scenarios without significant degradation.
• Scalability: Scalability refers to the ability of an AI system to handle increasing amounts of data, users, or computational
demands while maintaining its performance. Scalable systems can efficiently process large datasets or accommodate
growing user bases without significant performance degradation.
• Interpretability: Interpretability refers to the degree to which an AI system's decisions and behaviors can be understood
and explained by humans. Systems that are more interpretable are often preferred in applications where transparency
and accountability are important, such as healthcare and finance.
• Generalization: Generalization measures the ability of an AI system to apply its learned knowledge to new, unseen data
or tasks. A system that can generalize well can make accurate predictions or decisions in novel situations beyond its
training data.
• User Satisfaction: User satisfaction measures how well an AI system meets the needs and expectations of its users.
Factors such as usability, user experience, and user feedback are important for evaluating user satisfaction.
• These criteria are often used individually or in combination to assess the success of AI systems in various applications and
domains. Depending on the specific goals and requirements of a project, additional criteria may also be considered.
 THE FOUNDATIONS OF ARTIFICIAL
INTELLIGENCE
• A brief history of the disciplines that contributed ideas,
viewpoints, and techniques to AI.
-Philosophy
-Mathematics
-Economics
-Neuroscience
-Psychology
-Computer engineering
-Control theory and cybernetics
-Linguistics
Philosophy : It discussed a historical overview of philosophical contributions
to the development of Artificial Intelligence (AI). It focuses on four key questions:

• Formal rules and reasoning: Can logical rules be used to draw valid
conclusions? Philosophers like Aristotle and Leibniz explored this
question, laying the groundwork for symbolic reasoning in AI.
• Mind and matter: Is the mind a physical system governed by the laws of
physics, or something separate from it? This debate between dualism
(Descartes) and materialism has implications for understanding how
intelligence arises.
• Source of knowledge: Where does knowledge come from? Empiricism
(Locke, Hume) emphasizes sensory experience, while rationalism
(Leibniz) highlights the role of reason. AI research draws on both
perspectives.
• Knowledge and action: How does knowledge lead to action? Aristotle's
work on goal-directed reasoning and decision-making has influenced
research in planning and decision-making for AI systems.
Mathematics : This delves into the mathematical foundations of
Artificial Intelligence (AI), focusing on three key areas :

• Logic: Formal logic, originating from ancient Greece and formalized by

Boole, Frege, and Tarski, provides a framework for drawing valid
conclusions and reasoning with certainty.
• Computation: The concept of computability, explored by Gödel and
Turing, defines the limits of what can be achieved through algorithmic
processes. It highlights the existence of problems that cannot be solved by
machines, emphasizing the need for efficient resource management in AI.
• Probability: Probability theory, pioneered by Cardano, Pascal, and
Bayes, helps deal with uncertainty and incomplete information, crucial for
AI systems operating in real-world scenarios.
• These mathematical contributions laid the groundwork for developing AI
models and algorithms capable of reasoning, learning, and making
decisions under various conditions. Understanding these concepts is
essential for further exploring the field of AI.
 Economics: the contributions of economics to the field of Artificial Intelligence (AI), focusing on three key areas:

• Decision-making: How do individuals make choices to achieve their desired outcomes?

This involves concepts like utility theory, which formalizes the idea of "preferred
outcomes," and decision theory, which incorporates probability into decision-making under
uncertainty.
• Game theory: How do individuals make decisions when their choices affect each other?
This branch of economics studies strategic interactions between agents, where one player's
actions influence the payoffs of others.
• Sequential decision-making: How do individuals make choices when the outcomes depend
on a series of actions taken over time? This area, explored in operations research, deals
with problems where optimal decisions involve considering future consequences.
highlights the concept of "satisficing" introduced by Herbert Simon, which suggests that
in the face of complex decisions, individuals often make choices that are "good enough" rather
than searching for the absolute optimal solution.
Overall, economics provides valuable frameworks and tools for AI research, particularly
in areas like multi-agent systems, robot planning, and resource allocation. Understanding how
individuals and groups make decisions can inform the design of intelligent agents that interact
effectively with the world and each other.
Neuroscience: an overview of neuroscience and its contributions to the field of Artificial Intelligence (AI). Here are some key points:

• Brain structure and function: The brain consists of interconnected

nerve cells called neurons, responsible for information processing.
Different brain regions have specialized functions, like speech
production or sensory perception.
• Brain activity measurement: Techniques like EEG and MRI allow
scientists to observe brain activity during various cognitive tasks,
providing insights into how the brain works.
• Challenges in understanding the brain: Despite advancements,
fully understanding how the brain enables thought, memory, and
consciousness remains a scientific mystery.
• Brain vs. computers: While sharing some similarities, brains and
computers differ significantly in their processing speed, storage
capacity, and architectural design.
The parts of a nerve cell or neuron
 Psychology:delves into the fascinating history of psychology and its contributions to
understanding how humans and animals think and act. Here are the key takeaways:

• Psychology as a science: The field emerged in the 19th century with

efforts to study mental processes using scientific methods. Early
pioneers like Wundt established experimental psychology, while
others like Jennings focused on objective observation of animal
behavior.
• Different perspectives: Two major schools of thought emerged:
– Behaviorism: Focused on observable behaviors and stimuli-response
relationships, rejecting subjective introspection as unreliable.
– Cognitive psychology: Views the brain as an information processor, studying
internal mental processes like memory, language, and decision-making.
• The rise of cognitive science: Combining psychology with computer
modeling led to this new field, aiming to understand cognition
through computational theories and simulations.
Computer engineering: a historical overview of computer engineering, focusing on how efficient computers have been built and their role in artificial
intelligence (AI). Here are the key takeaways:

• Early computers: The first digital computers were developed during World
War II, with the Colossus and ENIAC being influential early models. These
machines laid the foundation for modern computers.
• Moore's Law: For several decades, computer performance roughly doubled
every two years, following a trend known as Moore's Law. This rapid
progress was fueled by miniaturization of transistors and other components.
• Challenges and future directions: As miniaturization reaches its
limits, future performance gains are expected to come from other
innovations like parallel processing and specialized hardware.
• Software's role: the importance of software, including operating
systems, programming languages, and tools, in enabling AI development.
• AI's contributions to computer science: how research in AI has also led to
advancements in mainstream computer science, such as time-
sharing, interactive interfaces, and new programming concepts.
 Control theory and cybernetics:

• Early examples of self-control: The idea of machines regulating their own behavior dates
back centuries, as seen in inventions like the water clock and the steam engine governor.
• Birth of control theory: The 19th century saw the development of the mathematical
foundation for stable feedback systems, paving the way for more advanced control
mechanisms.
• Norbert Wiener and cybernetics: Wiener's work bridged the gap between engineering and
biology, suggesting parallels between machine control and animal behavior. His book
"Cybernetics" popularized the notion of intelligent machines.
• Homeostasis and adaptation: W. Ross Ashby and others explored the concept of
"homeostasis," where systems maintain stability through feedback loops, as a potential
principle for achieving intelligence.
• Modern control theory: Today, control theory aims to design systems that optimize specific
objectives over time, reflecting a common goal with AI.
• Divergence of AI and control theory: Despite their shared history, the two fields diverged
due to differences in their mathematical tools and the types of problems they addressed.
Control theory focused on continuous variables and well-defined systems, while AI explored
broader challenges like language, vision, and planning.
 Linguistics: an interesting look at the relationship between linguistics and artificial
intelligence (AI), particularly regarding language and thought. Here are some key points:

• Behaviorism vs. Creativity:

Behaviorism, focusing on observable behavior, struggled to explain how
children use language creatively.
Chomsky's theory, emphasizing syntax and structure, offered an
alternative explanation for language acquisition and generation.
• Birth of Computational Linguistics:
Chomsky's work coincided with the development of AI, leading to the
field of computational linguistics, which applies computer science to
understand and process language.
• Beyond Syntax:
Language understanding requires knowledge of the world and context,
not just sentence structure.
Research in linguistics and philosophy informed the development of
knowledge representation in AI.