Defining AI — what are we actually talking about?

import random

SIZE, STEPS, TRIALS = 5, 60, 400
MOVES = {'N': (-1, 0), 'S': (1, 0), 'E': (0, 1), 'W': (0, -1)}

def new_room(seed):
    rng = random.Random(seed)
    dirt = {(r, c) for r in range(SIZE) for c in range(SIZE) if rng.random() < 0.4}
    dirt.discard((0, 0))
    return dirt, rng

def percept(pos, dirt):
    """Everything the agent is allowed to know: where it is, and whether
    THIS square is dirty. It cannot see the rest of the room."""
    return pos, pos in dirt

record('room_size', f'{SIZE}x{SIZE}')
record('steps', STEPS)
record('trials', TRIALS)
record('avg_dirt', round(sum(len(new_room(s)[0]) for s in range(TRIALS)) / TRIALS, 1))

def random_agent(pos, dirty, memory, rng):
    """Ignores the percept completely. It is an agent — it acts — but it does
    not perceive, so it sucks at empty squares and drives past dirty ones."""
    return rng.choice(['suck'] + list(MOVES))

def reflex_agent(pos, dirty, memory, rng):
    """The whole difference from Random is one `if`: it LOOKS at the square it
    is standing on. No memory, though — it cannot tell a square it has already
    done from one it has not."""
    if dirty: return 'suck'
    return rng.choice(list(MOVES))

def systematic_agent(pos, dirty, memory, rng):
    """Model-based: it remembers where it has been, and walks the room in
    boustrophedon order — along a row, down, back along the next."""
    if dirty: return 'suck'
    r, c = pos
    memory.add(pos)
    going_east = (r % 2 == 0)
    ahead = (r, c + 1) if going_east else (r, c - 1)
    if 0 <= ahead[1] < SIZE: return 'E' if going_east else 'W'
    return 'S' if r + 1 < SIZE else ('W' if c > 0 else 'N')

def humanish_agent(pos, dirty, memory, rng):
    """Written to look like a person doing the job: doubles back to check its
    own work, and now and then does nothing at all."""
    if dirty: return 'suck'
    if rng.random() < 0.25: return 'wait'          # a pause
    if memory and rng.random() < 0.35:             # go back and check
        return rng.choice(list(MOVES))
    memory.add(pos)
    return rng.choice(list(MOVES))

AGENTS = [
    ('Random', random_agent),
    ('Reflex', reflex_agent),
    ('Remembers', systematic_agent),
    ('Human-like', humanish_agent),
]
record('n_agents', len(AGENTS))

MOVE_COST = 0.6

def run(agent, seed):
    dirt, rng = new_room(seed)
    started = len(dirt)
    pos, memory, moves = (0, 0), set(), 0
    for _ in range(STEPS):
        where, dirty = percept(pos, dirt)
        action = agent(where, dirty, memory, rng)
        if action == 'suck':
            dirt.discard(pos)
        elif action in MOVES:
            dr, dc = MOVES[action]
            nxt = (pos[0] + dr, pos[1] + dc)
            if 0 <= nxt[0] < SIZE and 0 <= nxt[1] < SIZE:
                pos = nxt
            moves += 1
    cleaned = started - len(dirt)
    return cleaned, moves

scores = {}
for name, agent in AGENTS:
    runs = [run(agent, s) for s in range(TRIALS)]
    cleaned = sum(c for c, _ in runs) / TRIALS
    moves = sum(m for _, m in runs) / TRIALS
    scores[name] = {
        'cleaned': round(cleaned, 1),
        'moves': round(moves, 1),
        'net': round(cleaned - MOVE_COST * moves, 1),
    }

for name, s in scores.items():
    print(f"{name:12} cleaned {s['cleaned']:5}   moves {s['moves']:5}   net {s['net']:6}")

record('move_cost', MOVE_COST)
for name, s in scores.items():
    key = name.lower().replace('-', '_')
    record(f'{key}_cleaned', s['cleaned'])
    record(f'{key}_moves', s['moves'])
    record(f'{key}_net', s['net'])

names = [n for n, _ in AGENTS]
cleaned = [scores[n]['cleaned'] for n in names]
net = [scores[n]['net'] for n in names]

winner_clean = max(names, key=lambda n: scores[n]['cleaned'])
winner_net = max(names, key=lambda n: scores[n]['net'])
record('winner_cleaned', winner_clean)
record('winner_net', winner_net)
record('scorecard_changes_winner', 'yes' if winner_clean != winner_net else 'no')

def plot_cleaned(ax):
    bars = ax.bar(names, cleaned, color=['#9aa1ab', '#9aa1ab', '#ee785b', '#9aa1ab'])
    for b, v in zip(bars, cleaned):
        ax.text(b.get_x() + b.get_width() / 2, v + 0.15, f'{v}', ha='center', fontsize=11)
    ax.set_ylabel('squares cleaned')
    ax.set_ylim(0, max(cleaned) * 1.25)
    ax.spines[['top', 'right']].set_visible(False)

save_fig('who-cleaned-most', plot_cleaned, figsize=(7, 4))

def plot_two_scorecards(ax):
    x = range(len(names))
    w = 0.38
    ax.bar([i - w / 2 for i in x], cleaned, w, label='squares cleaned', color='#9aa1ab')
    ax.bar([i + w / 2 for i in x], net, w, label='cleaned minus electricity', color='#ee785b')
    ax.axhline(0, color='#6b7280', linewidth=0.8)
    for i, (c, n) in enumerate(zip(cleaned, net)):
        ax.text(i - w / 2, c + 0.2, f'{c}', ha='center', fontsize=10)
        ax.text(i + w / 2, n + (0.2 if n >= 0 else -0.9), f'{n}', ha='center', fontsize=10)
    ax.set_xticks(list(x)); ax.set_xticklabels(names)
    ax.set_ylabel('score')
    ax.legend(frameon=False, fontsize=10)
    ax.spines[['top', 'right']].set_visible(False)

save_fig('two-scorecards', plot_two_scorecards, figsize=(7.6, 4.2))
print('best at cleaning:', winner_clean)
print('best once movement costs something:', winner_net)

definitions = ['Thinking\nlike a human', 'Thinking\nrationally',
               'Acting\nlike a human', 'Acting\nrationally']
scoreable = [0, 0, 0, 1]
record('definitions', len(definitions))
record('definitions_scored', sum(scoreable))

def plot_scoreable(ax):
    ax.bar(definitions, [1, 1, 1, 1], color='#eceef1')
    ax.bar(definitions, scoreable, color='#ee785b')
    for i, s in enumerate(scoreable):
        ax.text(i, 0.5, 'a number' if s else 'no test', ha='center', va='center',
                fontsize=10, color='#ffffff' if s else '#6b7280')
    ax.set_yticks([])
    ax.spines[['top', 'right', 'left']].set_visible(False)

save_fig('what-can-be-scored', plot_scoreable, figsize=(7.6, 3.4))