CS 378: Symbolic Programming: Online

CS 378 Class Web Page

Note: Links will be filled in after the lectures occur.

Lectures from Spring 2024

• January 16, 2024:
  • Clojure; Tree in Clojure; Binding
  • Interaction; cons: Add New Element to Front of List
  • Structure Sharing; first, rest
  • Combinations of first, rest; if statement

• January 18, 2024:
  • Structure Sharing; first, rest, cons
  • If, Predicates
  • Recursion; Top Level
  • sum of a list

• January 23, 2024:
  • reverse; append: Structure Sharing
  • append: Big O; Sets
  • Binomial via Pascal's Triangle

• January 25, 2024:
  • assocl; Short-Circuit Evaluation; cons as Binary Tree
  • gedanken; Identity Values; cons tree vs. Expression Tree
  • Notes on myeval, tojava

• January 30, 2024:
  • Tree Orders; Depth-First vs. Breadth-First; Constructing List of Operators
  • Tree for Mouse; Depth-Limited Search; Iterative Deepening

• February 1, 2024:
  • Solving Equation: Base Cases
  • Recursive Case: + Operator
  • Overall Structure of Solve
  • -, / Operators; opposites; Unary Operators

• February 6, 2024:
  • Algebra: Base Cases, Tree Search
  • solve: Code for +
  • solveit; Patterns; Procedural vs. Declarative

• February 8, 2024:
  • Patterns (Declarative) vs. Code (Procedural); eq vs. equal
  • Java: == Means Same Location in Memory for Reference (Capital letter) Types
  • Matching: Variable Matches Anything, but Consistently

• February 13, 2024:
  • Partial Evaluation

• February 15, 2024:
  • Satisfiability; Implies
  • Rule as Tree Structure; Backchaining

• February 20, 2024:
  • Backchaining as Tree Search; every
  • Conjunctive Normal Form (CNF)
  • SAT, 3SAT. FPGA
  • Predicate Calculus; Unification

• February 22, 2024:
  • Solving Multiple Equations
  • Lisp-like Languages; Finance Combinator
  • Unification

• February 27, 2024: Mr. Varun Kohli, Bloomberg

• February 29, 2024:
  • Notes on Assignment 3, Part 1
  • Example for Assignment 3, Part 1
  • Available, Busy; Quantifiers; Constant
  • Unification Examples; Sound, Complete
  • Resolution Step
  • Example Proof by Resolution

• March 5, 2024:
  • cons, rest, length, append
  • append: copies 1st arg; member; logical true
  • assocl, some, capturing result of some
  • Implication Rule, Tree, Backchaining, CNF
  • SATisfiability, Resolution Step

• March 19, 2024:
  • solve by Pattern Matching; Creation of Objects via Function
  • Woody Bledsoe; Function Specification in Logic

• March 21, 2024:
  • Algebra Patterns; Program Synthesis
  • Position Representations
  • Lat/Long, UTM, City, Movefrom
  • Semantic Network; EMYCIN

• March 26, 2024:
  • EMYCIN versions; Probability and Certainty Factors

• March 28, 2024:
  • Certainty Factors; Fuzzy Logic; Logistic Function
  • Combining Certainties from Rules
  • Combining CFs; Data can Influence Certainty
  • Backchaining: Why and Why Not Questions

• April 2, 2024:
  • Decision Tree; Samuel Checkers Program
  • Low-Pass Filter; Back-Propagation
  • Shannon Coding

• April 4, 2024: Professor Warren Hunt on ACL2
  • Getting Started with ACL2

• April 9, 2024:
  • Ambiguity; n-grams; Markov
  • Corpora; Context-Free Grammar
  • Homographs, Homophones

• April 11, 2024:
  • Chomsky Hierarchy; Context Free = Tree Grammar
  • Finite State Machine; Surface vs. Deep Structure
  • Spectrum of Language Processing

• April 16, 2024:
  • NOTSAME; Lemmatizer

• April 18, 2024:
  • Generating Clojure Code; Multiple Productions
  • Units in Lexicon; Vary-With Questions
  • MapReduce, Hadoop, mapcat
  • MapReduce: Intermediate Representation

Lectures from Fall 2023:

• August 22, 2023:
  • Clojure, Binding, REPL
  • cons, first, rest; Structure Sharing
  • cons, first, rest: Examples
  • Defining Function; Quoted and not Quoted

