Lecture 02: 형식 언어 및 정규 언어

Kwang-Man Kokkmam@sangji.ac.kr, compiler.sangji.ac.kr

Department of Computer Engineering

Sang Ji University

2019

언어(Language)

잘 정의된 언어(Well-defined Language)

– 문장들의 집합

– 알파벳(alphabet)

알파벳 T : 심볼들의 유한 집합

– T1 = {ㄱ, ㄴ, ㄷ, ... , ㅎ, ㅏ, ㅑ, ... , ㅡ,ㅣ}

– T2 = {A, B, C, ... , Z, a, b, c, …, z}

스트링(string)

– T에 속하는 하나 이상의 심볼들을 연결한 것.

– T = { a, b}

• a, b, aa, ab, ba, bb, aaa, ...

스트링 길이(Length)

– 스트링을 이루는 심볼들의 개수

– ω의 길이, |ω|

스트링 접속(concatenation)

– 스트링을 연속으로 연결한 것.

– u, v : u = a1a2 ... an, v = b1b2 ... bm

• u . v = a1a2 ... anb1b2 ... bm

• u를 prefix, v를 suffix라 함

• 접속 연산은 교환 법칙을 만족하지 않음

• |uv| = |u| + |v|

Empty String

– 스트링의 길이가 영(zero)

– ε(epsilon)으로 표기

• uε = u = εu

• uεv = uv

– empty 스트링을 λ(lambda)로 표시

T*

– Empty 스트링을 포함하여 T에 속하는 심볼로 이루어질 수

있는 모든 스트링의 집합

– T-start

T+

– T*에서 Empty 스트링을 제외한 모든 스트링의 집합.

– T+ = T* - {ε}

– T-dagger

T = {0}

– T* = {ε, 0, 00, 000, ...}

– T+ = { 0, 00, 000, ...}

T = {a, b}

– T* = {ε, a, b, aa, ab, ba, bb, aaa, aab, ... }

– T+ = {a, b, aa, ab, ba, bb, aaa, aab, ...}

– T*는 알파벳 T에 속하는 심볼로부터 만들 수 있는 스트

링의 전체 집합(universal set)

언어(language)

– 알파벳 T에 대해, 언어 L 은 T*의 부분 집합

• T*중에 속하는 스트링 중에 특정한 형태만 모아 놓은 집

합

– 유한 언어 : 스트링의 개수가 유한개

– 무한 언어 : 스트링의 개수가 무한개

T = {a, b}

– L1 = T* = {ε, a, b, aa, ab, ... }

– L2 = {a, ba, aba}

– L3 = {ap | p는 솟수(prime number)}

– L4 = {anbn | n≥1}

형식 언어(formal language)

– 의미의 개념은 포함하지않고 단지 스트링들의 집합

– 형식언어(formal Language), 단지 스트링 집합

– 문법구조만 고려

언어 L과 L'의 곱(product): LL'

– L에 속하는 스트링과 L’ 에 속하는 스트링 접속

– 교환 법칙은 성립하지 않음

– LL' = {xy | x∈L 그리고 y∈L'}.

언어 L의 거듭제곱(power)

– 순환적(recursive)으로 정의

– L0 = {ε}, Ln = LLn-1 for n≥1

L*(Reflexive transitive closure)

– L* = L0 ∪ L1 ∪ L2 ∪ ...∪ Ln ∪… =

L+(transitive closure)

– L+ = L1 ∪ L2 ∪ ... ∪ Ln ∪ ... = L* - L0

결론

– 언어마다 알파벳 T가 존재

– T로부터 만들 수 있는 스트링 전체 집합 : T*

– 언어

• 어떤 규칙에 맞는 특정한 형태의 스트링을 모아 놓은 집

합.

– 문장(sentence)

• 유한 언어에 속하는 스트링

문법(Grammar)

Nonterminal, VN

– 스트링을 생성하는데 사용되는 중간 과정의 심볼

– 언어의 구조를 정의하는데 사용

Terminal, VT

– 정의된 언어의 알파벳

Terminal + Nonterminal

– 문법심볼(Grammar Symbol)

– V(Vocabulary)

문법 정의

G = (VN, VT, P, S)

– VN : Nonterminal 심볼의 유한 집합

– VT : Terminal 심볼의 유한 집합

