🤖 Artificial Intelligence Fundamentals

A comprehensive introduction to AI concepts, history, and applications. Learn about intelligent agents, search algorithms, knowledge representation, and the foundations of modern AI systems.

📚 Course Modules

• Introduction to AI: History, applications, and AI types
• Intelligent Agents: Agent architectures and environments
• Search Algorithms: BFS, DFS, A*, heuristic search
• Knowledge Representation: Logic, ontologies, semantic networks
• Planning & Reasoning: Automated planning systems
• Game Theory: Minimax, alpha-beta pruning
• Constraint Satisfaction: CSPs and backtracking

💻 Python Implementation Example

# A* Search Algorithm Implementation
import heapq

class Node:
    def __init__(self, state, parent=None, g=0, h=0):
        self.state = state
        self.parent = parent
        self.g = g  # Cost from start
        self.h = h  # Heuristic to goal
        self.f = g + h
    
    def __lt__(self, other):
        return self.f < other.f

def astar_search(start, goal, neighbors_func, heuristic):
    open_set = [Node(start, g=0, h=heuristic(start, goal))]
    closed_set = set()
    
    while open_set:
        current = heapq.heappop(open_set)
        
        if current.state == goal:
            path = []
            while current:
                path.append(current.state)
                current = current.parent
            return path[::-1]
        
        closed_set.add(current.state)
        
        for neighbor, cost in neighbors_func(current.state):
            if neighbor in closed_set:
                continue
            
            g = current.g + cost
            h = heuristic(neighbor, goal)
            node = Node(neighbor, current, g, h)
            heapq.heappush(open_set, node)
    
    return None

def manhattan_distance(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

# Usage
start = (0, 0)
goal = (5, 5)
result = astar_search(start, goal, get_neighbors, manhattan_distance)
print(f"Path found: {result}")