• August 24, 2023:
  • Symbol vs. Binding; Equations; first, rest; Predicate
  • cons? ; Dynamic Type Checking

• August 28, 2023:
  • filter; length
  • reverse
  • append: Copies First List
  • Set Notation

• August 31, 2023:
  • Association List; map, reduce, short-circuit evaluation
  • Combine Function and Identity; List vs. Tree
  • 2 Kinds of Trees: cons, Expression
  • Hints on Assignment 1

• September 5, 2023:
  • Tree: Breadth b, Depth d, n = b^d; Identity Element
  • Prefix, Infix, Postfix; Preorder, Inorder, Postorder
  • Depth-First Search (DFS)
  • Precedence of Surrounding Operator

• September 7, 2023:
  • Depth-First State Space Search
  • Iterative Deepening; IMplementing Math Rules

• September 12, 2023:
  • Equations: Base Case Examples; Operator Cases
  • Constructing One Result for +
  • Cases for -, /; Unary Operators; Vars in Physics Problem
  • set= ; Finding Equation with 1 Unknown

• September 14, 2023:
  • Algebra: Start with +, Test Incrementally
  • Declarative vs. Procedural
  • copy-tree and subst
  • eq vs. equal; == vs. .equals() in Java

• September 19, 2023:
  • Equation Solving Cases
  • Unary Operators
  • Substitution, Equality, Matching

• September 21, 2023:
  • Partial Evaluation; Interpreter
  • Specializing a Program

• September 26, 2023:
  • Implies; False Implies Anything; Rule Tree
  • Backchaining Example and Tree
  • Conjunctive Normal Form (CNF)
  • SAT Solver: Unit Clause Trick

• September 28, 2023:
  • Available, Busy; Conjunctive Normal Form (CNF)
  • Backchaining Proof Tree; Fact = Rule with No Premises
  • Constant = Function of No Arguments; Unification

• October 3, 2023:
  • Backchaining; Unification
  • Unification; Sound and Complete; Resolution Example

• October 5, 2023:
  • Resolution Step; Conversion to CNF
  • Existentials Introduce Functions; Backchaining
  • Theorem to Program by Constructive Proof

• October 10, 2023:
  • Logic for Navigation: Cartesian
  • r-theta, range-bearing, distance-direction
  • latitude/longitude, UTM, City, movefrom
  • Using Logic; ACL2

• October 12, 2023:
  • cons, first, rest, append, member
  • assocl; set functions
  • map, some, anonymous functions; eq vs. equal
  • match, subst, transform
  • Propositional Logic, Backchaining
  • Resolution; Satisfiability

• October 19, 2023:
  • Equation Solving for Asg. 4; EMYCIN variants

• October 24, 2023:
  • solve using Patterns; Rules with Certainty Factor
  • Fuzzy Sets, AND, OR; Certainty Factor Combination
  • CF Combination; Computing Certainty from Data

• October 26, 2023:
  • Helicopter: movefrom
  • Decision Trees; Low-Pass Filter
  • Learning Certainty Factors

• October 31, 2023:
  • Shannon Coding; Ambiguity
  • Syntactic Ambiguity; Text Corpora
  • Markov Model; Viterbi Algorithm

• November 2, 2023:
  • Running Tmycin; Context Free as Tree Grammar
  • Case; Chomsky Hierarchy; Regular Example
  • Context Free Grammar; Ambiguity

• November 7, 2023:
  • Top-Down Parser; Surface Structure vs. Deep Structure
  • Eliza; Relational Database

• November 9, 2023:
  • Database: Restrictions, Retrieval
  • Lemmatizer; Lexicon; Optional ? in Grammar Rule

• November 14, 2023:
  • Learning CF Values; Top-Down Recursive Descent Parsing
  • El Camino; Relational Database; Units of Measurement
  • Change via Ratio; MapReduce

• November 16, 2023:
  • mapcat; MapReduce
  • MapReduce Example; PageRank
  • Functional Languages

• November 28, 2023: Guest Lecture: Yuecheng Shao, Bloomberg LinkedIn

• November 30, 2023:
  • Physics Option: Variation with ...
  • Map, Reduce, Mapcat
  • Filter; Math for Tree Search
  • Backchaining; Resolution Step
  • Certainty Factor Calculations
  • Context Free; cons