– VN ∩ VT = , VN ∪ VT = V

– P : 생성 규칙(production rule)의 유한 집합

– α → β, α∈V+, β∈V*

– S : VN에 속하는 심볼로서 시작 심볼

G = ( {S, A}, {a, b}, P, S )

P : S → aAS S→a

A → SbA A → ba A → SS

– nonterminal 집합 : {S, A}

– terminal 집합 : {a, b}

– 시작 심볼 : S

– 생성 규칙 : 5개

축약표기

– 생성 규칙의 왼쪽(LHS)이 같은 경우

– α → β1, α→β2, α → β1 | β2

– S → aAS | a

– A → SbA | ba | SS

• Nonterminal 심볼 : 대문자

• Terminal 심볼 : 소문자

• 시작 심볼 : 대문자 S

유도(derivation), ⇒, ⇒*, ⇒+

– ⇒, 직접 유도(directly derive)

• 생성 규칙을 한 번 적용하여 다른 스트링으로 대치

• α→β가 존재, γ, δ ∈ V*이면,γαδ ⇒ γβδ

– ⇒*, 영 번 이상의 유도

– ⇒+, 한 번 이상의 유도

문장형태 vs. 문장

예

S => aA (S -> aA)

=> abS (A -> bS 를 적용)

=> abbB (S -> bB 를 적용)

=> abbaS (B -> aS 를 적용)

=> abba (S -> ε 을 적용)

– 문장 형태 : S, aA, abS, abbB, abbaS, abba

– 문장 : abba(terminal로 구성 )

L(G)

– 문법 G에 의해 생성되는 언어

– L(G) = {ω | S ⇒* ω, ω∈VT*}

G1 = ( {S}, {a}, P, S )

– P : S -> a | aS

S ⇒ a a ∈ L(G1)

S ⇒ aS ⇒ aa aa ∈ L(G1)

S ⇒ aS ⇒ aaS ⇒ aaa aaa ∈ L(G1)

– L(G1) = {an | n≥1}

문법과 언어의 관계

Grammar Languagedesign

generation

문법의 분류

촘스키(Noam Chomsky) 문법 분류

– Type 0 문법

• Unrestricted Grammar; UG

– Type 1 문법

• Context Sensitive Grammar; CSG

– Type 2 문법

• Context Free Grammar; CFG

– Type 3 문법

• Regular Grammar; RG

Type 0 문법 : Unrestricted Grammar

• 생성 규칙에 제한을 두지 않음

• 생성 규칙 α→β에서 α는 empty 스트링이 될 수 없음

Type 1 문법 : Context Sensitive Grammar

• 생성 규칙 α→β에서 β의 길이가 α의 길이보다 길다.

• |α| ≤ |β|

– Type 2 문법 : Context Free Grammar; CFG

• 생성 규칙 A→α 형태

– A는 Nonterminal 심볼, α는 V*에 속하는 스트링

• 생성 규칙 좌측(LHS) : 하나의 Nonterminal 심볼

• 생성 규칙 우측(RHS) : Nonterminal + Terminal

– Type 3 문법 : Regular Grammar; RG

• A → tB or A → t, t ∈ VT*이고 A, B∈VN ; 우선형

• A → Bt or A → t, t ∈ VT*이고 A, B∈VN : 좌선형

문법, 언어, 인식기(recognizer)

Grammar Language Recognizer

Type 0

(unrestricted)

recursively

enumerable set

Turing

machine

Type 1

(context-sensitive)

context-sensitive

language

linear bounded

automata

Type 2

(context-free )

context-free

language

PushDown

Automata

Type 3

(regular)

regular

language

Finite

Automata

정규 언어(Regular Language)

상지대학교 컴퓨터정보공학부

고 광 만

(kkman@mail.sangji.ac.kr)

Contents

정규 문법과 정규 언어

정규 표현(Regular Expression)

유한 오토마타(Finite Automata)

정규 언어의 속성

정규 문법과 정규 언어

정규 문법(Regular Grammar)

– 촘스키(Chomsky, N.) 문법 규칙-Type 3

– 토큰 구조 표현(어휘 분석 단계)

정규 문법의 형태

① 우선형 문법(right-linear grammar; RLG)

• Nonterminal이 Terminal 뒤에 나타남

