Paradigms of artificial intelligence programming case studies in Common Lisp 1st edition by Peter Norvig 0080571158 9781558601918 9780080571157

Paradigms of artificial intelligence programming case studies in Common Lisp 1st edition by Peter Norvig – Ebook PDF Instant Download/DeliveryISBN:  0080571158, 9781558601918, 9780080571157 

Full download Paradigms of artificial intelligence programming case studies in Common Lisp 1st edition after payment.

Product details:

ISBN-10 :  0080571158 

ISBN-13 :  9780080571157, 9781558601918 

Author :  Peter Norvig 

Paradigms of AI Programming is the first text to teach advanced Common Lisp techniques in the context of building major AI systems. By reconstructing authentic, complex AI programs using state-of-the-art Common Lisp, the book teaches students and professionals how to build and debug robust practical programs, while demonstrating superior programming style and important AI concepts. The author strongly emphasizes the practical performance issues involved in writing real working programs of significant size. Chapters on troubleshooting and efficiency are included, along with a discussion of the fundamentals of object-oriented programming and a description of the main CLOS functions. This volume is an excellent text for a course on AI programming, a useful supplement for general AI courses and an indispensable reference for the professional programmer.

Paradigms of artificial intelligence programming case studies in Common Lisp 1st Table of contents:

Part I: Introduction to Common Lisp
Chapter 1: Introduction to Lisp
1.1 Symbolic Computation
1.2 Variables
1.3 Special Forms
1.4 Lists
1.5 Defining New Functions
1.6 Using Functions
1.7 Higher-Order Functions
1.8 Other Data Types
1.9 Summary: The Lisp Evaluation Rule
1.10 What Makes Lisp Different?
1.11 Exercises
1.12 Answers
Chapter 2: A Simple Lisp Program
2.1 A Grammar for a Subset of English
2.2 A Straightforward Solution
2.3 A Rule-Based Solution
2.4 Two Paths to Follow
2.5 Changing the Grammar without Changing the Program
2.6 Using the Same Data for Several Programs
2.7 Exercises
2.8 Answers
Chapter 3: Overview of Lisp
3.1 A Guide to Lisp Style
3.2 Special Forms
3.3 Functions on Lists
3.4 Equality and Internal Representation
3.5 Functions on Sequences
3.6 Functions for Maintaining Tables
3.7 Functions on Trees
3.8 Functions on Numbers
3.9 Functions on Sets
3.10 Destructive Functions
3.11 Overview of Data Types
3.12 Input/Output
3.13 Debugging Tools
3.14 Antibugging Tools
3.15 Evaluation
3.16 Closures
3.17 Special Variables
3.18 Multiple Values
3.19 More about Parameters
3.20 The Rest of Lisp
3.21 Exercises
3.22 Answers
Part II: Early AI Programs
Chapter 4: GPS: The General Problem Solver
4.1 Stage 1: Description
4.2 Stage 2: Specification
4.3 Stage 3: Implementation
4.4 Stage 4: Test
4.5 Stage 5: Analysis, or “We Lied about the G”
4.6 The Running Around the Block Problem
4.7 The Clobbered Sibling Goal Problem
4.8 The Leaping before You Look Problem
4.9 The Recursive Subgoal Problem
4.10 The Lack of Intermediate Information Problem
4.11 GPS Version 2: A More General Problem Solver
4.12 The New Domain Problem: Monkey and Bananas
4.13 The Maze Searching Domain
4.14 The Blocks World Domain
4.15 Stage 5 Repeated: Analysis of Version 2
4.16 The Not Looking after You Don’t Leap Problem
4.17 The Lack of Descriptive Power Problem
4.18 The Perfect Information Problem
4.19 The Interacting Goals Problem
4.20 The End of GPS
4.21 History and References
4.22 Exercises
4.23 Answers
Chapter 5: Eliza: Dialog With a Machine
5.1 Describing and Specifying ELIZA
5.2 Pattern Matching
5.3 Segment Pattern Matching
5.4 The ELIZA Program: A Rule-Based Translator
5.5 History and References
5.6 Exercises
5.7 Answers
Chapter 6: Building Software Tools
6.1 An Interactive Interpreter Tool
6.2 A Pattern-Matching Tool
6.3 A Rule-Based Translator Tool
6.4 A Set of Searching Tools
6.5 GPS as Search
6.6 History and References
6.7 Exercises
6.8 Answers
Chapter 7: STUDENT: Solving Algebra Word Problems
7.1 Translating English into Equations
7.2 Solving Algebraic Equations
7.3 Examples
7.4 History and References
7.5 Exercises
7.6 Answers
Chapter 8: Symbolic Mathematics: A Simplification Program
8.1 Converting Infix to Prefix Notation
8.2 Simplification Rules
8.3 Associativity and Commutativity
8.4 Logs, Trig, and Differentiation
8.5 Limits of Rule-Based Approaches
8.6 Integration
8.7 History and References
8.8 Exercises
Part III: Tools and Techniques
Chapter 9: Efficiency Issues
9.1 Caching Results of Previous Computations: Memoization
9.2 Compiling One Language into Another
9.3 Delaying Computation
9.4 Indexing Data
9.5 Instrumentation: Deciding What to Optimize
9.6 A Case Study in Efficiency: The SIMPLIFY Program
9.7 History and References
9.8 Exercises
9.9 Answers
Chapter 10: Low-Level Efficiency Issues
10.1 Use Declarations
10.2 Avoid Generic Functions
10.3 Avoid Complex Argument Lists
10.4 Avoid Unnecessary Consing
10.5 Use the Right Data Structures
10.6 Exercises
10.7 Answers
Chapter 11: Logic Programming
11.1 Idea 1: A Uniform Data Base
11.2 Idea 2: Unification of Logic Variables
11.3 Idea 3: Automatic Backtracking
11.4 The Zebra Puzzle
11.5 The Synergy of Backtracking and Unification
11.6 Destructive Unification
11.7 Prolog in Prolog
11.8 Prolog Compared to Lisp
11.9 History and References
11.10 Exercises
11.11 Answers
Chapter 12: Compiling Logic Programs
12.1 A Prolog Compiler
12.2 Fixing the Errors in the Compiler
12.3 Improving the Compiler
12.4 Improving the Compilation of Unification
12.5 Further Improvements to Unification
12.6 The User Interface to the Compiler
12.7 Benchmarking the Compiler
12.8 Adding More Primitives
12.9 The Cut
12.10 “Real” Prolog
12.11 History and References
12.12 Exercises
12.13 Answers
Chapter 13: Object-Oriented Programming
13.1 Object-Oriented Programming
13.2 Objects
13.3 Generic Functions
13.4 Classes
13.5 Delegation
13.6 Inheritance
13.7 CLOS: The Common Lisp Object System
13.8 A CLOS Example: Searching Tools
13.9 Is CLOS Object-Oriented?
13.10 Advantages of Object-Oriented Programming
13.11 History and References
13.12 Exercises
Chapter 14: Knowledge Representation and Reasoning
14.1 A Taxonomy of Representation Languages
14.2 Predicate Calculus and its Problems
14.3 A Logical Language: Prolog
14.4 Problems with Prolog’s Expressiveness
14.5 Problems with Predicate Calculus’s Expressiveness
14.6 Problems with Completeness
14.7 Problems with Efficiency: Indexing
14.8 A Solution to the Indexing Problem
14.9 A Solution to the Completeness Problem
14.10 Solutions to the Expressiveness Problems
14.11 History and References
14.12 Exercises
14.13 Answers
Part IV: Advanced AI Programs
Chapter 15: Symbolic Mathematics with Canonical Forms
15.1 A Canonical Form for Polynomials
15.2 Differentiating Polynomials
15.3 Converting between Infix and Prefix
15.4 Benchmarking the Polynomial Simplifier
15.5 A Canonical Form for Rational Expressions
15.6 Extending Rational Expressions
15.7 History and References
15.8 Exercises
15.9 Answers
Chapter 16: Expert Systems
16.1 Dealing with Uncertainty
16.2 Caching Derived Facts
16.3 Asking Questions
16.4 Contexts Instead of Variables
16.5 Backward-Chaining Revisited
16.6 Interacting with the Expert
16.7 Interacting with the Client
16.8 MYCIN, A Medical Expert System
16.9 Alternatives to Certainty Factors
16.10 History and References
16.11 Exercises
16.12 Answers
Chapter 17: Line-Diagram Labeling by Constraint Satisfaction
17.1 The Line-Labeling Problem
17.2 Combining Constraints and Searching
17.3 Labeling Diagrams
17.4 Checking Diagrams for Errors
17.5 History and References
17.6 Exercises
Chapter 18: Search and the Game of Othello
18.1 The Rules of the Game
18.2 Representation Choices
18.3 Evaluating Positions
18.4 Searching Ahead: Minimax
18.5 Smarter Searching: Alpha-Beta Search
18.6 An Analysis of Some Games
18.7 The Tournament Version of Othello
18.8 Playing a Series of Games
18.9 More Efficient Searching
18.10 It Pays to Precycle
18.11 Killer Moves
18.12 Championship Programs: Iago and Bill
18.13 Other Techniques
18.14 History and References
18.15 Exercises
18.16 Answers
Chapter 19: Introduction to Natural Language
19.1 Parsing with a Phrase-Structure Grammar
19.2 Extending the Grammar and Recognizing Ambiguity
19.3 More Efficient Parsing
19.4 The Unknown-Word Problem
19.5 Parsing into a Semantic Representation
19.6 Parsing with Preferences
19.7 The Problem with Context-Free Phrase-Structure Rules
19.8 History and References
19.9 Exercises
19.10 Answers
Chapter 20: Unification Grammars
20.1 Parsing as Deduction
20.2 Definite Clause Grammars
20.3 A Simple Grammar in DCG Format
20.4 A DCG Grammar with Quantifiers
20.5 Preserving Quantifier Scope Ambiguity
20.6 Long-Distance Dependencies
20.7 Augmenting DCG Rules
20.8 History and References
20.9 Exercises
20.10 Answers
Chapter 21: A Grammar of English
21.1 Noun Phrases
21.2 Modifiers
21.3 Noun Modifiers
21.4 Determiners
21.5 Verb Phrases
21.6 Adverbs
21.7 Clauses
21.8 Sentences
21.9 XPs
21.10 Word Categories
21.11 The Lexicon
21.12 Supporting the Lexicon
21.13 Other Primitives
21.14 Examples
21.15 History and References
21.16 Exercises
Part V: The Rest of Lisp
Chapter 22: Scheme: An Uncommon Lisp
22.1 A Scheme Interpreter
22.2 Syntactic Extension with Macros
22.3 A Properly Tail-Recursive Interpreter
22.4 Throw, Catch, and Call/cc
22.5 An Interpreter Supporting Call/cc
22.6 History and References
22.7 Exercises
22.8 Answers
Chapter 23: Compiling Lisp
23.1 A Properly Tail-Recursive Lisp Compiler
23.2 Introducing Call/cc
23.3 The Abstract Machine
23.4 A Peephole Optimizer
23.5 Languages with Different Lexical Conventions
23.6 History and References
23.7 Exercises
23.8 Answers
Chapter 24: ANSI Common Lisp
24.1 Packages
24.2 Conditions and Error Handling
24.3 Pretty Printing
24.4 Series
24.5 The Loop Macro
24.6 Sequence Functions
24.7 Exercises
24.8 Answers
Chapter 25: Troubleshooting
25.1 Nothing Happens
25.2 Change to Variable Has No Effect
25.3 Change to Function Has No Effect
25.4 Values Change “by Themselves”
25.5 Built-In Functions Don’t Find Elements
25.6 Multiple Values Are Lost
25.7 Declarations Are Ignored
25.8 My Lisp Does the Wrong Thing
25.9 How to Find the Function You Want
25.10 Syntax of LOOP
25.11 Syntax of COND
25.12 Syntax of CASE
25.13 Syntax of LET and LET*
25.14 Problems with Macros
25.15 A Style Guide to Lisp
25.16 Dealing with Files, Packages, and Systems
25.17 Portability Problems
25.18 Exercises
25.19 Answers

People also search for Paradigms of artificial intelligence programming case studies in Common Lisp 1st:

    
paradigms of machine learning
    
what are the main programming paradigms
    
what are the programming paradigms
    
how many programming paradigms are there
    
paradigms of ai programming