Skip to main content

A Brief History of AI and Robotics

Overview​

To understand Physical AI, it's essential to appreciate the historical journey of artificial intelligence and robotics. This section provides a brief history, tracing the evolution of thought from the early days of symbolic AI, with its focus on abstract reasoning, to the behavior-based robotics movement that re-introduced the importance of the physical body and its interaction with the world.

Detailed Explanation​

The Age of Symbolic AI: The "Thinking Machine"​

The birth of artificial intelligence as a field is often traced back to the Dartmouth Workshop in 1956. The dominant paradigm in these early days was Symbolic AI, also known as "Good Old-Fashioned AI" (GOFAI). The central belief of symbolic AI was that intelligence could be achieved by creating a system that manipulated symbols according to a set of formal rules.

One of the earliest successes of this approach was the Logic Theory Machine (Newell & Simon, 1956), a program that could prove mathematical theorems. This was followed by the General Problem Solver (GPS), which, as its name suggests, was designed to solve a wide range of formalized problems. These systems were impressive in their ability to reason logically and play games like chess, leading to a great deal of optimism about the future of AI.

However, symbolic AI had a fundamental weakness: it was disembodied. The systems existed purely in the abstract world of computer memory, with no connection to the messy, unpredictable reality of the physical world. This led to a critical stumbling block known as the "frame problem".

The Frame Problem: A Crisis for Symbolic AI​

The frame problem, in simple terms, is the challenge of representing and updating the state of a dynamic world. When a robot performs an action, like picking up a block, how does it know what has changed and what has stayed the same? The robot's arm has moved, the block has moved, but the color of the walls, the position of the sun, and the price of tea in China have (probably) not.

For a symbolic AI system to work, it would need an enormous database of facts about the world and a set of rules to update them. This proved to be computationally intractable. The real world is just too complex to be modeled with a finite set of symbols and rules. This limitation of symbolic AI paved the way for a new approach.

The Rise of Behavior-Based Robotics: Intelligence from the Ground Up​

In the 1980s, a group of researchers, most notably Rodney Brooks at MIT, began to challenge the symbolic AI paradigm. Brooks argued that intelligence didn't need to be a top-down process of reasoning and planning. Instead, it could be built from the "ground up" through a set of simple, reactive behaviors.

This approach, known as Behavior-Based Robotics, focused on building robots that could survive and function in the real world. Brooks's most famous work, "Intelligence without representation" (1991), became a manifesto for this new movement. The idea was to create robots with a layered set of simple behaviors. For example, a robot might have a low-level behavior to avoid obstacles, a higher-level behavior to wander around, and an even higher-level behavior to look for interesting objects.

These behaviors were directly coupled to the robot's sensors and actuators, creating a tight perception-action loop. There was no central "brain" or world model. Intelligence, in this view, was an emergent property of the interaction between the robot's behaviors and the structure of the environment.

This shift from disembodied, symbolic reasoning to embodied, behavior-based robotics was a critical step in the evolution of Physical AI. It brought the focus back to the body and the environment, setting the stage for the modern study of intelligent physical agents.

References​

  • Brooks, R. A. (1991). Intelligence without representation. Artificial intelligence, 47(1-3), 139-159.
  • Newell, A., & Simon, H. A. (1956). The logic theory machine—A complex information processing system. IRE Transactions on information theory, 2(3), 61-79.

Hands-on Exercise: Symbolic vs. Behavior-Based Robot Control​

This exercise demonstrates the fundamental difference between a symbolic (planner-based) and a behavior-based approach to a simple robot navigation task.

The Scenario​

Imagine a simple robot in a 1D world (a line). The world is 10 units long. The robot starts at position 0 and needs to get to position 9. There is an obstacle at position 5.

[R, , , , , O, , , , G] (R=Robot, O=Obstacle, G=Goal)

Approach 1: The Symbolic Planner​

A symbolic AI would first create a complete plan to get from start to goal.

# Symbolic (Planner-Based) Approach
world = ['R', ' ', ' ', ' ', ' ', 'O', ' ', ' ', ' ', 'G']
robot_pos = 0
goal_pos = 9
obstacle_pos = 5

# The planner generates a sequence of moves
plan = [1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # A suboptimal plan to go around the obstacle

print("Executing Symbolic Plan...")
for move in plan:
    robot_pos += move
    print(f"Robot moved to {robot_pos}")
    if robot_pos == goal_pos:
        print("Goal reached!")
        break
    if robot_pos == obstacle_pos:
        print("Error: Plan did not account for obstacle. Collision!")
        break

Discussion: The symbolic approach relies on a pre-computed plan. If the world is not perfectly known (e.g., the obstacle's position is unknown), the plan will fail.

Approach 2: The Behavior-Based System​

A behavior-based AI would use a set of simple, reactive rules (behaviors).

# Behavior-Based Approach
world = ['R', ' ', ' ', ' ', ' ', 'O', ' ', ' ', ' ', 'G']
robot_pos = 0
goal_pos = 9
obstacle_pos = 5

print("\nExecuting Behavior-Based System...")
for _ in range(20): # Limit steps to prevent infinite loops
    # --- Behavior 1: If at goal, stop ---
    if robot_pos == goal_pos:
        print("Behavior: At Goal. Stopping.")
        break

    # --- Behavior 2: If obstacle ahead, move away ---
    if robot_pos + 1 == obstacle_pos:
        print("Behavior: Obstacle Ahead. Moving away.")
        robot_pos -= 1
        print(f"Robot moved to {robot_pos}")
        continue

    # --- Behavior 3 (Default): Move towards goal ---
    print("Behavior: Moving towards goal.")
    robot_pos += 1
    print(f"Robot moved to {robot_pos}")

Discussion: The behavior-based system doesn't have a grand plan. It just reacts to its immediate environment based on a prioritized set of behaviors. This makes it more robust to uncertainty. You can move the obstacle in the world array and the behavior-based system will still likely find a solution, while the symbolic plan would fail.

Experiment​

Modify the obstacle_pos in both scripts. Run them again and observe how each approach handles the change.