• RLG: A -> tB, A -> t

② 좌선형 문법(left-linear grammar; LLG)

• Nonterminal이 Terminal 앞에 나타남

• LLG: A -> Bt, A -> t (A,B ∈ VN 이고 t ∈ VT*)

예

– G1 : S -> 000S | 000 : RLG

– G2 : S -> S11 | 11 : LLG

RLG <===> LLG

참고

– 문법의 생성 규칙이 우선형 형태의 규칙과 좌선형 형태의규칙이 혼합되어 있으면 정규 문법이 아님.

– 예, 정규 문법이 아님.

G : S -> aR | c

R -> Sb

• L(G) = {ancbn | n ≥ 0} : context-free 언어

• G : context-free 문법

우선형 문법

– RLG: A -> tB, A -> t (A, B ∈ VN, t ∈ VT*)

우선형 문법에서 t =ε인 경우

– 생성 규칙 : A -> B

• 단일 생성 규칙(single production)

– 생성 규칙 : A -> ε

• ε-생성 규칙(epsilon production)

같은 종류의 언어 생성

– 언어 L은 우선형 문법에 의해 생성

– 언어 L은 좌선형 문법에 의해 생성

– 언어 L은 정규 문법에 의해 생성

=> 정규 언어(Regular Language)

L = {anbm | n,m ≥ 1}, 정규 언어

S -> aS | aA

A -> bA | b

– 언어 L을 생성하는 정규 문법이 존재

정규 문법이 사용되는 이유

– 토큰의 구조는 간단하므로 정규 문법으로 표현 가능

– Context-Free Grammar보다는 정규 문법으로부터 인식기의 구현이 쉬움.

– 모듈러하게 구성할 수 있음

정규 표현(Regular Expression)

정 의

– 정규 문법 G를 대수학적인 성질로 표현

– 정규 언어에 속해있는 스트링의 모양을 직접 기술

– 정규 문법은 문법이 나타내는 언어의 형태를 체계적으로 구하여 정규 표현으로 나타낼 수 있음.

정규 문법(Regular Grammar)

정규 표현(Regular Grammar)

유한 오토마타(Finite Automata)

정규 표현 정의

1. 정규 표현의 기본 요소 : Φ, ε, terminal 심볼

– Φ : 공집합을 나타내는 정규 표현

– ε : 집합 {ε}을 나타내는 정규 표현

– a∈VT : 집합 {a}를 나타내는 정규 표현

2. e1, e2가 정규 언어 L1과 L2의 정규 표현

– (e1) + (e2) : L1∪L2의 정규 표현(union)

– (e1) . (e2) : L1. L2의 정규 표현(concatenation)

– (e1)*L1* = {ε}∪L1

1∪L12∪L1

3 ...∪L1n의 정규 표현, (closure)

정규 표현의 예

– 정규 표현 : ab*

• a가 나오고 b가 0번 이상 나오는 스트링

• {abn| n≥0}

– 정규 표현 : (0+1)*

• {0,1}*

– 정규 표현 : (a+b)*abb

• a와 b로 이루어지는 모든 스트링 뒤에 abb가 나오는 언어

명칭(identifier)의 정규 표현

– 특정한 형태의 스트링을 표현하는데 유용

– letter={A,B, ..., Z,a,b, ...,z}, digit={0,1,2, ..., 9}

– letter(letter+digit)*

정규 표현의 대수학적인 성질

A1) α+β = β+α

A2) (α+β) + γ = α+ (β+γ)

A3) (αβ) = α(β)

A4) α(β+γ) = αβ+αγ

A5) (β +γ)α = βα +γα

A6) α +α = α

A7) α +Φ = α

A8) αΦ = Φ = Φα

A9) εα = α = αε

A10) α* = ε+αα*

A11) α* = (ε + α)*

A12) (α*)* = αβ*

A13) α* +α = α*

A14) α* + α+ =α*

A15) (α + β)* = (α*β*)*

정규 표현식

– 계수가 정규 표현인 식

– 예, αi, βi(i = 1,2,3, …)가 정규 표현일 때

• X = α1X +α2Y +α3

• Y = β1X +β2Y +β3

X = αX +β의 해(Solution)

– X =α*β 대입

X = αX + β

= α(α*β)+β