Lectures from Spring 2023:

• January 10, 2023:
  • Using Clojure
  • List Structure; list and cons
  • Structure Sharing

• January 12, 2023:
  • first, rest
  • if: false/nil or true
  • Recursion; Top Level of List
  • Base Answer Depends on Combine; filter example

• January 17, 2023:
  • reverse, append
  • append copies 1st arg; Sets

• January 19, 2023:
  • assocl; map; short-circuit evaluation; every?
  • REPL; Code for every?
  • cons tree vs. algebra tree; nextrow function
  • myeval, tojava

• January 24, 2023:
  • Tree Forms; Tree Algorithm Ordering
  • Search: State, Operator, Path, Loops

• January 26, 2023:
  • Search Answer; Mouse Search Tree
  • Bounded Depth-First Search
  • Equation Solving: Intro

• February 7, 2023:
  • Equation Solving: Base Cases
  • + operator; opposites
  • Unary Operators
  • Special Cases: - and /
  • Special Case: Unary -

• February 9, 2023:
  • map function
  • Solving Physics Problem with 1 Equation
  • Solving Physics Problem with multiple Equations
  • Physics Problem to Code

• February 14, 2023:
  • Finding Physics Equation; Available, Busy
  • Declarative vs. Procedural
  • Matching Example; copy-tree

• February 16, 2023:
  • Test for One Unknown; Pattern Matching
  • copy-tree, subst
  • Java: == Means Same Pointer Value
  • eq vs. equals; Consistency

• February 21, 2023:
  • Matching; Symbolic Math
  • Partial Evaluation

• February 23, 2023:
  • Partial Evaluation; Cannonball; Forms of Logic
  • Invalid, Consistent, Implies

• February 28, 2023:
  • Backchaining
  • Conjunctive Normal Form (CNF); SATisfiability
  • Quantifiers

• March 2, 2023:
  • Solving Multiple Equations
  • Preserving Original Equation Set
  • Proofs in Predicate Calculus
  • Resolution Step, Skolemization

• March 7, 2023: Review for Midterm Exam
  • List Functions
  • Sets, map, fn
  • some, match, sublis
  • Tree Parameters; Transform; Propositional Logic
  • Conjunctive Normal Form (CNF), Satisfiability
  • Resolution
  • Resolution Proof, Backchaining, Unification

• March 21, 2023:
  • Resolution Example
  • Quantifier Elimination, Unification
  • Unification Examples
  • Sound, Complete; Horn Clause Representation

• March 23, 2023:
  • Program Generation from Constructive Proof; xy-data
  • rth-data, rb-data, dd-data
  • lat-long, UTM, City
  • Semantic Network, Forward Chaining

• March 28, 2023:
  • MYCIN variants; Rule with Certainty

• March 30, 2023:
  • Rule with Certainty Factor; Fuzzy Logic
  • Rule Calculations; CF Combination
  • Certainty from Data; Lisp-like Languages

• April 4, 2023: Mr. Varun Kohli, Bloomberg

• April 6, 2023:
  • Yes/No Parameters; Decision Tree
  • Learning Decision Tree; Low-Pass Filter
  • Natural Language: Minimality

• April 11, 2023:
  • Ambiguity; Text Corpora
  • N-grams; Markov Process
  • Chomsky Hierarchy; Context Free: Tree Grammar

• April 13, 2023:
  • Context Free: Tree Grammar; Ambiguity
  • Top-Down Parsing; Deep Structure
  • ELIZA; Relational Database

• April 18, 2023:
  • Relational Database; Grammar Compiler
  • MapReduce

• April 20, 2023:
  • map, reduce, filter, mapcat
  • Depth-First vs. Bread-First, Backchain, Resolution Step
  • Certainty Factor Combination, Bayes Theorem, Low-Pass Filter
  • Context-Free Grammar, Recursive Descent Parser
  • first, rest, cons, reverse, append
  • set-difference, assocl, reduce, some
  • subst, match

Lectures from Fall 2022:

• August 23, 2022:
  • Symbol, Binding, Tree
  • Quotation, List
  • Cons, Structure Sharing
  • Structure Sharing, Changing Binding, Quotation

• August 25, 2022:
  • first, rest, cons
  • Example with first, rest, cons

