2nd/10_Wiki/Topics/AI_and_ML/Finite-State-Machines-FSM.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-finite-state-machines-fsm	Finite State Machines (FSM)	10_Wiki/Topics	verified	self	FSM state machine statechart XState hierarchical FSM behavior tree	none	A	0.98	applied	computer-science fsm state-machine xstate statechart game-ai control		2026-05-10	pending	language framework TypeScript / Python XState / Stateless / SCXML

Finite State Machines (FSM)

매 한 줄

"매 finite state + 매 transition (event-driven)". 매 oldest CS abstraction. 매 modern: 매 statechart (Harel), 매 XState, 매 behavior tree (game). 매 game AI, 매 UI workflow, 매 protocol, 매 LLM agent의 control 의 사용.

매 핵심

매 component

• State: 매 finite set.
• Initial state.
• Transition: state × event → state.
• Guard: 매 transition condition.
• Action: 매 transition / entry / exit 의 effect.

매 variant

• DFA: 매 deterministic.
• NFA: 매 non-deterministic.
• Statechart (Harel): 매 nested + parallel.
• HSM (hierarchical).
• Behavior tree: 매 game alternative.

매 응용

1. Game AI: 매 enemy behavior.
2. UI: 매 form workflow.
3. Protocol: 매 TCP, BLE.
4. Compiler: 매 lexer.
5. LLM agent: 매 conversation flow.
6. Saga: 매 distributed transaction.

💻 패턴

Simple FSM (TypeScript)

type State = 'idle' | 'fetching' | 'success' | 'error';
type Event = { type: 'FETCH' } | { type: 'RESOLVE'; data: any } | { type: 'REJECT' } | { type: 'RESET' };

function transition(state: State, event: Event): State {
  switch (state) {
    case 'idle':
      if (event.type === 'FETCH') return 'fetching';
      break;
    case 'fetching':
      if (event.type === 'RESOLVE') return 'success';
      if (event.type === 'REJECT') return 'error';
      break;
    case 'success':
    case 'error':
      if (event.type === 'RESET') return 'idle';
      break;
  }
  return state;
}

XState (declarative)

import { createMachine, assign, interpret } from 'xstate';

const fetchMachine = createMachine({
  id: 'fetch',
  initial: 'idle',
  context: { data: null, error: null },
  states: {
    idle: {
      on: { FETCH: 'loading' },
    },
    loading: {
      invoke: {
        src: 'fetchData',
        onDone: { target: 'success', actions: assign({ data: (_, e) => e.data }) },
        onError: { target: 'failure', actions: assign({ error: (_, e) => e.data }) },
      },
    },
    success: {
      on: { REFRESH: 'loading' },
    },
    failure: {
      on: { RETRY: 'loading' },
    },
  },
});

const service = interpret(fetchMachine).start();
service.send({ type: 'FETCH' });

Hierarchical (statechart)

const trafficLight = createMachine({
  initial: 'red',
  states: {
    red: {
      after: { 5000: 'green' },
    },
    green: {
      after: { 5000: 'yellow' },
    },
    yellow: {
      initial: 'flashing',
      states: {
        flashing: {},
        steady: {},
      },
      after: { 2000: 'red' },
    },
  },
});

Game AI FSM (Python)

class EnemyAI:
    def __init__(self):
        self.state = 'patrol'
    
    def update(self, world):
        if self.state == 'patrol':
            if world.player_visible(self): self.state = 'chase'
            else: self.patrol_move()
        elif self.state == 'chase':
            if world.in_attack_range(self): self.state = 'attack'
            elif not world.player_visible(self): self.state = 'search'
            else: self.chase_player()
        elif self.state == 'attack':
            if not world.in_attack_range(self): self.state = 'chase'
            else: self.attack()
        elif self.state == 'search':
            if world.search_timeout(): self.state = 'patrol'
            elif world.player_visible(self): self.state = 'chase'
            else: self.search_area()

Behavior tree (alternative)

class Node:
    def tick(self): raise NotImplementedError

class Sequence(Node):
    def __init__(self, *children): self.children = children
    def tick(self):
        for c in self.children:
            if c.tick() != 'success': return 'fail'
        return 'success'