= α+β+β

= (α+ +ε)β

= α*β

L(G)를 나타내는 정규 표현 생성 과정

정규 문법으로부터 정규 표현식 구성

– 정규 문법 : X ->α|β|γ

– 정규 표현식 : X = α + β + γ 변환

X =αX +β을 X =α*β 변환

– X = αX +β 형태로 정리

– 시작 심볼에 대한 정규 표현식을 X =α*β로 변환

– α*β

• 정규 문법으로부터 생성될 수 있는 정규 언어

G = ( {S, R}, {a,b}, P, S )

– S → aS | bR | ε

– R → aS

정규 표현식

S = aS + bR +ε .... (1)

R = aS .... (2)

– X = αX +β 형태의 식이 존재하지 않음

시작 심볼 S에 대해, 식 (2)를 식 (1)에 대입.

S = aS + b(aS) +ε

= aS + baS +ε

= (a+ba)S +ε

변환 과정에 의해 L(G) 구성

– S = (a+ba)S +ε = (a+ba)*

– L(G) = (a+ba)*

G = ( {S,A,B}, {a,b}, P, S )에 대한 L(G) ?

정규 문법

S → aA | bB | b

A → bA |ε

B → bS

정규 표현식

S = aA + bB + b .... (1)

A = bA +ε .... (2)

B = bS .... (3)

X = αX +β형태의 식 (2)를 풀면

A = bA +ε = b*ε = b* .... (4)

식 (4)와 (3)을 식 (1)에 대입

S = aA + bB + b

= ab* + bbS +b

= bbS + (ab* + b)

= (bb)*(ab* + b)

L(G) = (bb)* (ab* + b)

정규 표현 ?

정규 표현식

X1 = 0X2 + 1X1 +ε .... (1)

X2 = 0X3 + 1X2 .... (2)

X3 = 0X1 + 1X3 .... (3)

식 (3)에서

X3 = 1X3 + 0X1

= 1*0X1 .... (4)

식 (2)에 식(4)를 대입

X2 = 01*0X1 + 1X2 = 1X2 + 01*0X1

= 1*01*0X1 .... (5)

식 (5)를 식 (1)에 대입

X1 = 01*01*0X1 + 1X1 +ε

= (01*01*0 + 1)X1 +ε

= (01*01*0 + 1)*

L(X1) = (01*01*0 + 1)*

유한 오토마타(Finite Automata; FA)

언어 인식기(Language Recognizer)

– 스트링을 받아 스트링이 그 언어의 문장, "Yes"

– 인식기 중에 가장 간단한 형태

– 어휘 분석기의 고안/구현

a0 a1 a2 ... ai ai+1 ai+2 ... aninput

Input head

Auxiliary Storage

Finite State Control

FA M = (Q, Σ, δ ,q0, F)

구성 요소

– Q : 상태(state)들의 유한 집합

– Σ : 입력 심볼의 유한 집합

– δ : 사상 함수(mapping function)

• Q×Σ→2Q(power set of Q)

• δ(q, a) = {p1 ,p2 , . . . ,pn}

• q 상태에서 입력 a를 본 다음 상태는 p1부터 pn중 하나

선택

– q0 : 시작 상태(start 또는 initial state) (q0∈Q)

– F: 종결 상태의 집합 (F⊆Q)

상태 전이 함수(state transition function)

– 결정적 유한 오토마타(Derteministic FA; DFA)

– 비결정적 유한 오토마타(Nonderteministic FA; NFA)

DFA 정의

– 전이 함수 δ(q, a)가 다음 상태로서 오직 한 상태만 갖는 경

우

– δ(q, a) = {p}, δ(q, a) = p

DFA M = (Q, Σ ,δ, q0, F)

구성 요소

– Q : 상태(state)들의 유한 집합

– Σ: 입력 심볼의 유한 집합

– δ : 사상 함수(mapping function)

• Q×Σ → Q

• δ(q, a) = p

• q 상태에서 입력 a를 본 다음 상태는 p.

– q0 : 시작 상태(start 또는 initial state) (q0∈Q)

– F: 종결 상태의 집합 (F⊆Q)

M = ( {q0, q1, q2}, {a, b} , δ, q0, {q2} )

δ(q0, a) = q1 δ(q0, b) = q2