• August 30, 2022:
  • length() in C; identity; filter operation
  • reverse; append and structure sharing
  • append vs. cons and reverse: Big O
  • binomial and nextrow

• September 1, 2022:
  • Sets; Association List
  • Adding to Association List; empty?
  • cons Tree and Tree Recursion

• September 6, 2022:
  • Short-Circuit Evaluation; REPL; Kinds of Tree
  • Using let in myeval; Translation to Java
  • Precedence and Environment

• September 8, 2022:
  • Flattening Tree; Tree Parameters; Accumulating Path
  • Mouse Search Program

• September 13, 2022:
  • Depth-First, Breadth-First, Iterative Deepening
  • Algebra: Tree Search, Base Cases
  • Algebra: Recursive Case: Move Operand to Left

• September 15, 2022:
  • Equation Solving; Interactive Testing
  • Algebra: Removing Top Operator
  • Code for +; Subtract is Different
  • Solving Problems: One Equation, Multiple Equations

• September 20, 2022:
  • Solving Multiple Equations
  • Available, Busy; Procedural vs. Declarative
  • copy-tree and subst
  • subst; bindings; equality is difficult

• September 22, 2022:
  • Equality: Same Pointer vs. Value
  • eq, eql, equal; Pattern Consistency

• September 27, 2022:
  • Java == vs. .equals(); Lisp eq vs equals
  • Matching Consistency; Pattern vs. Code
  • Symbolic Algebra Packages

• September 29, 2022:
  • gensym; Interpretation; Static/Dynamic
  • Partial Evaluation of power(x,n)
  • Propositional Logic, Predicate Logic, Probability

• October 4, 2022:
  • Interpretation, Model; Implies
  • Horn Clause as Tree; Backchaining
  • Conjunctive Normal Form (CNF); SATisfiability

• October 6, 2022:
  • Backchaining as Tree Proof
  • Unification
  • Unification; Sound and Complete

• October 11, 2022:
  • Resolution
  • Resolution Example
  • Lisp-like Languages; cons, first, rest
  • length, reverse, append, member, assocl, set-difference
  • map, some, member, subst

• Guest Lecture: Mr. Varun Kohli, Bloomberg, October 13, 2022:

• October 20, 2022:
  • Resolution Overview
  • Resolution Step
  • Resolution, Universal Substitution, Skolemization
  • Resolution Example
  • Program Generation from Constructive Proof

• October 25, 2022:
  • Equation Solving; xy-data, rth-data
  • range-bearing, distance-direction, lat-long, UTM
  • movefrom; Inference with Logic
  • ACL2

• October 27, 2022:
  • Bayesian, Emycin Probabilities

• November 1, 2022:
  • Fuzzy Sets; Certainty Factors
  • Certainty Factor Calculations
  • Using Data to Vary Certainty
  • Decision Trees

• November 3, 2022:
  • Low-Pass Filter, Backchaining Tree
  • Overfitting, ROC Curve, Shannon Coding

• November 8, 2022:
  • Ambiguity; Case Frames
  • Corpora, n-grams, Markov
  • Statistical Methods; Context-Free Grammar and Trees

• November 10, 2022:
  • Chomsky Hierarchy; Regular Grammar and Parse Tree
  • Context Free Grammar: Tree Pattern
  • English Examples

• November 15, 2022:
  • Expression to English;
  • Eliza and Parry; Relational Database; Spell Check
  • Compositional Semantics from Parsing

• November 17, 2022:
  • Semantic Grammar; Database Query
  • Top-Down Recursive Descent Parsing; Post-Processing
  • Optional Item with ?; Units, Changes in Physics

• November 29, 2022:
  • MapReduce
  • Master-Mappers-Reducers; PageRank

• December 1, 2022:
  • Review: cons, first, rest, append
  • let, member, assocl, map
  • some; == vs. .equals()
  • Logic: Backchain, Horn Clause, Unification
  • Resolution; Combining certainties

Lectures from Spring 2022:

• January 18, 2022:
  • Binding, Quotation
  • cons and list
  • List of Lists

• January 20, 2022:
  • let; cons
  • structure sharing; first, rest
  • taking apart lists; predicates and if statement
  • number? symbol? cons?
  • recursion; length
  • recursive sum of list