class Selector(Node):
    def __init__(self, *children): self.children = children
    def tick(self):
        for c in self.children:
            if c.tick() == 'success': return 'success'
        return 'fail'

ai = Selector(
    Sequence(IsPlayerVisible(), AttackPlayer()),
    PatrolArea(),
)

Lexer (FSM)

def lex(input):
    state = 'start'
    tokens = []
    buf = ''
    for ch in input + ' ':
        if state == 'start':
            if ch.isalpha(): state, buf = 'ident', ch
            elif ch.isdigit(): state, buf = 'number', ch
        elif state == 'ident':
            if ch.isalnum(): buf += ch
            else: tokens.append(('IDENT', buf)); state, buf = 'start', ''
        elif state == 'number':
            if ch.isdigit(): buf += ch
            else: tokens.append(('NUMBER', int(buf))); state, buf = 'start', ''
    return tokens

LLM agent state machine

const agent = createMachine({
  initial: 'understanding',
  states: {
    understanding: {
      on: { CLEAR: 'planning', NEEDS_INFO: 'asking' },
    },
    asking: {
      on: { ANSWERED: 'understanding' },
    },
    planning: {
      on: { READY: 'executing' },
    },
    executing: {
      on: { COMPLETE: 'reflecting', NEED_REPLAN: 'planning', BLOCKED: 'asking' },
    },
    reflecting: {
      on: { OK: 'done', RETRY: 'planning' },
    },
    done: { type: 'final' },
  },
});

Saga (distributed transaction)

const orderSaga = createMachine({
  initial: 'reserving',
  context: { compensations: [] },
  states: {
    reserving: {
      invoke: {
        src: 'reserveInventory',
        onDone: { target: 'charging', actions: 'pushCompensation' },
        onError: 'failed',
      },
    },
    charging: {
      invoke: {
        src: 'chargeCard',
        onDone: 'completed',
        onError: { target: 'compensating' },
      },
    },
    compensating: {
      invoke: {
        src: 'runCompensations',
        onDone: 'failed',
      },
    },
    completed: { type: 'final' },
    failed: { type: 'final' },
  },
});

State persistence

const persistedState = JSON.stringify(service.getSnapshot());
localStorage.setItem('appState', persistedState);

// 매 restore
const restored = JSON.parse(localStorage.getItem('appState')!);
const restoredService = interpret(machine, { state: restored }).start();

Visualizer (XState Inspector)

import { inspect } from '@xstate/inspect';
inspect({ url: 'https://stately.ai/viz?inspect', iframe: false });
const service = interpret(machine, { devTools: true }).start();

Test (path coverage)

import { createModel } from '@xstate/test';
const testModel = createModel(machine).withEvents({
  FETCH: { exec: async () => fireEvent.click(fetchBtn) },
  RESOLVE: { ... },
});
testModel.getSimplePathPlans().forEach(plan => {
  describe(plan.description, () => {
    plan.paths.forEach(path => {
      it(path.description, async () => {
        await path.test(/* page */);
      });
    });
  });
});

매 결정 기준

상황	Approach
UI workflow	XState
Game AI	FSM or Behavior Tree
Lexer / parser	DFA
Distributed	Saga (XState compatible)
LLM agent	Statechart
Tiny linear	Plain switch

기본값: 매 XState (TS) + 매 statechart (hierarchical) + 매 visualizer + 매 model-based test.

🔗 Graph

• 변형: Statechart · Hierarchical-FSM · Behavior-Tree
• Adjacent: Exhaustiveness-Checking · Encapsulation-of-Domain-Invariants · Event-Driven-Architecture

🤖 LLM 활용

언제: 매 multi-step workflow. 매 game AI. 매 protocol. 언제 X: 매 1-2 state.

❌ 안티패턴

• Boolean explosion: 매 N flags 의 implicit FSM.
• Hidden FSM: 매 spaghetti.
• No exhaustive transition: 매 invalid state.
• State + global side effect: 매 untestable.
• Reinvent XState: 매 use library.

🧪 검증 / 중복

• Verified (Harel statecharts 1987, XState docs).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-26	FSM auto
2026-05-08	Phase 1
2026-05-10	Manual cleanup — FSM + 매 XState / hierarchical / game / saga / LLM agent code