δ(q1, a) = q2 δ(q1, b) = q0

δ(q2, a) = q0 δ(q2, b) = q1

– 상태수, 3개 : q0, q1, q2

– 입력 심볼 : a, b

– 시작 상태 : q0

– 종결 상태 : q2

상태 전이표(transition table)

– FA의 전이 함수를 행렬(matrix) 형태로 표현

– 행과 열은 각각 상태 집합과 입력 심볼 표시

– 행과 열이 교차하는 위치 : 다음 상태

전이 함수에 대한 상태 전이표

δ a b

q0 q1 q2

q1 q2 q0

q2 q0 q1

전이 함수 확장

– Q×Σ→Q ⇒ Q×Σ*→Q

– 한 개의 심볼을 스트링으로 확장

• δ(q, ε) = q

• δ(q, xa) = δ( δ(q,x) , a)

상태 q0에서 스트링 aba를 인식

– δ(q0, aba) = δ(δ(q0, ab), a)

= δ(δ(δ(q0, a), b), a)

δ(q0, x) = p인 경우

– q0로부터 x를 본 다음 상태, p

– p가 종결 상태에 포함(p∈F)

• 스트링 x는 M에 의해 인식(accept).

– 시작 상태에서 주어진 스트링을 다본 상태가 종결 상태이

면 스트링 인식

M에 의해 인식되는 언어, L(M)

– DFA M에 의해 인식되는 스트링 전체를 모아 놓은 집합

– L(M) 정의

• L(M) = {x| δ(q0, x) ∈ F}.

M = ( {p, q, r}, {0, 1}, δ, p, {r} )에 의한 스트링 1001, 0110 인

식 ?

– 오토마타 상태 전이표

δ 0 1

p q p

q r p

r r r

δ(p,1001)

=δ(p, 001) = δ(q, 01) =δ(r, 1) = r ∈ F

스트링 1001은 M에 의해 인식

δ(p,0110)

=δ(p, 110) = δ(p, 10) = δ(p, 0) = q ∈ F

스트링 0110은 M에 의해 인식되지 못함

상태 전이도(state transition diagram)

상태 전이도

– 각 상태를 노드(node)로 표현

– 전이 함수 δ(q,a) = p

• 상태 q에서 p로 이동, 레이블이 a인 지시선 사용

– 종결 상태 : 이중 원, 시작 상태 : start 지시선

상태 전이도 표현

– 스트링을 인식 과정을 표현한 흐름도

– 스트링을 받아 들이는 인식기를 고안하는데 사용

상태 전이도

명칭에 대한 상태 전이도

start p q r0

1

1

0

0, 1

start Sletter

letter, digit

A

비결정적 유한 오토마타

비결정적 유한 오토마타(NFA)

– 입력 심볼에 대한 다음 상태가 여러개 존재

– 다음 상태를 선택하기 위하여 여러 가지 가능성을 고려

NFA M

– Q : 상태들의 유한 집합

– Σ : 입력 심볼의 유한 집합

– δ : 전이 함수 Q×Σ→2Q, δ(q, a) = {p1, p2, ... ,pn}

– q0 : 시작 상태로 q0∈Q

– F : 종결 상태의 집합

상태 전이표

– δ(q, a) = Φ, δ(q, a)는 정의되지 않았음.

– q 상태에서 a라는 입력 심볼이 나올 수 없음

δ 0 1

q0 {q1, q2} (q1, q3}

q1 {q1, q2} {q1, q3}

q2 {qf} Φ

q3 Φ {qf}

qf {qf} {qf}

NFA에 대한 상태 전이도

– 노드 : q0, ..., qf

– 입력 심볼 : 0, 1

– 시작 상태 : q0, 종결 상태 : qf

– 전이 함수 δ

start q0

q1

q2

q

3

qf

0 0 0, 1

11

0, 1

1

0

0,1

NFA에 의한 전이 함수 확장-1

– δ(q,ε) = {q}

– δ(q,xa) = ∪ δ(p,a) p∈δ(q,x)

• x를 다 본 상태들에서 a를 본 상태 집합의 합집합

δ(q0,1001) = δ(q1, 001) ∪ δ(q3, 001)

= δ(q1, 01) ∪ δ(q2, 01) ∪ Φ