• January 25, 2022:
  • Interactive Testing; Documenting Recursive Function
  • length: Recursive, Tasil-Recursive
  • reverse; append structure sharing
  • append copies 1st argument; binomial

• January 27, 2022:
  • myeval homework; Tail Recursion
  • append; cons a list, then reverse it
  • set functions; binomial: nesting if statement
  • reduce; using and with some to extract answer
  • Tree Recursion: Critical Questions

• February 1, 2022:
  • Identity: Safe Value
  • Short-Circuit Evaluation; First-Child/Next-Sibling
  • cons: List or Tree; Tree-Recursive Function
  • binomial; maxbt; vars, myeval
  • tojava: op precedence vs. neighborhood

• February 8, 2022:
  • first/rest vs. lhs/rhs tree; nested tree recursion
  • BST = Binary Search Tree; Tree Processing Order
  • Equation Solving as Search: Base, Recursive Cases
  • Solve: Making New Equation for +

• February 10, 2022:
  • Algebra by Search
  • Algebra: + Operator
  • Algebra: Other Operators
  • opposites list; Finding Physics Formula
  • Finding Formula; Search in Cave

• February 15, 2022:
  • New Slide: Depth-First Search Code
  • Mouse: Search for Cheese in Maze
  • Bounded DFS; Iterative Deepening
  • Unary; opposites; Code vs. Pattern; copy-tree

• February 17, 2022:
  • Revised slide: Solving Equations by Search
  • Example: Generating Program from Equations
  • Outline: Generating Program from Equations
  • Declarative vs. Procedural; subst
  • == vs. .equals() in Java

• February 22, 2022:
  • Substitution; Tree Equality
  • Short-Circuit Evaluation; Match Consistency
  • Transform: Make New Cons if Children Changed

• February 24, 2022:
  • Symbolic Math Programs; Knuth-Bendix Algorithm
  • Derivative Example; In-line vs Closed Subroutine
  • Specialization of power(x, n) F[tree delta]unction

• March 1, 2022:
  • Partial Evaluation of Code; Cannonball Problem
  • Symbolic Programming Paradigms; Propositional Logic

• March 3, 2022:
  • Horn Clause; Conjunctive Normal Form; Proof Tree
  • backchain, annotated
  • Rule Representation; Fact = Rule with No Premises
  • Trace of backchain
  • Trace of backch
  • Adding Ask-the-User to Backchain; clauses in CNF
  • Satisfiability

• March 8, 2022:
  • Review: first, rest, cons, length, reverse, append
  • member, assocl, intersection, union, set-difference
  • map, set=, doseq
  • some, every?, eq vs. equal
  • Use of let
  • Trees: cons, expressions; tree recursion as depth-first search
  • match, subst, sublis; pattern pair or rewrite rule
  • Logic: Rule Forms, Conjunctive Normal Form (CNF)
  • Backchaining, SAT; Interpretation
  • Resolution in Propositional Calculus
  • match example

• March 22, 2022:
  • Predicate Calculus
  • Unification
  • Unification Algorithm

• March 24, 2022: Guest Lecture by Mr. Varun Kohli, Bloomberg

• March 29, 2022:
  • Predicate Calculus Proof, Unification
  • Unification Process
  • Sound, Complete; Resolution
  • Backchaining; Answer Predicate

• March 31, 2022:
  • Program Specification in Logic
  • Amphion Structure; Lat/Long and UTM
  • movefrom; location data forms
  • distance-direction, city; Helicopter Problem

• April 5, 2022:
  • Semantic Network; Rules with Certainty Factors

• April 7, 2022:
  • Rules, Backchaining, Ask the User
  • Several Kinds of Certainty Factor

• April 12, 2022:
  • Certainty Factor Calculations
  • Combining Certainty from Rules; Certainty from Data

• April 14, 2022:
  • Decision Trees; Low-Pass Filter
  • ROC Curve; Shannon Coding

• April 19, 2022:
  • Ambiguity; Combinatoric Number of N-Grams
  • Markov Process; Context-Free Grammar

• April 21, 2022:
  • Case; Chomsky Hierarchy; Linear Parse Tree of Regular
  • Context Free: Tree/Stack Language
  • Top-Down, Bottom-Up Parsing; Arbitrary Test
  • Transformations: Hard with Grammar, Easy with ATN

• April 26, 2022:
  • Semantic Grammar; Relational Database

• April 28, 2022:
  • Top-Down Recursive Descent Parser

• May 3, 2022:
  • MapReduce
  • MapReduce Plugins; Data Buffering
  • PageRank

• May 5, 2022:
  • Review: cons, first, rest, length, append, set-difference
  • map, reduce, filter, mapcat
  • depth-first search, backchaining, resolution
  • backchaining, constructive proof
  • EMYCIN certainty factors
  • certainty factor combination, low-pass filter, top-down parsing

Lectures from Fall 2021:

• Aug 26, 2021:
  • Binding; cons cell
  • cons: making a new cell; cons adds to front of list
  • first, rest
  • Example: sum of a list

• Aug 31, 2021:
  • Quote, first, rest
  • Box structure, If, short-circuit evaluation
  • Emacs; base case, top-level list processing

• September 2, 2021:
  • append
  • append copies its first arg; Sets
  • association list; hints on assignment

• September 7, 2021:
  • Mapping; Short-Circuit Evaluation; Identity
  • Read-Eval-Print Loop (REPL); Binary Tree
  • Notes on Assignment

• September 9, 2021:
  • Binary Search Tree; cons constructs a list backwards
  • State Space Search: Mouse

• September 14, 2021:
  • Constructing Path of State Space Search
  • Equation Solving: Base Cases
  • Removing a + Operator

• September 16, 2021:
  • Symbolic Algebraic Manipulation; Base Cases
  • + Operator; opposites list
  • Kinds of Operators; - Operator
  • solveit: Finding the Right Formula

• September 21, 2021:
  • Finding Physics Equation
  • some function; Data Flow
  • Introduction to Patterns

• September 23, 2021:
  • Declarative vs. Procedural; Code vs. Pattern
  • copy-tree and subst
  • Pattern Example; eq and Java ==
  • == with Integer: Bug Hazard

• September 28, 2021:
  • Substitution; eq versus equal
  • Matching Consistency; SIGSAM; Mathematica

• September 30, 2021:
  • In-Line or Open Subroutine; Partial Evaluation
  • Partial Evaluation Example: power
  • Knowledge Representation: Intro

• October 5, 2021:
  • A → B ≡ ¬ A ∨ B; Backchain Rule as Tree
  • Backchaining as Tree Search

• October 7, 2021:
  • Filtering Equations
  • Horn Clause; CNF = Conjunctive Normal Form
  • SAT Solver; Predicate Calculus

• October 12, 2021:
  • Lisp-like Languages; Financial Instruments
  • Quantifiers; Unification and Substitution
  • Unification: both directions

• October 14, 2021: Guest Lecture by Mr. Varun Kohli, Bloomberg

• October 21, 2021:
  • Unification
  • Sound and Complete; Conjunctive Normal Form
  • Resolution Step, Example
  • Resolution Example

• October 26, 2021:
  • Converting Predicate Calculus to CNF
  • Back-Chaining; Constructive Proof of Program
  • Navigation Data Forms
  • Combinatoric Explosion

• October 28, 2021:
  • Proving Program Goal by Backchaining
  • Logic Representation; ACL2
  • Proof of Floating Divide; Rules with Probabilities

• November 2, 2021:
  • Certainty Factors in Rules

• November 4, 2021:
  • Certainty Factors
  • Combining Certainty Factors; CF from Data

• November 9, 2021:
  • Decision Trees; Low-pass Filter
  • ROC Curve; Shannon Coding

• November 11, 2021:
  • Natural Language: Introduction
  • Filling In Meaning; Corpora
  • n-grams; Markov

• November 16, 2021:
  • Context Free as Tree Grammar; Chomsky Hierarchy
  • Recursive language; Issues in Natural Language

• November 18, 2021:
  • Natural Language Access to Database
  • Lexicon Coding

• November 23, 2021:
  • Relational Database; Restaurant Assignment
  • Speedup is Hard to Get with Conventional Programming

• November 30, 2021:
  • MapReduce
  • Master and Workers; PageRank

• December 2, 2021:
  • Natural Language Grammar: Order Matters
  • Review: map, reduce, filter
  • Review: Counting conses; every, some
  • Review: let, mapcat, Depth-first Search
  • Review: Backchaining, Conjunctive Normal Form
  • Review: Resolution
  • Review: Emycin Certainty Calculations; first, rest, cons
  • Review: List Functions
  • Review: Pattern Match; SAT Solver