= δ(q1, 1) ∪ δ(q2, 1) ∪ δ(qf, 1) = {q1, q3, qf}

NFA M은 스트링 1011을 인식 ?

δ({q0}, 1011) = δ({q1, q3}, 011)

= δ({q1, q2}, 11)

= δ({q1, q3}, 1)

= δ{q1, q3, qf}.

– {q1, q3, qf} ∩ {qf}≠ Φ

∴ 1011은 M에 의해 인식

인식 과정을 트리 구조로 표현

NFA에서 DFA로 변환

NFA에서 DFA로 변환

– NFA는 언어의 구조를 쉽게 표현할 수 있음

– DFA보다 프로그램으로 구현하기가 어려움

– NFA에 대해 같은 언어를 인식하는 DFA 구현 가능

NFA에서 스트링을 인식 과정

– 상태 집합에서 심볼을 보고 다음 상태 집합으로 이동

δ(q0, a1a2 ... an)

= δ( {q1,q2,...,qi}, a2a3 ... an)…

= {r1, r2, ... , rk}

NFA M=(Q, , δ, q0, F), DFA M'=(Q', , δ', q0', F')

– Q' = 2Q(Q의 부분 집합의 집합; power set).

• Q'의 한 상태는 [q1,q2,…, qi]의 형태로 표시)

– q0 ‘= [q0]

– F' = {q} ∈ Q'

• q는 F의 상태들 중에 적어도 하나를 포함

– δ({q1, q2, …, qi}, a) = { p1, p2, …, pj} 이면

• δ'([q1, q2, …, qi], a) = [p1, p2, …, pj]

NFA를 DFA로 변환

– NFA M = ( {q0, q1}, {0, 1}, δ, q0, {q1} )

0 1

q0 {q0, q1} {q0}

q1 {q0, q1}

DFA, M'=(Q', Σ, δ',q0',F')

– 상태 집합 Q‘ : 2Q로 표현

• { [q0], [q1], [q0,q1] }

– 시작 상태 :

• q0' = [q0]

– 종결 상태 집합 F ' :

• NFA의 종결 상태 q1을 포함하고 있는 상태들의 집합

• { [q1], [q0, q1] }

– 입력 심볼에 따른 전이 함수

δ'([q0], 0) = δ({q0}, 0) = {q0,q1} = [q0,q1]

δ'([q0], 1) = {q0} = [q0]

δ'([q1], 0) = δ({q1}, 0) = Φ

δ'([q1], 1) = δ({q1}, 1) = {q0,q1} = [q0,q1]

δ'([q0,q1], 0) = δ({q0,q1}, 0) = {q0,q1} = [q0,q1]

δ'([q0,q1], 1) = δ({q0,q1}, 1) = {q0,q1} = [q0,q1]

상태 이름 변경

– [q0] = A, [q1] = B, [q0,q1] = C

– B는 시작 상태에서 도달할 수 없는 상태이므로 문장을 인식하는데 필요 없음.

’ 0 1

A C A

B C

C C C

상태 전이도

0,11

0

1

CA

B

Start

NFA로부터 DFA를 구성하는 과정

과정

– 시작 상태 q0를 DFA의 시작 상태 [q0]로 지정

• Q' = { [q0] }

– 각 상태에서 입력 심볼을 보고 갈 수 있는 다음 상태 구성

• 새로 구성된 상태가 존재하지 않으면 새로운 상태를 Q'에 추가

• 문자에 대한 지시선을 연결

• 다음 상태가 이미 존재하면 입력 문자에 따른 지시선만연결

– 새로운 상태가 추가되지 않을 때까지 반복

• 새로운 상태중 NFA의 종결 상태를 포함하고 있으면 모두 DFA의 종결 상태.

NFA로부터 동등한 언어를 인식하는 DFA

start 0

a, b

a1 2 3

b b

1. NFA의 시작 상태가 0, DFA의 시작 상태 [0]

start [0]

2. 상태 [0]에서 a, b를 보고 갈 수 있는 다음 상태

– 상태 [0]에서 a를 보고 갈 수 있는 상태 집합

• {0,1}, 새로운 상태 추가 후 지시선 연결

– 상태 [0]에서 b를 보고 갈 수 있는 상태 집합

• {0}, [0]는 이미 존재하므로 지시선만 연결