Lectures from Fall 2020:

• January 19, 2021:
  • Quotation, Binding
  • Lists, Structure Sharing
  • First, Rest

• January 21, 2021:
  • cons, first, rest
  • How value is returned
  • Recursion on a List
  • Hints on Pascal's Triangle

• January 26, 2021:
  • reverse and append
  • append can cause O(n^2) garbage
  • Set and Alist
  • some; hints on assignment 1

• January 28, 2021:
  • let, short-circuit evaluation
  • some, tree recursion
  • Assignment 1 Hints
  • tojava hints

• February 2, 2021:
  • Notes on Assignment 1
  • Binary Search Tree
  • Tree Search

• February 4, 2021:
  • State Space Search; Mouse in Maze
  • Algebra: Getting Started

• February 9, 2021:
  • Iterative Deepening
  • Algebra as State Space Search
  • Code for One Operator for Plus
  • Difference, Unary Operators, Opposites

• February 11, 2021:
  • Algebra Example
  • Solving Multiple Equations
  • Multiple Equations Example
  • Eliminating Unused Equations

• February 25, 2021:
  • Solving a Physics Problem
  • Pattern Matching: copy-tree
  • Substitution: subst

• March 2, 2021:
  • == vs .equals()
  • Pattern Matching

• March 4, 2021:
  • In-line Subroutine; Interpretation
  • Partial Evaluation Example
  • Partial Evaluation: Removing Interpretation

• March 9, 2021:
  • Interpretation, Model, Implies
  • Conjunctive Normal Form, Back-chaining

• March 23, 2021:
  • Backchaining; Conjunctive Normal Form (CNF)
  • Unification; Sound and Complete
  • Resolution Example

• March 25, 2021:
  • Constructive Proof
  • Navigation Coordinates
  • Knowledge Rwepresentation

• March 30, 2021:
  • ACL2 and Hardware Proofs

• April 1, 2021:
  • Notes on Deduction Assignment; EMYCIN
  • Certainty Factors in EMYCIN
  • .2 Threshold; Certainty Factor Combination

• April 6, 2021:
  • Certainty Factor Calculations
  • Certainty Factor: Function of Data

• April 8, 2021:
  • Decision Tree; Neural Net
  • Low-Pass Filter and Machine Learning
  • Learning Certainty Factors

• April 13, 2021:
  • Certainty Factor Calculations
  • ROC Curve; Overfitting of Training Set
  • Information Theory; Ambiguity

• April 15, 2021:
  • Deep Structure; Case Frames
  • n-Grams; Hidden Markov
  • Context Free: Pattern for a Piece of Tree

• April 20, 2021:
  • Language Classes; Regular and Context Free
  • Context Free; Need to Back Up
  • Augmented Transition Network

• April 22, 2021:
  • ELIZA; Natural Language Access to Database
  • Relational Database; Edit Distance
  • Abbreviated Natural Language

• April 27, 2021:
  • Top-Down Parsing with Failure, Backup
  • Multiple Productions, Database Access

• April 29, 2021:
  • Notes on Natural Language Assignment
  • MapReduce and Hadoop

• May 4, 2021:
  • Need for Parallelism
  • Mapreduce Overview

• May 6, 2021:
  • MapReduce
  • MapReduce Implementation; PageRank
  • Intermediate Form of Data for PageRank

Lectures from Fall 2020:

• August 28, 2020:
  • Read-Eval-Print Loop; Quotation

• September 1, 2020:
  • List Representation
  • rest; if statement
  • lengthfunction
  • Clojure examples

• September 3, 2020:
  • Recursion Stack Frames, Reverse
  • Append; Set functions
  • Association List; binomial and tree functions

• September 8, 2020:
  • append; let
  • map, reduce, using and with map
  • short-circuit evaluation
  • expression trees; precedence

• September 10, 2020:
  • Notes on Assignment 1
  • Notes on Assignment 1
  • Tree Recursion
  • Tree Recursion; Algebra

• September 15, 2020:
  • Tree Search
  • some; Answer for State Space Search
  • Iterative Deepening

• September 17, 2020:
  • Equation Solving Structure
  • Equations: Base Cases, Recursive Case
  • Asymmetric and Unary Operators
  • Difference and Divide

• September 22, 2020:
  • Algebra; Finding Physics Equation
  • Data Flow between Equations
  • Available/Busy Examples
  • Declarative vs. Procedural
  • copytree: basis of subst

• September 24, 2020:
  • Symbolic Programming Paradigms; subst
  • == vs. .equals()
  • == vs. .equals(), eq vs. equal

• September 29, 2020:
  • Notes on Algebra Homework
  • Algebra Homework
  • From Algebra to Physics Problems

• October 1, 2020:
  • Confluence; In-line vs. Closed Subroutines
  • Partial Evaluation

• October 6, 2020:
  • Functional Languages; Cannonball problem
  • Logic and Rules

• October 8, 2020: Guest Lecture by Mr. Varun Kohli, Bloomberg
  • Presentation Slides

• October 13, 2020:
  • Propositional Logic
  • Propositional Proof Methods
  • Backchaining in Propositional Logic
  • Resolution in Propositional Logic

• October 15, 2020: Review for Midterm
  • cons, first, rest, length
  • reverse, let, append, member, assocl
  • set functions
  • map, some, every, equal
  • trees; pattern matching
  • rewrite rule, propositional logic, CNF, interpretation
  • backchaining, SAT
  • resolution for propositional logic

• October 20, 2020: Midterm Exam

• October 22, 2020:
  • Horn clause
  • Unification
  • Resolution in Propositional Logic

• October 27, 2020:
  • Navigation Representztions
  • UTM = Universal Transverse Mercator

• October 29, 2020:
  • ACL2; Expert Systems

• November 3, 2020:
  • Deductive Synthesis Assignment
  • Introduction to Certainty Factors
  • CF calculations: prescan, AND, OR

• November 5, 2020:
  • Antecedent (lhs) certainty factor combination
  • Rule certainty factor and combination
  • Using data values to compute certainty factor

• November 10, 2020:
  • Explanation; Decision Trees
  • Weight adjustment; Low-Pass Filter
  • Over-fitting; ROC Curve

• November 12, 2020:
  • Shannon coding; Ambiguity
  • Deep Structure
  • Language Corpora; N-grams

• November 17, 2020:
  • Statistical Natural Language Processing
  • Regular and Context Free Grammars
  • Garden Path Sentences

• November 19, 2020:
  • Top-down Parsing, ATN
  • Difficulties in Natural Language
  • Psychiatrist Programs

• November 24, 2020:
  • Fixing NL Errors
  • Natural Language Grammar; Physics

• December 1, 2020:
  • MapReduce
  • PageRank

• December 3, 2020: Review
  • Review A
  • Review B
  • Review C
  • Review D
  • Review E
  • Review F

Lectures from Spring 2020:

• March 31, 2020:

• April 2, 2020:
  • Certainty Factor Computations
  • Negating Certainty Factor
  • Fuzzy Logic
  • Combining Certainty Factors
  • Associateve and Commutative
  • Duplicate Rules

• April 7, 2020:
  • Why, Whynot Questions
  • Decision Tree Induction

• April 9, 2020:
  • Shannon Coding, Semantic Network
  • Prepositions: Idiosyncratic, Ambiguous
  • Chomsky: Deep Structure vs. Surface Structure
  • Type, Token, n-gram

• April 14, 2020:
  • Language Brevity, Ambiguity
  • Hidden Markov
  • Chomsky Language Hierarchy
  • Surface Structure vs. Deep Structure

• April 16, 2020:
  • Context-Free Languages
  • Regular Languages
  • Context-Free Examples
  • Top-Down and CKY (Cocke-Kasami-Younger) Parsers
  • Arbitrary Tests and Transformations in Augmented Transition Network (ATN)

• April 21, 2020:
  • Relational Database
  • Left Recursion

• April 23, 2020:
  • Top-Down Parsing
  • Natural Language Access to Database

• April 28, 2020:
  • Natural language: quantifiers and negation are problematic
  • Symbolic Finance
  • Symbolic representation of laws of a domain

• April 30, 2020:
  • MapReduce
  • Parallelism: Many CPUs vs. One Fast CPU

• May 5, 2020:
  • MapReduce
  • MapReduce Implementation
  • PageRank

• May 7, 2020:
  • Review A
  • Review B
  • Review C
  • Review D