a[0,1]start [0]

b

a[0,1]start [0]

3.상태 [0,1]에서 a, b를 보고 갈 수 있는 상태

– 입력 심볼 a를 보고 갈 수 있는 상태

• {0,1}, 기존에 존재하는 상태이므로 지시선만 연결

– 입력 심볼 b를 보고 갈 수 있는 상태

• {0,2}, 새로운 상태 추가 후 지시선 연결

b

a[0,1]start [0]

a

b

a[0,1]start [0]

a

b[0,2]

4. 상태 [0,2]에서 a, b를 보고 갈 수 있는 상태

– 상태 [0,2]에서 a를 보고 갈 수 있는 상태 집합

• {0,1}, 지시선만 연결

– 상태 [0,2]에서 b를 보고 갈 수 있는 상태 집합

• {0,3}, 새로운 상태 추가 후 지시선 연결

b

a[0,1]start [0]

a

b[0,2]

a

b

a[0,1]start [0]

a

b[0,2]

a[0,3]

b

5. 상태 [0,3]에서 a, b를 보고 갈 수 있는 상태

– 상태 [0,3]에서 a를 보고 갈 수 있는 상태 집합

• {0,1}, 지시선만 연결

– 상태 [0, 3]에서 b를 보고 갈 수 있는 상태 집합

• {0}, 지시선만 연결

b

a[0,1]start [0]

a

b[0,2]

a[0,3]

b

a

b

6. 더 이상 새로운 상태가 존재하지 않음

– NFA의 종결 상태 3을 포함하는 상태 [0,3]을 DFA의종결 상태로 표시

b

a[0,1]start [0]

a

b[0,2]

a[0,3]

b

a

b

DFA 상태수 최소화

DFA 상태수 최소화(state minimization)

– DFA를 이용하는 어휘 분석기의 상태 전이표의 크기를 줄임

– 기억 공간을 적게 사용

– 어휘 분석 프로그램을 간단히 하는데 큰 도움

– 동치 관계(equivalence relation)

• 상태 합침(state merge)

• 구별되지 않는 상태를 하나로 합침.

상태수 최소화 방법

단계 1 : 초기의 동치 관계 구성

– 전체 상태를 종결 상태와 미종결 상태로 분할

b

a

Astart

a

ED

CB

a

b

b b

a

a

단계 2 : 같은 입력 심볼에 대해 서로 다른 동치류로 가는 지시선이 존재하는 경우

– 분할, 새로운 동치류 구성

1:{A, B, D} 2:{C, E}

a 1 1 1 1 1

b 1 2 2 1 1

1:{A} 2:{ B, D} 3:{C, E}

a 2 2 2 2 2

b 2 3 3 3 3

3. 2번 과정을 반복하여 더 이상 분할이 일어나지 않을 때,

– DFA M' = (Q', Σ, δ', q0', F') 구성

• Q' : 동치류의 집합

• Q'의 한 상태를 [q]로 표기

• 상태 q를 포함하는 동치류를 의미

– q0' = [q0]

– [p], [q]를 임의의 동치류라 할 때

• δ(p,a)=q 이면 δ'([p], a) = [q]

– F' = {[q] | q ∈ F}

상태수 축소

– X=[A], Y=[B, D], Z=[C, E]

X Y Z

a Y Y Y

b Y Z Z

– 상태수가 5개에서 3개로 축소

– 상태 전이도

b

Zstart X Ya, b

b

a

정규언어의 속성

정규 문법, 정규 표현, 유한 오토마타와의 관계

정규 문법(Regular Grammar)

정규 표현(Regular Grammar)

유한 오토마타(Finite Automata)

정규 문법과 유한 오토마타

정규 문법에 대해 유한 오토마타 구성

– 상태 집합

• Nonterminal 심볼의 집합 + 새로운 종결 상태

– 시작 상태 : 시작 심볼

– 사상 함수 : 전이 함수

G = (VN, VT, P, S), M = (Q, Σ, δ, q0, F)

– Q : VN ∪ {f}

– Σ : VT

– q0 : S

– F : L(G), then {f} else {S, f};

– δ : if A → aB ∈ P, then δ(A, a) ∋ B;

if A → a ∈ P, then δ(A, a) ∋ f.

QnA