前回は、瞬時復号可能な符号を作る手法の1つである「ハフマン符号化」についてみていきました。

[基本情報・応用情報] うさぎでもわかる情報理論　第3羽　ハフマン符号化

こんにちは、ももうさです。 前回では、「一意復号可能な符号」と「瞬時復号可能な符号」がどのような符号なのかについてみてい

今回は、瞬時復号可能な符号を作るもう1つの手法である「シャノン・ファノ符号化」の符号化手順について、実際に例題や練習問題を踏まえながら見ていきましょう。

1. まずは例題で確認

まずは、例題でシャノン・ファノ符号化の方法を見ていきましょう。

Step1. 各文字を出現確率 (回数) の多い順に並べ、全体で1つのグループと仮定

シャノン・ファノ符号化をする際にはまず、与えられた文字（記号・情報）を出現確率が大きい順に並び替えます。

ここからがハフマン符号と方法が変わってくるので、注意してみていきましょう。

シャノン・ファノ符号化では、最初にすべての文字 (記号・情報) を1つのグループと仮定します。

Step2. グループ内の情報を、確率が半分になるように分解していく。(すべてのグループの情報が1つになるまで)

すべてのグループに属する文字が1つになるまで、「2つ以上の文字が属するグループ」を出現確率の和が最も半分に近くなる部分で2分割していきます。

ここで、「出現確率の和が最も半分に近くなる部分」を選んでいく際に、グループ内の各文字の確率を大きい順に足していくことで確認します。（シャノン・ファノ符号化の特徴）

Step2-1. BDAED (100%) を2分割

まずは、BDAED (合計確率: 100%) を2分割します。

ここで、最も半分 (50%) に近くなるように分割するためには、B (56%) とDAEC (44%) に分ければOKですね。

つぎに、分けた2つのグループを下のように二分木で書きます。

ここで、Bはすでに1つの文字のグループとなったため、これ以上の操作は不要です。一方、ACDEはまだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-2. ACDE (44%) を2分割

つぎに、ACDE (合計確率: 44%) を確率が最も半分 (22%) に近くなるところで2分割します。

ここで、最も半分 (22%) に近くなるように分割するためには、D (20%) とAEC (24%) に分ければOKですね。

さらに、分けた2つのグループを下のように二分木で書きます。

ここで、Dはすでに1つの文字のグループとなったため、これ以上の操作は不要です。一方、AECはまだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-3. AEC (24%) を2分割

つぎに、ACDE (24%) を確率が最も半分 (12%) に近くなるところで2分割します。

ここで、最も半分 (12%) に近くなるように分割するためには、A (12%) とEC (12%) に分ければOKですね。

さらに、分けた2つのグループを下のように二分木で書きます。

ここで、Aはすでに1つの文字のグループとなったため、これ以上の操作は不要です。一方、ECはまだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-4. EC (12%) を2分割

つぎに、EC (合計確率: 12%) を確率が最も半分 (6%) に近くなるところで2分割します。
（とはいっても、グループ内の文字が2つなので、確率に関係なしに1-1に分割するしかありませんが…）

分けた2つのグループを下のように二分木で書きます。

すると、E, C ともに1つの文字のグループとなり、すべてのグループに属する文字が1つとなりましたね。

そのため、Step2の操作はここで完了です。

Step3. 作成した二分木から各文字(情報)ごとの符号を求める

あとは、作成した二分木を見ていくことで、各文字ごとの符号を求めていきましょう。
（※ この部分はハフマン符号化と手順は同じです。）

まず、下のように各節（ノード）の左側を0、右側を1として考えます。
（葉となっていないノードの名前は、見やすさのため消しています。）

あとは、各文字（A～E）に対応するノードごとに「木構造の一番上の部分から対応するノードまでたどっていく」という操作をし、たどっていく際に通った0, 1を左から順番に並べていったものが符号となります。

よって、各文字A～Eごとの符号は下のように求まります。

結果を見てみると、出現確率が高い符号には短い符号を、出現確率が低い符号には長い符号が付いていることがわかりますね。

このように、シャノン・ファノ符号化も、ハフマン符号化と同じく文字列の平均符号長がなるべく短くなるような符号の決め方を機械的に決めることができるのです！

※ シャノン・ファノ符号化において、二分木を書くことで瞬時復号可能な符号が作成できる理由はこちらに記しています^[1] … Continue reading。

(2)

平均符号長は、各文字ごとに「符号長（符号の文字数） × 出現確率」を求め、それらを足すことで求めることができます。

今回の場合は、各文字ごとの「符号長」、および「符号長 × 出現確率」を下のように求めることができます。

よって、平均符号長 \( L \) は\[\begin{align*}
L & = 0.36 + 0.56 + 0.16 + 0.40 + 0.32
\\ & = 1.80
\end{align*}\]と求まります。

※ ハフマン符号のときと全く同じ平均符号長が得られます。

2. シャノン・ファノ符号化手順まとめ

3. 練習問題

実際に練習問題で、シャノン・ファノ符号化ができるか確認してみましょう。

4. 練習問題の答え

(1)を解く前に各文字の出現回数から出現確率を求めましょう。（(2)で使うため）

各文字の出現確率は、( 各文字の出現回数 ) ÷ ( 文字全体の出現回数[今回の場合は20] ) で求めることができます。

(1) ハフマン符号による符号化

Step1. 各文字を出現確率 (回数) の多い順に並べ、全体で1つのグループと仮定

まず、与えられた文字（記号・情報）を出現確率が大きい順に並び替えます。

これら6つの文字をいったん、全て1つのグループに属していると仮定します。

Step2. グループ内の情報を、確率が半分になるように分解していく。(すべてのグループの情報が1つになるまで)

つぎに、すべてのグループに属する文字が1つになるまで、「2つ以上の文字が属するグループ」を出現確率の和が最も半分に近くなる部分で2分割していきます。

（「出現確率の和が最も半分に近くなる部分」を選んでいく際に、グループ内の各文字の確率を大きい順に足していくことで確認します）

Step2-1. CADEBF (100%) を2分割

まずは、CADEBF (合計確率: 100%) を2分割します。

ここで、最も半分 (50%) に近くなるように分割するためには、CA (55%) とDEBF (45%) に分ければOKですね^[2]C (30%) とADEBF (70%) だと最も半分に近くなるわけでないのでNG。。

分けた2つのグループを下のように二分木で書きます。

ここで、CA, DEBFの2つのグループともに、まだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-2. CA (55%) を2分割

先にCA (合計確率: 55%) からグループを分割していきましょう。

グループ内に2つの文字しかないため、確率を気にせず1つずつに分割すればOKです。

分けた2つのグループを下のように二分木で書きます。

これで、CAのグループは、互いに1つの文字のグループの文字に分割できたため、これ以上の操作は不要です。

なので、ここからはDEBFのグループを分割していきましょう。

Step2-3. DEBF (45%) を2分割

残った、DEBF (合計確率: 45%) を2分割します。

最も半分 (45%) に近くなるように分割するためには、D (20%) とEBF (25%) に分ければOKですね^[3]DE (35%) とBF (10%) だと最も半分に近くなるわけでないのでNG。。

分けた2つのグループを下のように二分木で書きます。

Dはすでに1つの文字のグループとなったため、これ以上の操作は不要です。一方、EBFはまだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-4. EBF (25%) を2分割

EBF (合計確率: 25%) を2分割します。

最も半分 (25%) に近くなるように分割するためには、E (15%) とBF (10%) に分ければOKですね。

分けた2つのグループを下のように二分木で書きます。

Eはすでに1つの文字のグループとなったため、これ以上の操作は不要です。一方、BFはまだ2つ以上の文字のグループなため、さらに分割をしていきます。

Step2-5. BF (10%) を2分割

最後にBF (合計確率: 10%) からグループを分割していきましょう。

とはいっても、グループ内に2つの文字しかないため、確率を気にせず1つずつに分割すればOKです。

分けた2つのグループを下のように二分木で書きます。

これで、すべてのグループの文字が1つになったため、Step2はクリアです。

Step3. 作成した二分木から各文字(情報)ごとの符号を求める

あとは、各文字（A～E）に対応するノードごとに「木構造の一番上の部分から対応するノードまでたどっていく」という操作をし、たどっていく際に通った0, 1を左から順番に並べていったものが符号となります。

よって、各文字A～Fごとの符号は下のように求まります。

(2) 平均符号長の計算

まず、各文字ごとの「符号長」および「符号長 × 出現確率」を求めましょう。

あとは、A～Fごとに求めた「符号長 × 出現確率」をすべて足せば平均符号長 \( L \) があっという間に求まります。\[\begin{align*}
L & = 0.50 + 0.20 + 0.60 + 0.40 + 0.45 + 0.20
\\ & = 2.35
\end{align*}\]※ ハフマン符号で圧縮した場合も同じ平均符号長が求まります。

前回では、「一意復号可能な符号」と「瞬時復号可能な符号」がどのような符号なのかについてみていきました。

うさぎでもわかる情報理論　第2羽　符号化と一意復号可能・瞬時復号可能な符号

皆さんはパソコンやスマホなどのコンピュータ上で何事もなく、「日本語」や「アルファベット」などの文字を使ってやり取りしてい

今回は、文字列を瞬時復号可能な符号かつ瞬時復号可能な符号の中で平均符号長が最も短くなるように符号化をするハフマン符号化方式について、例題や練習問題を解きながら見ていきましょう。

さらに、実際に基本情報や応用情報でハフマン符号化がどのように出題され、どのように解いていけばよいのかについても、確認しましょう。

1. まずは例題で確認

まずは、例題でハフマン符号化の方法を見ていきましょう。

Step1. 各文字を出現確率 (回数) の多い順に並べ、各文字ごとを独立したグループとする

ハフマン符号化をする際にはまず、与えられた文字（記号・情報）をそれぞれ独立したグループとしてから、出現確率が大きい順に並び替えます。

今回の場合は5種類あるため、5つの独立したグループが出てきます。

※ 並び変える際に、文字と出現確率の対応を書き間違えないようにしましょう。

Step2. 出現確率が低い2つのグループを1つにしていきながら、二分木を作る

つぎに、グループ数が1になるまで、各グループの中から出現確率が低い2つのグループを探し出し、その2つのグループをひとまとめにしていきます。

Step2-1. 5グループ → 4グループ

出現確率が低い2つのグループは、EとCなので、この2つをひとまとめにします。

（ひとまとめにしたグループの出現確率は、2つのグループの出現確率の合計です^[1]今回の場合は、Eの出現確率が6%、Cの出現確率が6%なので、ひとまとめにしたグループの出現確率は、6% + 6% = 12% となります。。）

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります^[2] … Continue reading。

Step2-2. 4グループ → 3グループ

出現確率が低い2つのグループは、AとECなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-3. 3グループ → 2グループ

出現確率が低い2つのグループは、AECとDなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-1. 2グループ → 1グループ

出現確率が低い2つのグループ(BとAECD)をひとまとめにします。
（残り2グループなので、その2グループが出現確率が低い2グループとなります。）

いつものように、ひとまとめにした2つのグループを子とし、二分木をつくりましょう。

Step3. 作成した二分木から各文字(情報)ごとの符号を求める

ここからは、作成した二分木を見ていくことで、各文字ごとの符号を求めていきましょう。

まず、下のように各節（ノード）の左側を0、右側を1として考えます。

あとは、各文字（A～E）に対応するノードごとに「木構造の一番上の部分から対応するノードまでたどっていく」という操作をし、たどっていく際に通った0, 1を左から順番に並べていったものが符号となります。

よって、各文字A～Eごとの符号は下のように求まります。

結果を見てみると、出現確率が高い符号には短い符号を、出現確率が低い符号には長い符号が付いていることがわかりますね。

このようにハフマン符号では、文字列の平均符号長がなるべく短くなるような符号の決め方を機械的に決めることができるのです！

(2)

平均符号長は、各文字ごとに「符号長（符号の文字数） × 出現確率」を求め、それらを足すことで求めることができます。

今回の場合は、各文字ごとの「符号長」、および「符号長 × 出現確率」を下のように求めることができます。

よって、平均符号長 \( L \) は\[\begin{align*}
L & = 0.36 + 0.56 + 0.16 + 0.40 + 0.32
\\ & = 1.80
\end{align*}\]と求まります。

2. ハフマン符号化と瞬時復号可能性

(1) 瞬時復号可能な符号とは

下のように、後戻りせずに符号化した文字列を復号することができる符号のことを、瞬時復号可能な符号と呼びます。

瞬時復号可能であるためには、どの符号語に対しても、頭部分に自身以外の符号語が出てこないかどうかで判定をすることができます。

(2) ハフマン符号化法で符号化した符号は必ず瞬時復号可能（かつ平均符号長が最小）！

ハフマン符号法で符号化を行うと符号は、必ず (平均符号長が最小の) 瞬時復号可能な符号になる点が大きな特徴です。

ここで、ハフマン符号化により符号化すると、必ず瞬時復号可能となることを二分木を使って確認しましょう。

まず、瞬時復号可能ではない符号を二分木で表すと、下のように各文字列が葉ではないノードが出てきますね。

つまり、葉ではないノードに対応する情報 (文字) があった時点で、何かしらの接頭語となっている符号が存在していることになります。

これを言い換えると、「全ての文字に対する各ノードがすべて葉ノードになっている」ことを確認できれば、接頭語となっている符号が存在しないこと、つまり符号が瞬時復号可能であることも確認ができます。

ハフマン符号化法によって符号化した符号が必ず平均符号長最小の瞬時復号可能な符号となる性質は、基本情報や応用情報の午前問題を解く際にかなり使えるので、必ず覚えておきましょう！！

※ 二分木を使って符号化をする方法には、ハフマン符号化のほかにシャノン・ファノ符号化もあります。シャノン・ファノ符号化はハフマン符号化とは異なるアルゴリズムで二分木を作成していきますが、瞬時復号可能となる理由はハフマン符号化と同じです^[3]。

3. 練習問題

4. 練習問題の答え

(1)を解く前に各文字の出現回数から出現確率を求めましょう。（(2)で使うため）

各文字の出現確率は、( 各文字の出現回数 ) ÷ ( 文字全体の出現回数[今回の場合は20] ) で求めることができます。

(1) ハフマン符号による符号化

Step1. 各文字を出現確率 (回数) の多い順に並べ、各文字ごとを独立したグループとする

まず、与えられた文字（記号・情報）をそれぞれ独立したグループとしてから、出現確率が大きい順に並び替えます。

今回の場合は6種類あるため、6つの独立したグループが出てきます。

Step2. 出現確率が低い2つのグループを1つにしていきながら、二分木を作る

つぎに、1グループになるまで、「出現確率が低い2つのグループを1つにまとめる」という操作を繰り返します。

Step2-1. 6グループ → 5グループ

まずは、出現確率が低い2つのグループは、BとFなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-2. 5グループ → 4グループ

出現確率が低い2つのグループは、BとFなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-3. 4グループ → 3グループ

まずは、出現確率が低い2つのグループは、EBFとDなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-4. 3グループ → 2グループ

出現確率が低い2つのグループは、CとAなので、この2つをひとまとめにします。

さらに、ひとまとめにした2つのグループを子とし、二分木をつくります。

Step2-5. 2グループ → 1グループ

残りの2つのグループ（CAとEBFD）をひとまとめにします。

このグループを子とし、二分木をつくれば、二分木の完成です。

Step3. 作成した二分木から各文字(情報)ごとの符号を求める

二分木が完成したら、つぎの方法で符号を求めていきます。

• 二分木の各節(ノード)の左側を0、右側を1とする
• 各文字（A～F）ごとに、以下の操作を実施
  • 木構造の一番上の部分から対応するノードまでたどっていく
  • たどった際に通った0, 1を左から順番に並べたものを符号にする

よって、各文字A～Fごとの符号は下のように求まります。

(2) 平均符号長の計算

まず、各文字ごとの「符号長」および「符号長 × 出現確率」を求めましょう。

あとは、A～Fごとに求めた「符号長 × 出現確率」をすべて足すことで平均符号長 \( L \) を求めることができます。\[\begin{align*}
L & = 0.50 + 0.20 + 0.60 + 0.40 + 0.45 + 0.20
\\ & = 2.35
\end{align*}\]

5. [問題] 基本情報・応用情報での問われ方

最後に、実際に基本情報・応用情報でハフマン符号化はどのように問われるかを見ていきましょう。

(1) 基本情報の午前問題の例

(2) 応用情報の午前問題の例

6. [解答] 基本情報・応用情報での問われ方

(1) 基本情報の午前問題の例

解答: エ

基本情報では問題には必ず選択肢が与えられています。
（応用情報でも午前問題と一部の午後問題には与えられています。）

そのため、ハフマン符号化を行った符号の特徴である

• 必ず瞬時復号可能となる
• 瞬時復号可能な符号の中でも平均符号長が最短となる

を満たしていない選択肢を消去していくことで、ハフマン符号化をしなくても正解に導けることがあります。

今回の場合、

ア → Aの符号00の接頭語となるためNG
イ → Bの符号01の接頭語となるためNG
ウ → Cの符号10の接頭語となるためNG

となるため、ハフマン符号化をしなくても残った エ が正解とわかります。

また、「瞬時復号可能」かを調べるのであれば下のように図を書くのも有効です。

図を見ると、ア～ウのノードを追加すると、どこかしらのノードが葉ではなくなりますね。なので、ア～ウの選択肢は誤りであることがわかります。

(2) 応用情報の午前問題の例

解答: ウ

ハフマン符号に関する知識の問題です。ハフマン符号について知っているだけで、1問分の得点が得られるおいしい問題なので、必ず得点をしておきたいですね。

[他の選択肢]

ア: 不正解。ラングレス法に関する説明。
イ: 不正解。二進化十進数 (BCD、Binary-coded decimal) に関する説明。
ウ: 正解。ハフマン符号化に関する説明。
エ: 不正解。ディジタル化の説明。

しかし、コンピュータ上では0, 1の2進数のみで情報を記録されているのでしたね。言い換えると、「日本語」や「アルファベット」などの情報はそのままコンピュータ上で保存されているわけではなく、2進数に変換されて保存されています。

そこで今回は、コンピュータ上で情報を読み出したり書きだしたりする際に使われる符号化についてみていきましょう。

1. 符号化とは

文字などの情報を2進数（0と1だけで表す）に置き換え、コンピュータ上で扱えるデータに変換することを符号化と言います。

例えば、「あ」・「い」・「う」・「え」の文字列を、下の2進数で置き換える（＝符号化する）ことにします。

ここで、置き換えた2進数（今回の場合は "00", "01", "10", "11"）のことを符号語と呼びます。

すると、文字列「あいうえ」は「00011011」と変換されます。

また、符号化された文字列を元の情報 (文字など) に戻すことを復号化と呼びます。

[解説]

符号化ルール

• A → 0
• B → 10
• C → 110
• D → 111

に従って、符号化・復号化をしていきましょう。

(1)

BDCA → 101111100

より、101111100と符号化できる。

(2)

11001111010 → CADBB

より、CADBBと復号化できる。

2. 符号化のための条件

やみくもに符号化のルールを決めると、復号する際に

• 復号ができない
• 復号ができたとしても復号に時間がかかる

といった問題が発生します。

そこで、符号化の際には、下のルールを守って符号化をする必要があります。

[必須条件]

• 符号化した文字列を一意に復号できること
  → 一意復号可能な符号であること

[推奨条件] (満たしてなくてもいいけど満たして)

• 符号化した文字列を後戻りせず（かつ一意）に復号できること → 瞬時復号可能な符号
• 出来る限り短い符号 (0, 1) で符号化すること

(1) 一意復号可能な符号 [必須条件]

(i) 一意復号可能とは

一意復号可能な符号とは、符号化した文字列を復号した際にその結果が1通りだけになる符号のことを表します。言い換えて、「元の情報を符号化し、それを復号すると100%元の情報に戻るような符号」と思っていただいてもOKです。

符号化は、一意復号可能な符号で行うことが必須です。「符号化された情報を復号したら、元の情報と違うものが出てきた」なんてことがあったら困りますよね。

(ii) 一意復号可能な符号の条件

ある符号が一意復号可能であるかを瞬時に見分ける方法は基本的にはありません。
（ただし、元の文字列への戻し方が2パターン以上存在する符号列を1つでも見つけることができれば、一意復号不可能であることは確認できます。）

(ii) 一意復号不可能な符号の例

下の例の符号を考えてみましょう。

• あ → 0
• い → 01
• う → 001

この場合、出てくる符号語は "0", "01", "001" の3つですね。ここで、"0", "01" をそれぞれ復号化すると、

• 0 → あ
• 01 → い

の1通りだけ得られます。一方、"001" は復号化すると、下のように2つの復号結果が出てきてしまいます^[1]"001" を復号すると「あい」or「う」のどちらがわからなくなるということですね。。そのため、例1の符号は一意復号不可能です。

(2) 瞬時復号可能な符号 [推奨条件]

瞬時復号可能な符号とは、符号化した文字列を復号していく際に、後戻りせずに復号ができる符号のことを表します。言い換えて、「先頭から順番に見ていくだけで、復号ができる符号」と考えてもOKです。

(ii) 瞬時復号可能な符号の条件

一意復号のときと異なり、瞬時復号可能な符号は見分ける方法があります。

ある符号が瞬時復号可能であるかは、符号化した文字列を左から読んでいくだけで、後戻りせずに各符号語を判別できるような符号化ルールをつかって符号化をする必要がありますね。

ここで、後戻りしないと各符号語を判別できない（＝瞬時復号不可能な）符号を見ていきましょう。

例えば下の符号化ルールの場合、「0」が出てきたときは、次の文字を先読みしないと「あ → 0」か「い → 01」のどちらかが確定できません。

もう少し詳しく符号化ルールを見ていくと、 01の頭部分には、「あ → 0」の0が含まれていますね。そのため、「い → 01」を復号する際に冒頭の1文字目0を読んだだけでは、「あ → 0」なのか、「い → 01」に出てくる0なのかがわかりません。

これを言い換えると、瞬時復号可能かどうかは符号化ルールに出てくるどの符号語に対しても、頭部分に自身以外の符号語が出てこないかどうかで判定ができますね。

(iii) 例で確認

例1) 瞬時復号不可能な符号

「い」の符号化ルールにおいて、「い → 01」のように、頭部分に「あ → 0」の0が含まれているため、瞬時復号不可能。

例2) 瞬時復号可能な符号

「あ → 0」：他の符号化ルールに出てくる符号 10, 11 の頭部分に0は出てこないのでOK
「い → 10」：「あ → 0」の符号は1文字、「う → 11」の符号は2文字と、自身の符号の文字数(2文字) 以下なのでOK。

より瞬時復号可能。

※ 各符号を確認する際は、自身の符号の文字数以下のものは「頭文字に来ることがないことが明らか」なため、確認を省略できます^[2] … Continue reading。

3. 練習問題

それでは、実際に「一意復号可能な符号」、「瞬時復号可能な符号」の判定法が理解できているかを練習問題で確認しましょう。

練習問題

次の(1)～(3)の符号のうち、瞬時可能な符号は(1), (2), (3)の中からすべて選びなさい。

[略解]

(1)

[解説]

(1): 瞬時復号可能

まずは、瞬時復号可能な符号かどうかの判定。

「あ → 00」、「い → 01」、「う → 10」、「え → 00」いずれも2文字の符号語である。

よって、完全一致しない限り自身以外の符号語の接頭語となる符号は存在しない。

よって、瞬時復号可能である。

(2): 瞬時復号可能ではない

「あ → 0」については、他の符号語 10, 11, 101 の接頭語になっていないためOK。

しかし、「い → 10」については、「え → 101」の符号 101 の接頭語になってしまっているため、瞬時復号可能な符号ではない。

(3): 瞬時復号可能ではない

「あ → 0」については、「え → 010」の符号語 010 の接頭語になっていないためNG。よって、瞬時復号可能な符号ではない。

4. さいごに

今回は、コンピュータ上で文字などの情報を扱う際に使われる符号化について学んでいきました。

最後に、一意復号可能な符号と瞬時復号可能な符号の関係を図にて、確認しておきましょう。

次回からは、実際に符号化する際に使われるハフマン符号やシャノンファノ符号についてみていきたいと思います。

[余談1] 符号化と文字コード

コンピュータをよく使う人や、情報系の人なら文字コード（ASCIIコード、Unicode、Shift-JISなど）というのを聞いたことがあると思います。この文字コードというのは、「どの符号化のルールが適用されているか」というのを表しています。

例えば、ASCIIコードであれば、各種文字とその符号（16進数に変換して記載している）は下のようになります。

[余談2] 符号化と文字化け

実際にWebサイトやドキュメントなどを見ていて、「文字化け」に出会ったことはありませんか？

実は、文字化けというのは「Webサイトやドキュメントを作成する際のコード設定」と「閲覧時の文字コード設定」がそろっていないために発生する現象なのです。

前回の「うさぎでもわかる画像処理　Part02」では、画像処理の中でも最も基本的な画像内の各画素値を自身の画素値のみを使って、一定のルールを用いて変換していく方法（トーンカーブ）について説明していきました。

トーンカーブを用いた画像処理でも、様々な画像処理ができるのですが、自身の画素値のみを書き換えていく画像処理では出来ることに限りがあります。

そこで今回と次回の2回にわたって、画像内の各画素値を変換していく際に自身の画素値だけでなく、周りの画素の画素値を利用しながら画像処理をしていく方法（フィルタ、空間フィルタリングなどと呼ばれます）について学習していきましょう。

今回の記事では、フィルタの中でも線形フィルタに着目してみていきます。

1. 線形フィルタのいろは

(1) 線形フィルタとは

画像処理の世界で出てくるフィルタは、

• 線形フィルタ
• 非線形フィルタ

の2つに分けることができます。

さらに、入力画像 \( A \) の \( i \) 行 \( j \) 列の画素値を \( A_{i,j} \)、出力画像 \( B \) の \( i \) 行 \( j \) 列の画素値を \( B_{i,j} \) としたときに\[
B_{m,n} = \sum^{N}_{n = -N} \sum^{M}_{m = -M} A_{i+m,j+n} H_{m,n}
\]の式（たたみこみ演算）で表されるようなフィルタのことを線形フィルタとよび、このときの \( H_{m,n} \) がフィルタを表す \( 2M+1 \) × \( 2N+1 \) 行列 \( H \) の \( m \) 行 \( n \) 列の係数を表します。

例えば、下のフィルタは3×3行列で表されていますね。

(2) 線形フィルタの計算の様子を見てみよう

では、(1)の例で出したフィルタ\[
\left( \begin{array}{ccc} \frac{1}{23} & \frac{2}{23} & \frac{5}{23} \\ \frac{3}{23} & \frac{1}{23} & \frac{2}{23} \\ \frac{2}{23} & \frac{3}{23} & \frac{4}{23} \end{array} \right)
\]を使って、たたみこみ式\[
B_{m,n} = \sum^{N}_{n = -N} \sum^{M}_{m = -M} A_{i+m,j+n} H_{m,n}
\]でどんな計算をしているかを下のアニメーションで確認してみましょう。

このように線形フィルタでは、着目した画素とその周囲の各画素値ごとに対応するフィルタの係数を掛け、それらをすべて足したものを着目した画素の新たな画素値とする計算を各画素ごとに行っているのです！

※ 端の画素をどうするかについては、様々な考え方がありますが、本記事では端の画素は画像処理をしない（＝画素値0）としたいと思います。

(3) 例題で確認！

例題

図1で表される元画像、および図2で示されるフィルタ(a), (b)がある。

(1), (2)の問いに答えなさい。

(1) フィルタ (a) を適用したときの、図3のアに当てはまる画素値を答えなさい。ただし、小数点以下を四捨五入し、整数値で答えること。
(2) フィルタ (b) を適用したときの、図3のイに当てはまる画素値を答えなさい。ただし、小数点以下を四捨五入し、整数値で答えること。

[解説]

(1)

フィルタ (a) \[
\left( \begin{array}{ccc} \frac{1}{5} & 0 & \frac{2}{5} \\ 0 & \frac{1}{5} & 0 \\ 0 & 0 & \frac{1}{5} \end{array} \right)
\]を適用した場合の [ア] の画素値を求めればOK。

よって [ ア ] の画素値は181となる。

(2)

フィルタ (b) \[
\left( \begin{array}{ccc} \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \end{array} \right)
\]を適用した場合の [イ] の画素値を求めればOK。

よって [ イ ] の画素値は149となる。

(4) 線形フィルタの演算をする関数（ソースコード）

実際に入力画像と線形フィルタを設定すると、画像処理を行う関数をPythonとMATLABで作成しました。

Python

def applyFilter(img,filt):
    # 入力画像のサイズ取得
    img_row    = img.shape[0]
    img_col    = img.shape[1]

    # フィルタのサイズ取得 (適さないフィルタサイズの場合はエラーを返す)
    filt_row = filt.shape[0]
    filt_col = filt.shape[1]
    if (filt_row % 2 == 0) or (filt_col % 2 == 0):
        print("フィルタサイズ設定に誤りがあります。")
        return img

    # 結果画像初期化
    result_img = np.zeros( (img_row,img_col) )

    # フィルタの中心部分算出
    filt_mid = int(filt_row / 2)

    # フィルタ適用
    for row in range(img_row):
        for col in range(img_col):
            if (row - filt_mid < 0) or (col - filt_mid < 0) or ( (row + filt_mid >= img_row) ) or ( (col+ filt_mid >= img_col) ):
                continue # 端の画素は無視 (画素値0)
            tmp_result = img[row - filt_mid:row + filt_mid + 1,col - filt_mid:col + filt_mid + 1] # 計算に使う周りの画素取得
            
            tmp_result = tmp_result * filt
            result_img[row,col] = round(np.sum(tmp_result))

    return result_img

MATLAB

function [result_img] = applyFilter(img,filt)
    img_row = size(img,1);
    img_col = size(img,2);

    filt_row = size(filt,1);
    filt_col = size(filt,2);
    if mod(filt_row,2) == 0 || mod(filt_col,2) == 0
        disp("フィルタサイズ設定に誤りがあります。");
        result_img = img;
        return
    end

    result_img = zeros(img_row,img_col,'uint8');

    filt_mid = uint32(filt_row / 2) - 1; % MATLABは要素が1スタートなのでPythonに慣れている人は注意！

    for row = 1:img_row
        for col = 1:img_col
            if (row - filt_mid < 1) || (col - filt_mid < 1) || (row + filt_mid > img_row) || (col + filt_mid > img_col)
                continue % 端は無視 (画素値0とする)
            end

            tmp_result = img(row - filt_mid:row + filt_mid,col - filt_mid:col + filt_mid); % 計算に使う周りの画素取得
            tmp_result = double(tmp_result) .* filt;
            result_img(row,col) = uint8(sum(tmp_result,'all'));
        end
    end
end

フィルタについての確認ができたところで、ここからは画像処理の世界によく出てくる代表的なフィルタを見ていきましょう。

2. 平滑化

ここでは、元の画像の画素値変化（濃淡変化）を小さくするフィルタを紹介します。

平滑化フィルタを適用することで、画像の濃淡変化を小さくした画像（＝元画像をぼかした画像）を生成することができます。

(1) 平均化フィルタ (移動平均フィルタ)

各画素を「自分自身とその周りの画素値の平均値」を新たな画素値とするフィルタです。\[\left( \begin{array}{ccc} \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\ \frac{1}{9} & \frac{1}{9} & \frac{1}{9} \\\frac{1}{9} & \frac{1}{9} & \frac{1}{9} \end{array} \right), \ \ \
\left( \begin{array}{ccc} \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \\ \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} & \frac{1}{25} \end{array} \right)
\]

「自分自身とその周りの画素値の平均」をとるため、隣り合う画素同士の画素値の差が減り、濃淡変化が緩やかになるため、元画像をぼかした画像が生成されます。

例えば下の変換は、自分＋周り1画素の平均値をとった3×3の平均化フィルタを表します。

「自分＋周り2画素」をとった5×5のフィルタを使った平均化も見てみましょう。

2つの変換を比べてみると、より広い周囲の画素値の平均をとった5×5フィルタの方が、よりぼかされた画像が生成されているのが特徴です。

(2) 加重平均化フィルタ [重み付き平均化]

平均化をする際に単純に平均化するのではなく、下のように「自分自身の画素（フィルタの中心）に近いほど重み大、遠いほど重み小」なフィルタを使って平均化をすることがあります。

このようなフィルタのことを加重平均化フィルタと呼び、加重平均化フィルタを使って平均化をすることを重み付き平均化と呼びます。

また、フィルタの重みをガウス分布（正規分布）\[
h_{x,y} = \frac{1}{2 \pi \alpha^2} e^{ - \frac{x^2 + y^2}{2 \alpha^2} }
\]に近づけたフィルタのことをガウシアンフィルタと呼びます。

(3) 特定方向への平滑化

特定方向へ画像をぼかすことができるフィルタもあります。

(i) 横方向へ平滑化

横方向のみに対して画素値の平均を取っていきます。

例えば上の例の場合、自分自身の画素と横±10画素の画素値の平均\[
B_{x,y} = \frac{1}{21} \left( A_{x-10,y} + A_{x-9,y} + \cdots + A_{x,y} + \cdots + A_{x+9,y} + A_{x+10,y} \right)
\]を取っています。

※注意（以後同様）

• \( A_{x,y} \) が元画像、\( B_{x,y} \) が変換後の \( x \) 行 \( y \) 列の画素値を表しています。
• 横方向を \( x \)、縦方向を \( y \) としています。

(ii) 縦方向へ平滑化

縦方向のみに対して画素値の平均を取っていきます。

例えば上の例の場合、自分自身の画素と縦±10画素の画素値の平均\[
B_{x,y} = \frac{1}{21} \left( A_{x,y-10} + A_{x,y-9} + \cdots + A_{x,y} + \cdots + A_{x,y+9} + A_{x,y+10} \right)
\]を取っています。

(iii) 斜め方向へ平滑化

左上方向から右下方向に対して画素値の平均を取っていきます。

例えば上の例の場合、基準に左上方向から右下方向に向かって±自分自身の画素10画素の画素値の平均\[
B_{x,y} = \frac{1}{21} \left( A_{x-10,y-10} + A_{x-9,y-9} + \cdots + A_{x,y} + \cdots + A_{x+9,y+9} + A_{x+10,y+10} \right)
\]を取っています。

3. 鮮鋭化

「3. 平滑化」で出てきたフィルタ、 元の画像の画素値変化（濃淡変化）を小さくすることで、元画像をぼかした画像を生成するフィルタでしたね。

鮮鋭化は、「3. 平滑化」とは反対に元の画像の画素値変化（濃淡変化）を大きくする変換をするフィルタです。

鮮鋭化フィルタを適用することで、画像の濃淡変化を大きくした画像（＝元画像のエッジを強調した画像）を生成することができます。

具体的には、各画素ごとに、「自分自身の画素を定数倍（＝強調）し、周りの画素値を一定量引いたもの」を新たな画素値にしていきます。\[\left( \begin{array}{ccc} \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{red}{9} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \end{array} \right), \ \ \
\left( \begin{array}{ccc} \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{red}{25} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \\ \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} & \textcolor{blue}{-1} \end{array} \right)
\]

「自分自身の画素値を定数倍＋周りの画素値を一定値引く」ため隣り合う画素同士の画素値の差が増え、濃淡変化が大きくなるため、元画像のエッジを強調した画像が生成されます。

なお、「3. 平滑化」のときと同じように、範囲が広いフィルタの方が、よりフィルタが強く作用します。

4. 1次微分によるエッジ抽出

皆さんは高校時代に「微分」について学びましたね。

ここで、「画像処理の世界でも微分って出てくるの？」と思った人も多いと思います。実は、微分

(1) 画素の微分とは

ある関数 \( f(x) \) を微分したもの（導関数） \( f'(x) \) は\[
f'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}
\]で計算できるのでしたね。

日本語でいうと、「\( x \) をほんの少し増やしたときの、\( f(x) \) の変化の度合い」を表したのが導関数ですね。

なので、画像を微分すると「画素値の変化の度合い」が得られそうな感じがしますね。さらに、「画素値の変化の度合い」を得ることで、特に画素値が変化している部分（＝エッジ）を得ることができます。

しかし、微分をフィルタとして取り入れるためには、以下の2つの問題を解決する必要があります。

• 画像 \( A_{x,y} \) を関数として見る場合、1変数 \( f(x) \) ではなく、横方向 \( x \)、縦方向 \( y \) の2変数関数 \( f(x,y) \) で表現する必要があること
• \( h \to 0 \) という極限操作が画像処理の世界ではできないこと

というわけで、1つずつ順番に解決していきましょう。

(i) 2変数関数の微分とは

2変数関数 \( f(x,y) \) の微分ですが、下のように「\( x \) での微分」と「\( y \) での微分」のように、微分する変数を1つ指定し、それ以外の変数を定数として考えることで、高校時代で習った1変数の微分と同じような感覚で微分ができます。\[
\textcolor{blue}{ f_x(x,y) = \lim_{h \to 0} \frac{f(x+h,y) - f(x,y)}{h} }
\]\[
\textcolor{red}{ f_y(x,y) = \lim_{h \to 0} \frac{f(x,y+h) - f(x,y)}{h} }
\]この方法のことを、偏微分と呼びます。

※ 偏微分についてもっと知りたい人は、偏微分についての記事のリンクを貼っているので是非こちらのリンクをご覧ください。

[注意]

単に \( f'(x,y) \) と表すと \( x \), \( y \) どちらの変数で微分したかわからなくなるので、

• \( f(x,y) \) を \( x \) で微分した場合 → \( f_x (x,y) \)
• \( f(x,y) \) を \( y \) で微分した場合 → \( f_y (x,y) \)

と表記することにします^[1]なお、偏微分を正式に表す場合は、\[
f_x (x,y) = \frac{ \partial }{ \partial x } f(x,y) , \ \ \ f_y (x,y) = \frac{ \partial }{ \partial y } f(x,y)
\]と表記します。。

(ii) 画像処理での微分の表現

画像処理は、1画素単位での処理となるため、\( h \to 0 \) のように「0に近づける」のような操作ができません。

そこで、画像処理で微分を表現する場合は\[
f_x = \frac{f(x+h,y) - f(x,y)}{h}
\]\[
f_y = \frac{f(x,y+h) - f(x,y)}{h}
\]に対し、\( h = 1 \) を代入し、「隣り合う画素の差分を取る」ことで微分を表現します。

実際に \( h = 1 \) を代入すると、\( x \) 方向（横方向）・\( y \) 方向（縦方向）の微分は下の式で表されます。

[\( x \) 方向（横方向）の微分]\[
f_x(x,y) = f(x+1,y) - f(x,y)
\]

[\( y \) 方向（横方向）の微分]\[
f_y(x,y) = f(x,y+1) - f(x,y)
\]

(2) 1次微分フィルタ

(1)で導出した式\[
f_x(x,y) = f(x+1,y) - f(x,y)
\]\[
f_y(x,y) = f(x,y+1) - f(x,y)
\]をフィルタの形に書き換えることで、1次微分フィルタを導出できます。

[横方向 (\( x \) 方向) のフィルタ適用例]

横方向の1次微分フィルタを適用すると、横方向の画素値変化が可視化されるため、出力画像には縦方向のエッジが強く出てきます。

一方、縦方向の画素値変化は可視化されないため、横方向のエッジは出力画像にあまり出てきません。

[縦方向 (\( y \) 方向) のフィルタ適用例]

縦方向の1次微分フィルタを適用することで、縦方向の画素値変化が可視化されるため、出力される画像には横方向のエッジが強く出てきます。

一方、横方向の画素値変化は可視化されないため、縦方向のエッジは出力画像にあまり出てきません。

(3) 様々な1次微分フィルタ

画像の微分は、各画素ごとに「隣り合う画素の差分を取る」ことで求めることができるのですが、差分を取り方として、\[
f_x(x,y) = f(x+1,y) - f(x,y)
\]\[
f_y(x,y) = f(x,y+1) - f(x,y)
\]というとり方以外にも以外にも¥[
f_x(x,y) = f(x,y) - f(x-1,y)
\]\[
f_y(x,y) = f(x,y) - f(x,y-1)
\]で差分を取ることもできますね。

そのため、1次微分フィルタを下のように書くこともできます。

また、2つの差分のとり方\[
f_x(x,y) = f(x+1,y) - f(x,y) , \ \ \ f_x(x,y) = f(x,y) - f(x-1,y)
\]\[
f_y(x,y) = f(x,y+1) - f(x,y) , \ \ \ f_y(x,y) = f(x,y) - f(x,y-1)
\]の平均をとって、\[\begin{align*}
f_x(x,y) & = \frac{1}{2} \left[ \left\{ f(x+1,y) - f(x,y) \right\} + \left\{ f(x,y) - f(x-1,y) \right\} \right]
\\ & = \frac{1}{2} \left\{ f(x+1,y) - f(x-1,y) \right\}
\end{align*}\]

\[\begin{align*}
f_y(x,y) & = \frac{1}{2} \left[ \left\{ f(x,y+1) - f(x,y) \right\} + \left\{ f(x,y) - f(x,y-1) \right\} \right]
\\ & = \frac{1}{2} \left\{ f(x,y+1) - f(x,y-1) \right\}
\end{align*}\]とする方法もあります。

この方法の場合の1次フィルタは、下のようになります。

このように、同じ「横(縦)方向の1次微分」でも、フィルタの書き方が3通りもあるのです。

※ 3番目のフィルタの係数 \( \frac{1}{2} \) は省略して、\[
\left( \begin{array}{ccc} 0 & 0 & 0 \\ \textcolor{magenta}{- 1 } & 0 & \textcolor{deepskyblue}{ 1 } \\ 0 & 0 & 0 \end{array} \right) , \ \ \ \left( \begin{array}{ccc} 0 & 0 & 0 \\ \textcolor{magenta}{- 1 } & 0 & \textcolor{deepskyblue}{ 1 } \\ 0 & 0 & 0 \end{array} \right)
\]と表現することも多いです。（ただし出力される画像の画素値は2倍になる）

5. プレヴィットフィルタ

(1) 1次微分フィルタの欠点

「5. 1次微分フィルタ」では、エッジ（＝画素値が特に変化している部分）を得ることができるのでしたね。

しかし、同時に画像に含まれるノイズも1次微分フィルタにより強調されてしまいます。

そこで、

(2) プレヴィットフィルタの仕組み [横方向]

1次微分フィルタと同じようにプレヴィットフィルタにも横方向（\( x \) 方向）、縦方向（\( y \) 方向）それぞれのフィルタがありますが、まず横方向のプレヴィットフィルタから見ていきましょう。

横方向の1次微分フィルタでは、次の2つの式の\[
f(x+1,y) - f(x,y) , \ \ \ f(x,y) - f(x-1,y)
\]の平均値を出力画素値（＝偏導関数）とするのでしたね。

プレヴィットフィルタでは、この2つの式に加え、縦方向の前後の画素 \( y \pm 1 \) に対しても\[
f(x+1,y-1) - f(x,y-1) , \ \ \ f(x,y-1) - f(x-1,y-1)
\]\[
f(x+1,y+1) - f(x,y+1) , \ \ \ f(x,y+1) - f(x-1,y+1)
\]のように「隣り合う画素の差分を取る」ということをします。

これら6つの式の平均

\[\begin{align*}
g(x,y) & = \frac{1}{6} \left\{ f(x+1,y) - f(x,y) \right\} + \frac{1}{6} \left\{ f(x,y) - f(x-1,y) \right\}
\\ & + \frac{1}{6} \left\{ f(x+1,y-1) - f(x,y-1) \right\} + \frac{1}{6} \left\{ f(x,y-1) - f(x-1,y-1) \right\}
\\ & + \frac{1}{6} \left\{ f(x+1,y) - f(x,y) \right\} + \frac{1}{6} \left\{ f(x,y) - f(x-1,y) \right\}
\\ & = \frac{1}{6} \left\{ \textcolor{red}{f(x-1,y-1)} + \textcolor{blue}{f(x+1,y-1)} + \textcolor{deepskyblue}{f(x-1,y)} + \textcolor{magenta}{f(x+1,y)} + \textcolor{orange}{f(x-1,y+1)} + \textcolor{green}{f(x+1,y+1)} \right\}
\end{align*}\]

をとったフィルタが、プレヴィットフィルタ\[ \frac{1}{6}
\left( \begin{array}{ccc} \textcolor{red}{- 1 } & 0 & \textcolor{blue}{ 1 }\\ \textcolor{magenta}{- 1 } & 0 & \textcolor{deepskyblue}{ 1 } \\ \textcolor{orange}{- 1 } & 0 & \textcolor{green}{ 1 } \end{array} \right)
\]となります。

(3) プレヴィットフィルタの仕組み [縦方向]

縦方向のプレヴィットフィルタも、横方向のときと同じように1次微分で使った2つの式\[
f(x,y+1) - f(x,y) , \ \ \ f(x,y) - f(x,y-1)
\]に加え、横方向の前後の画素 \( x \pm 1 \) に対しても\[
f(x-1,y+1) - f(x,y) , \ \ \ f(x-1,y) - f(x,y-1)
\]\[
f(x+1,y+1) - f(x,y) , \ \ \ f(x+1,y) - f(x,y-1)
\]のように「隣り合う画素の差分を取った」式を作ります。

合計6つの式の平均

\[\begin{align*}
g(x,y) & = \frac{1}{6} \left\{ f(x,y+1) - f(x,y) \right\} + \frac{1}{6} \left\{ f(x,y) - f(x,y-1) \right\}
\\ & + \frac{1}{6} \left\{ f(x-1,y+1) - f(x-1,y) \right\} + \frac{1}{6} \left\{ f(x-1,y) - f(x-1,y-1) \right\}
\\ & + \frac{1}{6} \left\{ f(x+1,y+1) - f(x+1,y) \right\} + \frac{1}{6} \left\{ f(x+1,y) - f(x+1,y-1) \right\}
\\ & = \frac{1}{6} \left\{ \textcolor{red}{f(x-1,y-1)} + \textcolor{magenta}{f(x,y-1)} + \textcolor{orange}{f(x+1,y-1)} + \textcolor{blue}{f(x-1,y+1)} + \textcolor{deepskyblue}{f(x,y+1)} + \textcolor{green}{f(x+1,y+1)} \right\}
\end{align*}\]

をとったものが縦方向のプレヴィットフィルタとなります。

\[ \frac{1}{6}
\left( \begin{array}{ccc} \textcolor{red}{- 1 } & \textcolor{magenta}{ -1 } & \textcolor{orange}{- 1 } \\ 0 & 0 & 0 \\ \textcolor{blue}{ 1 } & \textcolor{deepskyblue}{ 1 } & \textcolor{green}{ 1 } \end{array} \right)
\]

6. ソーベルフィルタ

横/縦方向のブレットフィルタでは、下の6種類の方法で「隣り合う画素の差分を取る」ことをし、それらの平均をとっていましたね。

横方向ブレットフィルタ：平均化する数式一覧

縦方向ブレットフィルタ：平均化する数式一覧

ソーベルフィルタでも、同じように6種類の方法で「隣り合う画素の差分を取る」のですが、ソーベルフィルタの場合は、着目している画素と同じ方向に対して2倍の重みをつけてから平均化をします。

横方向ソーベルフィルタ：平均化する数式一覧

縦方向ブレットフィルタ：平均化する数式一覧

2倍の重みをつけたあとは、平均を取ればOKです。

[横方向ソーベルフィルタ]

導出)

\[\begin{align*}
g(x,y) & = \frac{2}{8} \left\{ f(x+1,y) - f(x,y) \right\} + \frac{2}{8} \left\{ f(x,y) - f(x-1,y) \right\}
\\ & + \frac{1}{8} \left\{ f(x+1,y-1) - f(x,y-1) \right\} + \frac{1}{8} \left\{ f(x,y-1) - f(x-1,y-1) \right\}
\\ & + \frac{1}{8} \left\{ f(x+1,y) - f(x,y) \right\} + \frac{1}{8} \left\{ f(x,y) - f(x-1,y) \right\}
\\ & = \frac{1}{8} \left\{ \textcolor{red}{f(x-1,y-1)} + \textcolor{blue}{f(x+1,y-1)} + \textcolor{magenta}{2 f(x-1,y)} + \textcolor{deepskyblue}{2 f(x+1,y)} + \textcolor{orange}{f(x-1,y+1)} + \textcolor{green}{f(x+1,y+1)} \right\}
\end{align*}\]

結果)\[ \frac{1}{8}
\left( \begin{array}{ccc} \textcolor{red}{- 1 } & 0 & \textcolor{blue}{ 1 }\\ \textcolor{magenta}{- 2 } & 0 & \textcolor{deepskyblue}{ 2 } \\ \textcolor{orange}{- 1 } & 0 & \textcolor{green}{ 1 } \end{array} \right)
\]

変換例)

[縦方向ソーベルフィルタ導出]

\[\begin{align*}
g(x,y) & = \frac{2}{8} \left\{ f(x,y+1) - f(x,y) \right\} + \frac{2}{8} \left\{ f(x,y) - f(x,y-1) \right\}
\\ & + \frac{1}{8} \left\{ f(x-1,y+1) - f(x-1,y) \right\} + \frac{1}{8} \left\{ f(x-1,y) - f(x-1,y-1) \right\}
\\ & + \frac{1}{8} \left\{ f(x+1,y+1) - f(x+1,y) \right\} + \frac{1}{8} \left\{ f(x+1,y) - f(x+1,y-1) \right\}
\\ & = \frac{1}{8} \left\{ \textcolor{red}{f(x-1,y-1)} + \textcolor{magenta}{2 f(x,y-1)} + \textcolor{orange}{f(x+1,y-1)} + \textcolor{blue}{f(x-1,y+1)} + \textcolor{deepskyblue}{2 f(x,y+1)} + \textcolor{green}{f(x+1,y+1)} \right\}
\end{align*}\]

結果)\[
\frac{1}{8}
\left( \begin{array}{ccc} \textcolor{red}{- 1 } & \textcolor{magenta}{ -2 } & \textcolor{orange}{- 1 } \\ 0 & 0 & 0 \\ \textcolor{blue}{ 1 } & \textcolor{deepskyblue}{ 2 } & \textcolor{green}{ 1 } \end{array} \right)
\]

変換例)

7. 2次微分フィルタ

(1) 2次微分が表すものとは

2次微分は、微分したもの \( f'(x) \) に対してさらに微分をすることをいいます。数式で書くと、\[
f''(x) = \lim_{h \to 0} \frac{f'(x+h) - f'(x)}{h}
\]となります。

日本語で説明すると

• \( x \) の変化量を表したものが \( f'(x) \) → 1次微分
• \( f'(x) \) の変化量を表したものが \( f''(x) \) → 2次微分

といえますね。

そのため、画像を2次微分すると「画素値の変化度合いの大小」が得られそうな感じがしますね。「画素値の変化度合いの大小」を得ることで、特に画素値が変化している部分（＝エッジ）を1次微分に比べて正確に得ることができます。

(2) 2次微分フィルタの導出

ここからは、（3×3の）2次微分フィルタを導出してみましょう。

\( x \) 方向 (縦方向) の2次微分

2変数関数の \( x \) に関する1次微分は、\[
f_x(x,y) = \lim_{h \to 0} \frac{f(x+h,y) - f(x,y)}{h}
\]で計算できるのでしたね。

\( x \) に関する2次微分は、\( x \) で1次微分した関数 \( f_x (x,y) \) に対して、さらにもう1度微分することで求めることができます。\[
f_{xx} (x,y) = \lim_{h \to 0} \frac{f_x(x+h,y) - f_x(x,y)}{h}
\]※ \( x \) に関する2次微分を適用した関数を \( f_{xx} \) で表記します^[2]\( \frac{ \partial^2}{ \partial x^2} \) と表記されることもあります。。

ただし、画像処理の世界では極限計算 \( h \to 0 \) ができないので、代わりに \( h = 1 \) とし、\[
f_{xx} (x,y) = f_x(x+1,y) - f_x(x,y)
\]を求めることで \( x \) に関する2次微分を求めます。

ここで、1次微分 \( f_x(x+1,y) \), \( f_x(x,y) \) は\[
f_x (x+1,y) = f(x+1,y) - f(x,y)
\]\[
f_x(x,y) = f(x,y) - f(x-1,y)
\]と書き換えることができますね^[3]1階微分の法則 \( f_x (x,y) = f_x (x+1,y) - f_x (x,y) \), \( f_x (x,y) = f_x (x,y) - f_x (x-1,y) \) より。

よって、2次微分を\[\begin{align*}
f_{xx} (x,y) & = f_x(x+1,y) - f_x(x,y)
\\ & = \left\{ f(x+1,y) - f(x,y) \right\} + \left\{ f(x,y) - f(x-1,y) \right\}
\\ & = \textcolor{magenta}{f(x+1,y)} \textcolor{green}{-2 f(x,y)} + \textcolor{deepskyblue}{f(x-1,y)}
\end{align*}\]と変形できるため、2次微分フィルタは\[
\left( \begin{array}{ccc} 0 & 0 & 0 \\ \textcolor{deepskyblue}{1} & \textcolor{green}{-2} & \textcolor{magenta}{1} \\ 0 & 0 & 0 \end{array} \right)
\]と導出できます。

[実際に横方向の2次微分フィルタを適用すると…？]

横方向の2次微分フィルタを適用することで、横方向の画素値変化が可視化されます。可視化された画像には縦方向のエッジが入っているのが特徴です。

\( y \) 方向 (横方向) の2次微分

\( x \) 方向のときと同じように、\( y \) に関する2次微分は、\( y \) で1次微分した関数 \( f_y (x,y) \) に対して、さらにもう1度微分することで求めることができます。\[
f_{yy} (x,y) = \lim_{h \to 0} \frac{f_y(x,y+h) - f_y(x,y)}{h}
\]※ \( y \) に関する2次微分を適用した関数を \( f_{yy} \) で表記します^[4]\( \frac{ \partial^2}{ \partial y^2} \) と表記されることもあります。。

ただし、先程も言った通り画像処理の世界では極限計算 \( h \to 0 \) ができないので、代わりに \( h = 1 \) とし、\[
f_{yy} (x,y) = f_y(x,y+1) - f_y(x,y)
\]を求めることで \( y \) に関する2次微分を求めます。

ここで、1次微分 \( f_y(x,y+1) \), \( f_y(x,y) \) は\[
f_y (x,y+1) = f(x,y+1) - f(x,y)
\]\[
f_y(x,y) = f(x,y) - f(x,y-1)
\]と書き換えられますね^[5]1階微分の法則 \( f_y (x,y) = f_y (x,y+1) - f_y(x,y) \), \( f_y (x,y) = f_y (x,y) - f_y(x,y-1) \) より。

よって、2次微分を\[\begin{align*}
f_{yy} (x,y) = f_y(x,y+1) - f_y(x,y)
\\ & = \left\{ f(x,y+1) - f(x,y) \right\} + \left\{ f(x,y) - f(x,y-1) \right\}
\\ & = \textcolor{magenta}{f(x,y+1)} \textcolor{green}{-2 f(x,y)} + \textcolor{deepskyblue}{f(x,y-1)}
\end{align*}\]と変形できるため、2次微分フィルタは\[
\left( \begin{array}{ccc} 0 & \textcolor{deepskyblue}{1} & 0 \\ 0 & \textcolor{green}{-2} & 0 \\ 0 & \textcolor{magenta}{1} & 0 \end{array} \right)
\]と導出できます。

縦方向の2次微分フィルタを適用することで、縦方向の画素値変化が可視化されます。可視化された画像には横方向のエッジが入っているのが特徴です。

8. ラプラシアンフィルタ

「7. 2次微分フィルタ」では、横方向・縦方向それぞれの画素値変化の度合いを可視化することができますが、一度に「横方向と縦方向両方」の画素値の度合いを可視化することができます。

そこで、\( x \) に関する2次微分 \( f_{xx} (x,y) \) と、\( y \) に関する2次微分 \( f_{yy} (x,y) \) を足したフィルタを考えましょう。（ラプラシアンフィルタと呼ばれます^[6]2変数関数 \( f(x,y) \) のラプラシアンが\[ f_{xx} (x,y) + f_{yy} (x,y) \]で定義されることから名前が付けられています。。）

ここで、\[
f_{xx} = f(x+1,y) - 2 f(x,y) + f(x-1,y)
\]\[
f_{yy} = f(x,y+1) - 2 f(x,y) + f(x,y-1)
\]なので、\( f_{xx} (x,y) \) と \( f_{yy} (x,y) \) を足した和 \( g(x,y) \) は\[\begin{align*}
g(x,y) & = f_{xx} (x,y) + f_{yy} (x,y)
\\ & = \left\{ f(x+1,y) - 2 f(x,y) + f(x-1,y) \right\} + \left\{ f(x,y+1) - 2 f(x,y) + f(x,y-1) \right\}
\\ & = \textcolor{red}{f(x-1,y)} + \textcolor{orange}{f(x,y-1)} \textcolor{green}{-4 f(x,y)} + \textcolor{deepskyblue}{ f(x, y+1) } + \textcolor{blue}{ f(x+1,y) }
\end{align*}\]となるため、ラプラシアンフィルタは\[
\left( \begin{array}{ccc} 0 &\textcolor{red}{1} & 0 \\ \textcolor{orange}{1} & \textcolor{green}{-4} & \textcolor{deepskyblue}{1} \\ 0 & \textcolor{blue}{1} & 0 \end{array} \right)
\]と求められます。

9. 練習問題

最後に、練習問題で軽くフィルタについておさらいしておきましょう。

練習問題

ある画像に対して、次の(1)～(3)で示されるフィルタを加えたときの出力画像を表した説明として、正しいものを1つずつ選び番号で答えなさい。

[選択肢]

1. 元画像のエッジが強調された画像が出力された。
2. 元画像がぼやけた画像が出力された。
3. 元画像のエッジ部分だけが出力された。

[解説]

(1) 2 → 平滑化
(2) 1 → 鮮鋭化
(3) 3 → ラプラシアンフィルタ

前回は1文字だけの先読みで構文解析ができる文法であるLL(1)文法について説明していきました。

うさぎでもわかるコンパイラ　第3羽　First・Follow・Director集合とLL(1)文法の判定

こんにちは、ももやまです。 コンパイラ（言語処理系）の勉強をしていると、 LL(1)文法First集合Follow集合Director集合 などの不思議な用

しかし、文法の中に左再帰な規則が入ってしまうと、文法内の他の規則に関わらず、絶対にLL(1)文法となることはありません。言い換えると、左再帰な規則は先読みしながらの構文解析の壁の1つといえます。

そこで今回は、

• そもそも左再帰とは？
• 左再帰な規則が入るとLL(1)文法でなくなる理由
• 左再帰の除去（例題・練習問題あり）

について、お勉強していきましょう。

※

1. 左再帰・左再帰文法とは？

左再帰(規則)とは、生成規則の中に生成元の非終端記号と生成先の文字列の1文字目(先頭)が同じになっている規則、つまり規則中に \( \textcolor{red}{A} \to \textcolor{blue}{A} \alpha \) となる規則のことをさします。

また、左再帰 \( \textcolor{red}{A} \to \textcolor{red}{A} \alpha \) が含まれている文法のことを左再帰文法と呼びます。（ただし \( \alpha \not = \varepsilon \)）

例えば、生成規則が\[\begin{align*}
P = \{ \ \ \ \ S & \to aA \\ \textcolor{red}{A} & \textcolor{red}{\to Aba} \ | \ cd \\ B & \to Sc \ | \ a \ \ \ \ \ \ \ \}
\end{align*}
\]で表される文法は、左再帰 \( \textcolor{red}{A \to Aba } \) が含まれていますね。そのため、この文法は左再帰文法です。

左再帰文法には、左再帰の核部分 \( \textcolor{red}{A} \to \textcolor{red}{A} \alpha \) に加えて再帰をストップする規則の形 \( A \to \beta \) が含まれているのが特徴です。

[余談1] 右再帰とは？

「左再帰があるなら、右再帰な文法もあるんじゃね？」と思った人もいると思います。

想像の通り、右再帰もあります。具体的には、\( \textcolor{red}{A} \to \alpha \textcolor{blue}{A} \) の形の規則を右再帰と呼び^[1]日本語で説明すると、生成元の非終端記号と生成先の文字列の終端が同じになっている規則が右再帰です。、右再帰な規則が含まれている文法のことを右再帰文法と呼びます。（左再帰の時と同じく \( \alpha \not = \varepsilon \)）

右再帰文法も、左再帰文法と同じように規則の核部分に加えて再帰をストップする規則の形 \( A \to \beta \) が含まれているのが特徴です。

[余談2] 間接的な左(右)再帰

下の文法\[
\textcolor{red}{A \to Bb, \ \ \ B \to Aa} , \ \ \ A \to \alpha
\]のように、見た目的には左再帰になっていないものの、規則を適用していくと、\[
\textcolor{red}{A} \xrightarrow{A \to Bb} Bb \xrightarrow{B \to Aa} \textcolor{red}{A}ab
\]のように左再帰な形が出てくる規則のことを、間接左再帰と呼びます^[2]一方、見た目的に明らかな左再帰の形 \( \textcolor{red}{A} \to \textcolor{red}{A} \alpha \) をしている左再帰のことを、直接左再帰と呼ぶこともあります。。

同じように下の文法\[
\textcolor{blue}{A \to bB, \ \ \ B \to aA} , \ \ \ A \to \alpha
\]のように、見た目的には右再帰になっていないものの、規則を適用していくと、\[
\textcolor{blue}{A} \xrightarrow{A \to bB} bB \xrightarrow{B \to aA} ba \textcolor{blue}{A}
\]のように右再帰な形が出てくる規則のことを、間接右再帰と呼びます^[3]一方、見た目的に明らかな右再帰の形 \( \textcolor{blue}{A} \to \alpha \textcolor{blue}{A} \) が含まれている場合、直接右再帰と呼ぶこともあります。。

※ 今回の記事では、\( A \to A \alpha \) の形が出てくる直接的な左再帰の除去だけについて説明します。（間接的な左再帰の除去は本記事では割愛します。）

2. 左再帰文法の問題点

左再帰が含まれている文法（左再帰文法）の最大の問題点は、絶対にLL(1)文法とはならないからです。言い換えると、左再帰が含まれている文法は、1文字先読みすることで後戻りなしに構文解析することができません。

LL(1)文法にならない理由を具体例を踏まえてみていきましょう。

例えば、次の左再帰規則\[
A \to Aa , \ \ A \to b
\]を持つ文法があったとします。（出発記号 \( A \)）

ここで、もしLL(1)文法であれば、1文字先読みするだけで \( A \to Aa \), \( A \to b \) のどちかを判別することができますよね。

しかしこの2つの規則は、

• \( A \to \textcolor{red}{A} a \)：生成先の先頭 \( A \) は最終的に \( A \to b \) により \( b \) になる
• \( A \to \textcolor{ded}{b} \) ：生成先の先頭 \( \textcolor{red}{b} \) である

ため、1文字先読みしたとしても、どちらの規則を適用すればよいかわかりません。

厳密に証明してみる

[お知らせ] 証明で使うDirector集合・First集合・Follow集合の解説はこちらで行っています。

もっと厳密に、Director集合を使って左再帰規則\[
A \to A \alpha , \ \ A \to \beta
\]がLL(1)文法でないことを示してみましょう。

まず、生成規則 \( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{Aa} \) に関するDirector集合 \( \mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{A \alpha} ) \) は、\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{A \alpha} ) & = \mathrm
{First} ( \textcolor{deepskyblue}{A \alpha} )
\\ & = \mathrm{First} ( A )
\\ & = \mathrm{First} ( \beta )
\end{align*}\]と計算できます。

※ \( \varepsilon \notin \mathrm{First} ( A \alpha) = \mathrm{First} ( \beta ) \) の条件を仮定

また、 \( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{ \beta } \) に関するDirector集合は、 \( \varepsilon \notin \mathrm{First} ( \beta ) \) のとき\[\begin{align*}
& = \mathrm{First} (\textcolor{deepskyblue}{A \alpha} )
\\ & = \mathrm{First} (A)
\\ & = \mathrm{First} ( \beta )
\end{align*}\]と計算できます。

※ \( \varepsilon \notin \mathrm{First} ( \beta ) \) の条件を仮定

よって、\( \varepsilon \notin \mathrm{First} ( \beta ) \) のときに\[
\mathrm{Director} ( A , A \alpha ) \cap \mathrm{Director} ( A , \beta ) = \mathrm{First} ( \beta )
\]が成立するため、LL(1)文法ではない。

※ ほんの一部の条件に対してでもDirector集合の積集合が \( \phi \) 以外になったらLL(1)文法ではない。

右再帰文法は大丈夫なの？

右再帰文法（生成規則に右再帰が含まれている）だからといって絶対にLL(1)文法ではなくなるとは限りません。

例えば、\[
A \to a A , \ \ \ A \to b
\]のような文法は \( A \to aA \) が含まれているため右再帰文法ですが、

• \( A \to \textcolor{red}{a} A \)：生成先の先頭 \( A \) は \( a \) である
• \( A \to \textcolor{blue}{b} \) ：生成先の先頭 \( A \) は \( b \) である

のため、生成先の先頭文字を見るだけで \( A \to aA \), \( A \to b \) のどちらを適用すべきかが一意に定まりますね。そのため、LL(1)文法と言えます^[4]厳密に示したい場合は\[\begin{align*}\mathrm{Director} ( A, aA) \cap \mathrm{Director} (A, b) & = \mathrm{First} (a) \cap \mathrm{First} (b)\\ & = \{ a \} \cap \{ b \}\\ & = … Continue reading。

3. 左再帰の除去

(1) 左再帰除去の手順

左再帰文法は、次の公式を使うことによって簡単に左再帰ではない文法に書き換えることができます。

[公式導出] (やみくもに丸暗記するのではなく、導出過程を理解してから覚えましょう！)

まず最初に左再帰が含まれる規則\[
A \to A \alpha \ | \ \beta
\]にはどのような文字列が含まれるかを書きだしてみましょう。

すると、

• \( \beta \)
• \( \beta \alpha \)
• \( \beta \alpha \alpha \)
• \( \beta \alpha \alpha \alpha \)

のように、\( \beta \) が1文字来たあとに \( \alpha \) が連続するような文字列\[
\beta \underbrace{ \alpha \alpha \alpha \cdots }_{\mathrm{0 \ 回以上繰り返し}}
\]が当てはまることがわかりますね。

つまり、左再帰の規則を書き換える際には、左再帰ではない規則で\[
\beta \underbrace{ \alpha \alpha \alpha \cdots }_{\mathrm{0 \ 回以上繰り返し}}
\]となる文字列を表せればOKです。

ここからは、左再帰規則\[
A \to A \alpha \ | \ \beta
\]を左再帰でない規則に書き換えるために文字列\[
\textcolor{red}{\beta} \textcolor{blue}{ \underbrace{ \alpha \alpha \alpha \cdots }_{\mathrm{0 \ 回以上繰り返し}} }
\]を [ア] \( \beta \) の部分と [イ] \( \alpha \) の繰り返し部分に分けます。

[ア] \( \beta \) の部分

\( \beta \) の部分は1回だけ \( \beta \) を出力するために新しい非終端記号 \( A' \) を使って\[
\textcolor{red}{A \to \beta A'}
\]とします。

[イ] 0回以上の \( \alpha \) 繰り返しの部分

つぎに、\( A' \) の部分で0回以上の \( \alpha \) の繰り返しを左再帰を使わずに表します。ここで左再帰は使ったらダメだけど、右再帰を使ったらダメとは一言も言っていない点が重要です。

そのため、0回以上の \( \alpha \) の繰り返しは右再帰\[
\textcolor{blue}{ A' \to \alpha A' \ | \ \varepsilon }
\]を使って表現します。

※ \( \alpha \) は0回以上の繰り返し（＝空文字も含める）なので、右再帰をストップする条件は \( A' \to \varepsilon \) となります。

(a), (b)をまとめる

あとは [ア] と [イ] の規則を合わせるだけで、左再帰の除去をした（元の文法と等価な）文法の完成です！\[\begin{align*}
\textcolor{red}{A} & \textcolor{red}{\to \beta A'} \\
\textcolor{blue}{A'} & \textcolor{blue}{\to \alpha A' \ | \ \varepsilon}
\end{align*}\]

(2) 例題で確認 [左再帰の除去]

[解説1]

(1)

生成規則 \( \textcolor{red}{A} \to \textcolor{blue}{A}cb \) において、生成元の非終端記号と生成先の1文字目(先頭文字)が一致しているため。

(2)

左再帰が発生している部分について、下のように \( \textcolor{red}{\alpha} \), \( \textcolor{blue}{\beta} \) をおきます。\[
A \to A \textcolor{red}{ \underbrace{ cb }_{\alpha} } \ | \ \textcolor{blue}{ \underbrace{ b }_{ \beta } }
\]

あとは、左再帰の除去規則を使って規則を書き換えればOKです。\[\begin{align*}
A & \to \textcolor{blue}{ \underbrace{ b }_{ \beta } } A' \\
A' & \to \textcolor{red}{ \underbrace{ cb }_{\alpha} } A' \ | \ \varepsilon
\end{align*}\]

左再帰の発生に関係のない非終端記号（今回の場合は \( A \) 以外）の生成規則\[
S \to AaB , \ \ \ B \to Sc \ | \ d
\]はそのままでOKなので、文法 \( G \) と等価な左再帰ではない文法 \( G' \) は、\[
G' = \left( \ \{ S,A, \textcolor{magenta}{A'} ,B \} \ , \ \{ a,b,c,d \} \ , \ \textcolor{magenta}{P'} \ , \ S \ \right)
\]\[\begin{align*}
\textcolor{magenta}{P'} = \{ \ \ \ \ S & \to AaB \\
A & \to \textcolor{blue}{ b } A' \\
A' & \to \textcolor{red}{ cb } A' \ | \ \varepsilon
\\ B & \to Sc \ | \ d \ \ \ \ \ \ \ \}
\end{align*}
\]となります。

※ ピンク色を付けて書いた部分は忘れがちなので要注意！

(3) 左再帰が複数含まれる場合

下のように左再帰が複数含まれる規則\[\begin{align*}
\textcolor{magenta}{A} & \textcolor{magenta}{\to A \alpha_1 \ | \ A \alpha_2 \ | \ \cdots} \\\
\textcolor{deepskyblue}{A} & \textcolor{deepskyblue}{\to \beta_1 \ | \ \beta_2 \ | \ \cdots}
\end{align*}\]であっても、左再帰の適用が可能です。

[色の意味]

桃色の規則 … 左再帰の核となる \( A \to A \alpha_k \) が含まれた規則
水色の規則 … 左再帰をストップする規則 \( A \to \beta_k \) が含まれた規則^[5]\( A \) が生成元で、生成先の先頭が \( A \) で始まらない（つまり桃色の規則に当てはまらない）規則は全て水色の規則に含まれる。（ \( A \to bA \) … Continue reading

左再帰が含まれていない \( A \to A \alpha_k \) が含まれた規則

(4) 例題で確認 [左再帰が複数含まれる場合]

左再帰の直接的な原因は \( \textcolor{magenta}{B \to BaA} \), \( \textcolor{magenta}{B \to BS} \) の2つ（共に \( B \) が生成元の規則）ですね。

ここで、\( B \) が生成元の規則は先ほどの2つのほかに \( \textcolor{deepskyblue}{B \to aa} \), \( \textcolor{deepskyblue}{B \to dBa} \), \( \textcolor{deepskyblue}{B \to Cd} \) の3つがあります。

なので、文字列を\[\begin{align*}
B & \to B \underbrace{ aA }_{ \alpha_1 } \ | \ B \underbrace{ S }_{ \alpha_2 } \\
B & \to \underbrace{ aa }_{ \beta_1 } \ | \ \underbrace{ dBa }_{ \beta_2 } \ | \ \underbrace{ Cd }_{ \beta_3 }
\end{align*}\]とおきましょう。

あとは、左再帰の除去公式で置き換えてあげればOKです！\[\begin{align*}
B & \to \underbrace{ aa }_{ \beta_1 } B' \ | \ \underbrace{ dBa }_{ \beta_2 } B' \ | \ \underbrace{ Cd }_{ \beta_3 } B' \\
B' & \to \underbrace{ aA }_{ \alpha_1 } B' \ | \ \underbrace{ S }_{ \alpha_2 } B' \ | \ \varepsilon
\end{align*}\]

左再帰の発生に関係のない非終端記号（今回の場合は \( A \) 以外）の生成規則はそのままでOKなので、文法 \( G \) と等価かつ左再帰ではない文法 \( G' \) は、\[
G' = \left( \ \{ S,A, B, \textcolor{magenta}{B'} \} \ , \ \{ a,b,c,d \} \ , \ P' \ , \ S \ \right)
\]\[\begin{align*}
P' = \{ \ \ \ \
S & \to aBc \\
A & \to bB \ | \ aA \\
\textcolor{magenta}{B} & \textcolor{magenta}{\to aa B' \ | \ dBaB' \ | \ CdB'} \\
\textcolor{magenta}{B'} & \textcolor{magenta}{ \to aAB' \ | \ S B' \ | \ \varepsilon } \\
C & \to cc \ | \ ccc
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \}
\end{align*}
\]となります。（ピンク色を付けて書いた部分が変更箇所）

5. 練習問題

それでは、今回習った左再帰の除去について2問の練習問題を用意しました。

練習1. 左再帰が1つの場合

練習2. 左再帰が複数ある場合

6. 練習問題の答え

解答1. 左再帰が1つの場合

(1)

生成規則 \( \textcolor{red}{S} \to \textcolor{blue}{S} ab \) において、生成元の非終端記号と生成先の1文字目(先頭文字)が一致しているため。

(2)

まず、左再帰が発生している \( S \) が生成元の規則に対して、\( \textcolor{red}{\alpha} \), \( \textcolor{blue}{\beta} \) を以下のようにおく。\[
S \to S \textcolor{red}{ \underbrace{ ab }_{\alpha} } \ | \ \textcolor{blue}{ \underbrace{ c }_{\beta} }
\]

あとは、左再帰の除去規則を使って規則を書き換えればOK。\[\begin{align*}
S & \to \textcolor{blue}{ \underbrace{ c }_{ \beta } } S' \\
S' & \to \textcolor{red}{ \underbrace{ ab }_{\alpha} } S' \ | \ \varepsilon
\end{align*}\]

左再帰の発生に関係のない非終端記号（今回の場合は \( S \) 以外）の生成規則はそのままでOKなので、文法 \( G \) と等価な左再帰ではない文法 \( G' \) は、\[
G' = \left( \ \{ S,A, \textcolor{magenta}{A'} ,B \} \ , \ \{ a,b,c,d \} \ , \ \textcolor{magenta}{P'} \ , \ S \ \right)
\]\[
\begin{align*}
P' = \{ \ \ \ \
S & \to \textcolor{blue}{ c } S' \\
S' & \to \textcolor{red}{ ab } S' \ | \ \varepsilon \\
A & \to BaA \ | \ a \\
B & \to cA \ | \ bb
\ \ \ \ \ \ \ \}
\end{align*}
\]となる。

解答2. 左再帰が複数の場合

左再帰の直接的な原因は \( \textcolor{magenta}{C \to Cab} \), \( \textcolor{magenta}{C \to Cb} \), \( \textcolor{magenta}{C \to CBS} \) の3つ（共に \( C \) が生成元の規則）。

また、\( C \) が生成元の規則は先ほどの3つのほかに \( \textcolor{deepskyblue}{C \to cc} \), \( \textcolor{deepskyblue}{C \to Ad} \) の2つがある。

なので、\( \alpha_1 \), \( \alpha_2 \), \( \alpha_3 \), \( \beta_1 \), \( \beta_2 \) を用いて文字列を\[\begin{align*}
C & \to C \underbrace{ ab }_{ \alpha_1 } \ | \ C \underbrace{ b }_{ \alpha_2 } \ | \ C \underbrace{ BS }_{ \alpha_3 } \\
C & \to \underbrace{ cc }_{ \beta_1 } \ | \ \underbrace{ Ad }_{ \beta_2 }
\end{align*}\]とおく。

あとは、左再帰の除去公式で置き換えるだけ。\[\begin{align*}
C & \to \underbrace{ cc }_{ \beta_1 } C' \ | \ \underbrace{ Ad }_{ \beta_2 } C' \\
C' & \to \underbrace{ ab }_{ \alpha_1 } C' \ | \ \underbrace{ b }_{ \alpha_2 } C' \ | \ \underbrace{ BS }_{ \alpha_3 } C' \ | \ \varepsilon
\end{align*}\]

左再帰の発生に関係のない非終端記号（今回の場合は \( S \) 以外）の生成規則はそのままでOKなので、文法 \( G \) と等価かつ左再帰ではない文法 \( G' \) は、\[
G' = \left( \ \{ S,A, B, C, \textcolor{magenta}{C'} \} \ , \ \{ a,b,c,d \} \ , \ P' \ , \ S \ \right)
\]\[\begin{align*}
P' = \{ \ \ \ \
S & \to dS \ | \ bbab \\
A & \to aA \ | \ bB \ | \ cC \ | \ d \\
B & \to b \ | \ Sb \\
C & \to cc C' \ | \ Ad C' \\
C' & \to ab C' \ | \ b C' \ | \ BS C' \ | \ \varepsilon
\ \ \ \ \ \}
\end{align*}\]となります。

7. さいごに

今回は、左再帰が含まれる文法（左再帰文法）と、左再帰の除去について説明していきました。

最後に左再帰の除去公式をおさらいしておきましょう！

左再帰文法の問題点や、左再帰の除去について少しでも理解していただけたのであれば本当にうれしいです！

コンパイラ（言語処理系）の勉強をしていると、

• LL(1)文法
• First集合
• Follow集合
• Director集合

などの不思議な用語が出てきますよね。しかも、これらの定義（特にFirst集合やFollow集合）の定義は少し難解です。

文法 \( G = ( V_N, V_T, P, S ) \)に関して、記号列 \( \alpha \in ( V_N \cup V_T )^* \)、非終端記号 \(A \in V_T \) について、\( \mathrm{First} \ ( \alpha ) \), および \( \mathrm{Follow} \) は次のように定義される。\[
\mathrm{First} \ ( \alpha ) = \left\{ a \mid a \in V_T , \alpha \overset{*}{\Rightarrow} a \cdots \right\}
\]\[
\mathrm{Follow} \ ( A ) = \left\{ a \mid a \in V_T , S \overset{*}{\Rightarrow} \cdots Aa \cdots \right\}
\]ただし \( \alpha \overset{*}{\Rightarrow} \varepsilon \) なら \( \varepsilon \in \mathrm{First} \ ( \alpha ) \) とする。

コンパイラ補助資料　佐々木晃 より

そこで今回は、

• LL(1)文法とはそもそも何か？
• First, Follow, Director集合を求めて何がうれしいのか
• First, Follow, Director集合の求め方

の3点を中心に、LL(1)文法とFirst・Follow・Director集合のお勉強をしていきましょう。

1. LL(1)文法とは

ある文字列 \( \alpha \) が文法規則を満たすかどうかを一番単純に調べる方法は、下のように「出発記号 \( S \) から変換規則を総当たりで試していき、試した中に \( \alpha \) が含まれるか」を調べることです。

しかし、やみくもに総当たりで試す方法は、処理的にかなり無駄が発生してしまいます^[1] … Continue reading。

そこで、構文解析をする際に1文字だけ先読みし、どの生成規則を使えばよいかを決めてから実際に変換していく方法が考えられました。

このように、1文字だけ先読みすれば、文字列を後戻りすることなく構文解析ができる（文法を満たすか確認できる）文法からなる文法のことをLL(1)文法と呼びます^[2] … Continue reading。

LL(1)文法とは言えない文法（＝1文字だけ先読みするだけでは文字列を後戻りせずに構文解析ができない）文法の例も見てみましょう。

例えば、非終端記号（かつ出発記号） \( S \)、終端記号 \( a \), \( b \)、生成規則\[
S \to aaS , \ \ S \to abS , \ \ S \to b
\]からなる文法規則があるとします。

この文法規則に \( \textcolor{red}{a} bab \) という文字列が当てはまるかどうかを1文字先読みで見ていきましょう。

しかし、1文字目 \( \textcolor{red}{a} \) が出てくる生成規則には、

• \( S \to \textcolor{red}{a} aS \)
• \( S \to \textcolor{red}{a} b S \)

の2つがあるため、1文字先読みしただけでは \( S \to aaS \), \( S \to abS \) どちらの生成規則を適用すればいいかわかりません。

この例から分かる通り、LL(1)文法かどうかは文法の生成規則のみで決まります。

ここで、LL(1)文法を満たす生成規則であるかを機械的に確認する手法として導入されたのがFirst・Follow・Director集合という概念なのです！

つぎの第2章からは、

• 実際にFirst, Follow, Director集合の求め方の解説
• なぜ機械的にLL(1)文法を満たすのかがわかるのか

の2点について解説していきます。

2. First集合

(1) First 集合とはなにか

First集合 \( \mathrm{First} ( \alpha ) \) は、「ある文字列 \( \textcolor{magenta}{\alpha} \) に対して生成規則を適用して（複数回適用OK）全て終端記号にした際に、先頭（1文字目）に出てくる可能性がある文字を集めた集合」を表します。

数式で書くと、\[
\mathrm{First} ( \textcolor{magenta}{\alpha} ) = \left\{ \textcolor{orange}{a} \mid \textcolor{orange}{a} \in \textcolor{green}{V_T} , \textcolor{magenta}{\alpha} \textcolor{deepskyblue}{\overset{*}{\Rightarrow}} \textcolor{orange}{a} \cdots \right\}
\]となります。（色部分を日本語の説明に対応させています）

例えば、\( \mathrm{First} ( \alpha ) = \{ a, b, c\} \) の場合、\( \alpha \) に生成規則を適用していった際に出来る文字列の先頭（1文字目）が \( a \), \( b \), \( c \) のいずれかであることを表します。

(2) First 集合で頭にいれておくべき公式

※ 公式を丸暗記するのではなく、理屈を理解してから頭に入れましょう。

規則1[R1] First(a) … 終端記号1文字 \( a \) の場合

終端記号 \( a \) は、これ以上生成規則を適用することが出来ない文字を表すのでしたね。そのため、\( a \) はどう頑張っても他の文字に変換されることはありません。

よって、終端記号1文字 \( a \) のFirst集合の要素は終端記号 \( a \) だけとなります。\[
\mathrm{First} ( a ) = a
\]※ 空文字 \( \varepsilon \) のFirst集合は、\( \mathrm{First} ( \varepsilon ) = \{ \varepsilon \} \) となります。言い換えると、\( \mathrm{First} ( \alpha ) = \{ \varepsilon \} \) は、\( \alpha \) が空文字であることを表します。

※ 以後、この規則を用いた変換をする場合は \( \overset{ \mathrm{R1} }{=} \) と = の上にR1（規則1）を用いていることを示します。

規則2[R2] First(A) … 非終端記号1文字の場合

非終端記号 \( A \) のFirst集合 \( \mathrm{First} ( A ) \) を求める際、下のように樹形図を書いていって先頭1文字目に出てる文字を地味に探しても正しい答えは出てきますが、列挙ミスが発生する場合があります。

なのでもう少し機械的に \( \mathrm{First} ( A ) \) を求めてみましょう。

例えば、\( A \to BC \) という生成規則があったとします。これを言い換えると、「\( BC \) に対して生成規則を適用し、すべて終端記号に変換した際に出てくる文字列」は、必ず「\( A \) に対して生成規則を適用し、すべて終端記号に変換した際に出てくる文字列」 として出てきますね。

言い換えると、「\( BC \) に生成先を適用してすべて終端記号にした際に出てくる先頭文字 \( \mathrm{First} (BC) \) の集合」の要素に、「\( A \) に生成先を適用してすべて終端記号にした際に出てくる先頭文字 \( \mathrm{First} (A) \) の集合」が含まれますね。

つまり、 \( \mathrm{First} ( A ) \) を機械的に求める手順としては、\( A \) から生成規則 \( A \to \alpha \), \( A \to \beta \), … を探していき、その生成先の文字列 \( \alpha \), \( \beta \), … のFirst集合 \( \mathrm{First} ( \alpha ) \), \( \mathrm{First} ( \beta ) \) の要素をすべてFirst集合 \( \mathrm{First} (A) \) の要素とすればOKです。

1つ例を見てみましょう。\( A \) から始まる生成規則 \( A \to \textcolor{red}{\varepsilon} \), \( A \to \textcolor{blue}{aB} \), \( A \to \textcolor{green}{Cb} \) が3つあったとします。

この場合、\( \mathrm{First} (A) \) の要素は、\( \mathrm{First} ( \textcolor{red}{ \varepsilon } ) \), \( \mathrm{First} ( \textcolor{blue}{ aB } ) \), \( \mathrm{First} ( \textcolor{green}{ Cb } ) \) の和\[
\mathrm{First} ( A ) = \underbrace{ \mathrm{First} ( \textcolor{red}{\varepsilon} ) }_{ A \to \textcolor{red}{\varepsilon} } \cup \underbrace{ \mathrm{First} ( \textcolor{blue}{a B} ) }_{ A \to \textcolor{blue}{ aB } } \cup \underbrace{ \mathrm{First} ( \textcolor{green}{Cb} ) }_{ A \to \textcolor{green}{Cb} }
\]となります。

ここで1点注意が必要です非終端記号 \( A \) から空文字 \( \varepsilon \) が生成される可能性があるときには、\( \mathrm{First}  ( A ) \) の要素に \( \varepsilon \) が加わる点に注意してください。

※ 以後、この規則を用いた変換をする場合は \( \overset{ \mathrm{R2} }{=} \) と = の上にR2（規則2）を用いていることを示します。

規則3[R3] First(αβ…) … 2文字以上の場合

First集合は、「文字列に生成規則を加えて全て終端記号にした際に、先頭に来る可能性がある終端記号」を表しているのでしたね。

そのため、（First集合を求めるだけであれば）最初の1文字さえわかってしまえば、（最初の1文字が空文字とはならない限り）残りの後ろは何が来ようが関係ありません。

よって、文字列 \( \alpha \beta \cdots \) のFirst集合 \( \mathrm{First} ( \alpha \beta \cdots ) \) は、\( \alpha \) に空文字が来ない限り（＝ \( \varepsilon \notin \mathrm{First} (\alpha ) \) の場合）は \( \mathrm{First} ( \alpha ) \) と等しくなります。

一方、\( \alpha \) に空文字が来る可能性があるとき（＝ \( \varepsilon \in \mathrm{First} (\alpha ) \) の場合）は、2文字目が先頭になる可能性があるため、1文字目に加えて2文字目 \( \beta \cdots \) の先頭文字 \( \mathrm{First} ( \beta \cdots ) \) も追加で調べます。つまり、\[
\mathrm{First} ( \alpha \beta \cdots ) = \left( \mathrm{First} ( \alpha ) - \{ \varepsilon \} \right) \cup \mathrm{First} ( \beta \cdots )
\]が成立します。

※ \( \varepsilon \) を引いた理由は、2文字目 \( \beta \) の先頭に空文字 \( \varepsilon \) が来ない場合、文字列 \( \alpha \beta \cdots \) に \( \beta \) の文字列が残り、文字列 \( \alpha \beta \cdots \) が空文字 \( \varepsilon \) になることはないからです。

まとめると、2文字以上の文字列 \( \alpha \beta \cdots \) のFirst集合 \( \mathrm{First} ( \alpha \beta \cdots ) \) は、\[
\mathrm{First} ( \alpha \beta \cdots ) = \left\{ \begin{array}{ccc} \mathrm{First} ( \alpha ) & \varepsilon \notin \mathrm{First} ( \alpha ) \\ \left( \mathrm{First} ( \alpha ) - \{ \varepsilon \} \right) \cup \mathrm{First} ( \beta \cdots ) & \varepsilon \in \mathrm{First} ( \alpha ) \end{array} \right.
\]で求めることができます。

※ 以後、この規則を用いた変換をする場合は \( \overset{ \mathrm{R3} }{=} \) と = の上にR3（規則3）を用いていることを示します。

注意: 左再帰 A → Aα が含まれる場合のFirst集合

\( \textcolor{red}{A} \to \textcolor{blue}{A} bc \) のように「生成先の文字列の先頭が生成元の文字列になっている」場合、First集合を求めていくと\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R2} }{=} \mathrm{First} (Abc)
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (A)
\end{align*}\]となり、求めたい集合 \( \mathrm{First} (A) \) が計算途中に出てくるというよくわからないことが起こります。

この形になった場合は、計算途中に出てくる \( \mathrm{First} (A) \) は無視してOKです。例えば、\[
\mathrm{First} (A) = \underbrace{ \mathrm{First} (A) }_{ \mathrm{無視} } \cup \mathrm{First} (b)
\]となった場合は、左辺にも右辺にも出てくる \( \mathrm{First} (A) \) を無視し、\[
\mathrm{First} (A) = \mathrm{First} (b)
\]として計算してください^[3] \( A \to Ab \) のように左再帰文法となる規則を適用しても、先頭文字列は \( A \) のまま変わらないため、無視しても問題ない。。

また、\[
\textcolor{red}{A \to Bb, \ \ \ B \to Aa} , \ \ \ A \to c
\]のように、見た目に左再帰になる生成規則は含まれてはいないものの、変形していくと、\[
\textcolor{red}{A} \to Bb \to \textcolor{red}{A}ab
\]のように間接的に左再帰の形が出てくる場合、\[\begin{align*}
\mathrm{First} ( A ) & = \mathrm{First} (B) \cup \mathrm{First} (c) \\
\mathrm{First} (B) & = \mathrm{First} (A)
\end{align*}\]のように、一意には答えを決定できないような形が出てくることがあります。

しかし、左再帰になる規則の部分だけに着目してみると、\( \mathrm{First} (A) = \mathrm{First} (B) \), \( \mathrm{First} (B) = \mathrm{First} (A) \) 以外の式が出てこず、特に新しい要素が足される気配（例えば \( \mathrm{First} (c) \) はありません。

そのため、間接的な左再帰が出てきた際（＝一意に答えが決定できないような形が出てきた場合）には、間接的な左再帰が出てくる式（例えば \( A \to B b \), \( B \to Aa \)）をすべて無視し、残りの生成規則からFirst集合を求めてください。ただし、間接的な左再帰に寄与している非終端記号（今回の例だと \(A \), \( B \)）同士のFirst集合は等しくなる点は忘れないでください。

今回の場合は、\( A \to Bb \), \( B \to Aa \), \( A \to c \) のうちの赤文字部分が間接的な左再帰なため、まずは間接的な左再帰とは関係ない生成規則 \( A \to c \) から\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R1} }{=} \mathrm{First} (c)
\\ & = \{ c \}
\end{align*}\]と求めます。さらに、間接的な左再帰に寄与している \(A \), \( B \) のFirst集合は等しくなるため、\[
\mathrm{First} (B) = \mathrm{First} (A) = \{ c \}
\]と求めることができます^[4]いったん\[\begin{align*}\mathrm{First} (A) & = \mathrm{First} (B) \cup \mathrm{First} (c)\\ & = \underbrace{ \mathrm{First} (A) }_{ \mathrm{無視} } \cup \mathrm{First} (c)\\ & = … Continue reading。

(3) 例題で確認！

ここからは、1題例題を実際に解いてみましょう。

解説の前に、First集合を求める手順について確認しておきましょう。

First(S) の求め方

\( S \) が生成元になる規則は、\( S \to \textcolor{red}{ aA } \) ただ1つですね。

そのため、\[\begin{align*}
\mathrm{First} (S) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} ( \textcolor{red}{aA} ) }_{S \to \textcolor{red}{aA} }
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (a)
\\ & \overset{ \mathrm{R1} }{=} \{ a \}
\end{align*}\]で計算できます。

First(A) の求め方

\( A \) が生成元になる規則は、\( A \to bBa \ | \ \varepsilon \)、つまり \( A \to \textcolor{red}{bBa} \) と \( A \to \textcolor{blue}{\varepsilon} \) の2つですね。

そのため、\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} ( \textcolor{red}{bBa} ) }_{A \to \textcolor{red}{bBa} } \cup \underbrace{ \mathrm{First} (\textcolor{blue}{\varepsilon}) }_{A \to \textcolor{blue}{\varepsilon}}
\end{align*}\]を求めればＯＫです。

ここで、それぞれのFirst集合は、\[\begin{align*}
\mathrm{First} (bBa) & \overset{ \mathrm{R3} }{=} \mathrm{First} (b)
\\ & \overset{ \mathrm{R1} }{=} \{ b \}
\end{align*}\]\[\begin{align*}
\mathrm{First} ( \varepsilon ) & \overset{ \mathrm{R1} }{=} \{ \varepsilon \}
\end{align*}\]となるため、求めたいFirst集合は\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R2} }{=} \mathrm{First} (bBa) \cup \mathrm{First} (\varepsilon )
\\ & = \{ b \} \cup \{ \varepsilon \}
\\ & = \{ b, \varepsilon \}
\end{align*}\]と計算できます。

First(B) の求め方

\( B \) が生成元になる規則は、\( B \to Sc \ | \ d \)、つまり \( B \to \textcolor{red}{Sc} \) と \( B \to \textcolor{blue}{d} \) の2つですね。

そのため、\[\begin{align*}
\mathrm{First} (B) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} ( \textcolor{red}{Sc} ) }_{B \to \textcolor{red}{Sc}} \cup \underbrace{ \mathrm{First} ( \textcolor{blue}{d} ) }_{B \to \textcolor{blue}{d}}
\end{align*}\]を求めればＯＫです。

ここで、それぞれのFirst集合は、\[\begin{align*}
\mathrm{First} (Sc) & \overset{ \mathrm{R3} }{=} \mathrm{First} (S)
\\ & \overset{(1) }{=} \{ a \}
\end{align*}\]\[\begin{align*}
\mathrm{First} ( d ) & \overset{ \mathrm{R1} }{=} \{ d \}
\end{align*}\]となるため、求めたいFirst集合は\[\begin{align*}
\mathrm{First} (B) & \overset{ \mathrm{R2} }{=} \mathrm{First} (Sc) \cup \mathrm{First} ( d )
\\ & = \{ a \} \cup \{ d \}
\\ & = \{ a,d \}
\end{align*}\]と計算できます。

※ \( \overset{(1) }{=}\) は、(1)の答え \( \mathrm{First} \ (S) = \{ a \} \) を使っていることを表しています。

3. Follow集合

(1) Follow 集合とはなにか

Follow集合 \( \mathrm{Follow} ( A ) \) は、「ある非終端記号1文字 \( \textcolor{magenta}{A} \) 以降の文字をの直後に来る可能性がある文字（終端記号）の候補を集めた集合」を表します。

数式で書くと、\[
\mathrm{Follow} ( \textcolor{magenta}{A} ) = \left\{ \textcolor{orange}{a} \mid \textcolor{orange}{a} \in \textcolor{green}{V_T} , \textcolor{magenta}{\alpha} \overset{*}{\Rightarrow} \cdots A \textcolor{orange}{a} \cdots \right\}
\]となります。（色部分を日本語の説明に対応させています）

例えば、\( \mathrm{Follow} ( A ) = \{ a, b \} \) の場合、\( A \) の後ろの文字列をすべて終端記号にした際、\( A \) の直後に来る文字列が \( a \), \( b \) のいずれかであることを表します。

1点注意が必要なのは、Follow集合の要素に「空文字 \( \varepsilon \)」が出てくることは絶対にありません。

その代わりに、「\( A \) の直後に来る文字はありません（＝\( A \) が文字列の終端になりますよ）」というのを表す記号 \( \$ \) がFollow集合の要素で使われます。

(2) Follow 集合で頭にいれておくべき3つの公式

各非終端記号に対してFollow集合を求めていくときには、公式1～公式3で出てきた要素すべての和を取ることで求めます。

そこで、この「(2) Follow集合で頭にいれておくべき3つの公式」では、公式1～公式3の式の紹介だけでなく、何故この式でFollow集合が求められるのかまで説明していきます。

公式1. 出発記号 S の直後は必ず文字列の終端 $

文脈自由文法では、下のようにどの文字列も出発記号 \( S \) から与えられた生成規則により変換されていき、導出されます。\[
S \xrightarrow{S \to AaB} AaB \xrightarrow{A \to aA} aAaB \xrightarrow{A \to a} aaaB \xrightarrow{B \to b} aaab
\]

そのため、出発記号の後ろは必ず文字列の終端となりますね。

そのため、最初に出発記号に対するFollow集合 \( \mathrm{Follow} (S) \) に対しては、文字列の終端を表す \( \$ \) を要素に追加します。\[
\mathrm{Follow} (S) + = \{ \$ \}
\]

※1: 出発記号ではない非終端記号に対しては何もしなくてOKです。
※2: \( X += Y \) は、（集合 \( X \) に含まれない）集合 \( Y \) の要素を集合 \( X \) に加えることを表します。数式で書くと、\( X = X \cup Y \) です。

公式2. 直後の文字が空文字にならない場合

Follow集合は、「ある非終端記号の直後に来る（終端記号の）文字の候補」を表すため、Follow集合を求める際には、まずは生成規則の生成元ではなく、生成先側の文字列に着目します。

例えば、\( S \to a \textcolor{magenta}{A} \textcolor{blue}{c} B \) という規則があったとします。この規則を適用すると、\( \textcolor{magenta}{A} \) の直後には必ず \( \textcolor{blue}{c} B \) という文字が来ますよね。

このように、\( S \to a \textcolor{magenta}{A} \textcolor{blue}{c} B \) のような求めたい非終端記号 \( \textcolor{magenta}{A} \) が生成されている規則を見つけ、その直後に来る文字（今回は \( c \)）を見つけ出す（＋非終端記号であれば終端記号に変換する）ことでFollow集合を求められそうですね。

もう少し一般化して、\( \mathrm{Follow} (A) \) の求め方を公式化していきましょう。

まず、求めたい非終端記号 \( \textcolor{magenta}{A} \) が生成されている規則を探し出し、生成先の文字列を \( \textcolor{magenta}{A} \) より前にある文字列 \( \textcolor{gray}{\alpha} \) と \( \textcolor{magenta}{A} \) より後ろにある文字列 \( \textcolor{blue}{\beta} \) に分け、\( S \to \textcolor{gray}{\alpha} \textcolor{magenta}{A} \textcolor{blue}{\beta} \) の形にします。

例えば、\( S \to a \textcolor{magenta}{A} cB \) であれば、\[
S \to \textcolor{gray}{ \underbrace{a}_{\alpha}} \textcolor{magenta}{A} \textcolor{blue}{\underbrace{cB}_{\beta}}
\]より、\( \textcolor{gray}{\alpha = a} \), \( \textcolor{blue}{\beta = cB} \) となります。

※1 \( \textcolor{gray}{\alpha} \) はFollow集合の計算ではいらない子なので、求めなくてもOK。
※2 \( \alpha \), \( \beta \) に空文字が来てもOK。例えば、\( S \to \textcolor{gray}{a} \textcolor{magenta}{A} \) であれば、\( \textcolor{gray}{\alpha = a } \), \( \textcolor{blue}{\beta = \varepsilon} \) となる。

ここで、\( \mathrm{Follow} (A) \) というのは、\( A \) の直後に出てくる文字列でしたね。

また、先ほど生成規則を \( S \to \textcolor{gray}{\alpha} \textcolor{magenta}{A} \textcolor{blue}{\beta} \) と書き換えましたね。つまり、「 \( \textcolor{magenta}{A} \) の直後に出てくる文字列」というのは、「\( \textcolor{blue}{\beta} \) の先頭に来る文字列」と言い換えることができますね。さらにもう1段階言い換えると、「\( \textcolor{blue}{\beta} \) の先頭に来る文字列」は \( \mathrm{First} ( \textcolor{blue}{\beta} ) \) と書くことができますね。

そのため、生成規則 \( S \to \alpha \textcolor{magenta}{A} \textcolor{blue}{\beta} \) に対して、Follow集合に\[
\mathrm{Follow} ( \textcolor{magenta}{A} ) + = \mathrm{First} ( \textcolor{blue}{\beta} )
\]と \( \mathrm{First} ( \textcolor{blue}{\beta} ) \) を追加します。

ただし、First集合の要素に \( \varepsilon \) が含まれる場合は、\( \varepsilon \) を無視してからFollow集合に追加してください。例えば、\( S \to \alpha A \beta \) に対して、\( \mathrm{First} ( \beta ) = \{ b, c, \varepsilon \} \) であれば、\[\begin{align*}
\mathrm{Follow} ( A) + & = \mathrm{First} ( \beta )
\\ & =  \{ b,c \} 
\end{align*}\]と、Follow集合に \( b \), \( c \) の要素を加えます。そのため、\( S \to \alpha A \) のように \( A \) の直後の文字列 \( \beta \) がそもそも存在しない場合は、この公式でFollow集合の追加は行われません^[6]\( \beta \) がそもそも存在しない、つまり \( \beta = \varepsilon \) のときは、\( \mathrm{First} ( \beta ) = \mathrm{First} ( \varepsilon )  \overset{ \mathrm{R1} }{=} \{ … Continue reading。

さらに、\( \mathrm{First} ( \beta ) \) に \( \varepsilon \) が含まれる（＝ \( \beta \) が空文字になる可能性がある）場合や、\( S \to \alpha A \) のように、 そもそも \( A \) が生成先の文字列の末尾になる場合は公式2を確認します。

公式3. 直後の文字が空文字になる可能性がある場合

生成規則 \( S \to \alpha A \textcolor{blue}{\beta} \) において、

• \( \textcolor{blue}{\beta} \) 部分がそもそも存在しない
  （つまり \( A \to \alpha A \) となるとき）
• \( \textcolor{blue}{\beta} \) 部分が存在していた場合でも \( S \to \alpha \alpha A \textcolor{blue}{B} \), \( B \to \varepsilon \) のように \( \textcolor{blue}{\beta} \) に空文字が来る可能性がある場合
  （つまり \( \varepsilon \in \mathrm{First} ( \beta ) \) となる場合）

は、生成先 \( \alpha A \textcolor{blue}{\beta} \) に着目するだけでは、\( A \) の直後に来る文字列（＝ \( \mathrm{Follow} (A) \)）がわかりません。

ここで、\( S \) の直後の文字を \( \textcolor{blue}{X} \) としてから、\( S \textcolor{magenta}{X} \) に生成規則 \( \textcolor{purple}{S \to aA} \) を適用することを考えましょう。すると、\[ \textcolor{purple}{S} \textcolor{blue}{X} \to \textcolor{purple}{aA} \textcolor{blue}{X} \]となり、「\( A \) の直後の文字」が「\( S \) の直後の文字」と同じになっていることがわかりますね。

つまり、\( S \to \varepsilon \in \mathrm{First} ( \beta ) \) 、つまり \( \beta \) 部分が空文字になる（つまり \( \textcolor{blue}{S} \to a \textcolor{magenta}{A} \) となる）可能性がある場合は\[
\mathrm{Follow} ( \textcolor{magenta}{A} ) += \mathrm{Follow} ( \textcolor{blue}{S} )
\]と、生成元 \( \textcolor{blue}{S} \) の非終端記号の直後の文字、つまり \( \mathrm{Follow} (\textcolor{blue}{S}) \) を \( \mathrm{Follow} (\textcolor{blue}{A}) \) に追加します。

注意: 右再帰 A → αAが含まれる場合

\( \textcolor{red}{A} \to ab \textcolor{blue}{A} \) のように「生成先の文字列の終端が生成元の文字列になっている」生成規則の場合、\[\begin{align*}
\mathrm{Follow} (A) + & = \mathrm{Follow} (A)
\\ & = \mathrm{Follow} (A) \cup \mathrm{Follow} (A)
\end{align*}\]となるため、\( \mathrm{Follow} (A) \) に要素が一切追加されません。

そのため、右再帰 \( A \to \alpha A \) となる文法に対しては、Follow集合を求める際には無視してください。

特に注意が必要なのが、\[
A \to aB , \ \ \ B \to bA
\]のように見た目は右再帰な規則は含まれていないものの、変形してみると\[
A \to aB \to abA
\]のように間接的に右再帰な規則が含まれる場合です。

この場合、生成規則 \( A \to aB \) に対しては\( \textcolor{blue}{A} \to a \textcolor{magenta}{B} \) より\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{blue}{A} )
\\ & = \mathrm{Follow} (B) \cup \mathrm{Follow} (A)
\end{align*}\]が成立するため、\( \mathrm{Follow} (B) \) に対して、\( \mathrm{Follow} (A) \) の要素を追加されるような式が出てきます。

さらに、\( \mathrm{Follow} (A) \) を求めていきましょう。\( \textcolor{blue}{B} \to b \textcolor{magenta}{A} \) より\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{A} ) + & = \mathrm{Follow} ( \textcolor{blue}{B} )
\\ & = \mathrm{Follow} (A) \cup \mathrm{Follow} (B)
\end{align*}\] なり、\( \mathrm{Follow} (A) \) に対して \( \mathrm{Follow} (B) \) を追加するような式が出てきます。

すると、

• \( \mathrm{Follow} (A) \) を求めるためには追加される要素である \( \mathrm{Follow} (B) \) を求める必要がある
• \( \mathrm{Follow} (B) \) を求めるためには追加される要素である \( \mathrm{Follow} (A) \) を求める必要がある

という「無限ループ」が発生し、訳が分からないことが起こってしまいます。

ここで、式ではなく意味的に考えてみましょう。ある非終端記号 \( A \) Follow集合 \( \mathrm{Follow} (A) \) とは、「\( A \) の直後に来る非終端記号の候補を集めた集合」でしたね。

そこで、ある非終端記号 \( A \) を間接的な右再帰規則 \( A \to aB \), \( B \to bA \) だけで変換していくことで、Follow集合がどうなるかを見てみましょう。

すると、\( A \to aB \) の変化から、\( A \) の直後の非終端記号（\( \mathrm{Follow} (A) \)）と \( B \) の直後の非終端記号（\( \mathrm{Follow} (B) \) には変化がないことがわかりますね。また\( aB \to abA \) の変化から、\( B \) の直後の非終端記号（\( \mathrm{Follow} (B) \)）と \( A \) の直後の非終端記号（\( \mathrm{Follow} (A) \) にも変化がないことがわかりますね。

よって、\( A \to aB \), \( B \to bA \) のような間接的な右再帰規則が含まれている場合、Follow集合に追加されるような要素は存在しないこと、および \( \mathrm{Follow} (A) \), \( \mathrm{Follow} (B) \) が等しくなることがわかりますね^[7]\( \textcolor{blue}{A} \to a \textcolor{magenta}{B} \) より、\[\begin{align*}\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{magenta}{A} )\\ & = … Continue reading。

そのため、Follow集合を求める際には、直接的な右再帰規則 \( A \to \alpha A \) だけでなく、間接的な右再帰規則 \( A \to aB \), \( B \to bA \) が含まれている場合（＝一意に答えが決定できないような形が出てきた場合）でも、間接的な左再帰が出てくる式（例えば \( A \to aB \), \( B \to bA \) ）をすべて無視し、残りの生成規則からFollow集合を求めてください。ただし、間接的な左再帰に寄与している非終端記号（今回の例だと \(A \), \( B \)）同士のFirst集合は等しくなる点は忘れないでください。

Follow集合を求める際に使う3つの公式まとめ

Follow集合は[公式1]～[公式3]で出てきた要素の和で求められる。

※ ただし、\( X += Y \) は、\[
X = X \cup Y
\]を表す。（集合 \( Y \) の要素を集合 \( X \) に加える）

[公式1] 出発記号 \( S \) の場合は文字列の終端を表す \( \$ \) を追加する。\[\begin{align*}
\mathrm{Follow} (S) += \{ \$ \} \end{align*}\]

[公式1]適用後、各非終端記号 \( \textcolor{magenta}{A} \) ごとに、生成先に \( \textcolor{magenta}{A} \) が含まれる生成規則を

• \( A \) より前の文字列 \( \alpha \)
• \( A \) より後ろの文字列 \( \beta \)

に分けて \( S \to \textcolor{gray}{\alpha} \textcolor{magenta}{A} \textcolor{blue}{\beta} \) の形に分けたあと、公式1・公式2のどちらか（もしくは両方）を適用し、\( \mathrm{Follow} (\textcolor{magenta}{A}) \) に集合を追加する。

※ \( \textcolor{gray}{\alpha} \) と \( \beta \) は空文字でもOK。

例1: \( B \to \textcolor{magenta}{A} \textcolor{blue}{c} \) のとき： \( \textcolor{gray}{\alpha = \varepsilon} \), \( \textcolor{blue}{\beta = c} \)
例2: \( B \to \textcolor{gray}{d} \textcolor{magenta}{A} \) のとき： \( \textcolor{gray}{\alpha = d} \), \( \textcolor{blue}{\beta = \varepsilon} \)
例3: \( B \to\textcolor{magenta}{A} \) のとき： \( \textcolor{gray}{\alpha = \varepsilon} \), \( \textcolor{blue}{\beta = \varepsilon} \)

[公式2]

\( \textcolor{blue}{\beta} \) (空文字ではない)何かしらの文字列があれば、\( \mathrm{First} ( \beta) \) を除くすべての集合を \( \mathrm{Follow} (\textcolor{magenta}{A}) \) に加える。\[
\mathrm{Follow} (\textcolor{magenta}{A}) += \mathrm{First} ( \textcolor{blue}{\beta}) - \{ \varepsilon \}
\]※ \( \beta \) がそもそも空文字（つまり \( S \to \alpha A \)）の場合はこの公式を適用しない。

[公式3]

\( \beta \) がそもそも空文字（つまり \( \textcolor{blue}{S} \to \alpha \textcolor{magenta}{A} \)）もしくは空文字ではないが \( \mathrm{First} ( \beta ) \) の要素に \( \varepsilon \) が含まれる場合は、集合 \( S \) のFollow集合 \( \mathrm{Follow} (\textcolor{blue}{S}) \) を \( \mathrm{Follow} (\textcolor{magenta}{A}) \) に加える。 \[
\mathrm{Follow} (\textcolor{magenta}{A}) += \mathrm{Follow} (\textcolor{blue}{S})
\]

※ \( \textcolor{red}{A} \to \alpha \textcolor{red}{A} \) のような→再帰が含まれる文法が出てきた場合は無視する（間接的な右再帰、例えば \( A \to \alpha B \), \( B \to \beta A \) など）が出てきた場合も無視するが、間接的な左再帰に寄与する非終端記号（例の場合だと \( A \), \( B \)）同士のFollow集合は等しくなる。）。

(3) 例題で確認！

ここからは、例題1でも出てきた文法を使って、実際にFollow集合を求め方を見ていきましょう。

解説の前に、もう1度Follow集合を求める手順について確認しておきましょう。

Follow集合を求める手順

ある非終端記号 \( A \) のFollow集合 \( \mathrm{Follow} (A) \) はつぎの「準備」の後、下に示す公式[R1]と公式[R2]で出てくる要素を全て追加することで求められる。

[公式1] 出発記号かどうかの確認

\( A \) が出発記号であるか確認し、出発記号であれば要素に \( \$ \) を加えた状態でスタート。それ以外の場合は要素なしでスタート。

• \( A \) が出発記号である: \( \mathrm{Follow} (A) += \{ \$ \} \)
• \( A \) が出発記号でない: なにもしない

[公式2], [公式3] では \( S \to \textcolor{gray}{ab} \textcolor{magenta}{A} \textcolor{blue}{Bc} \) のような生成先に \( \textcolor{blue}{S} \) が出てくる規則それぞれに対し、\( S \to \textcolor{gray}{\alpha} \textcolor{magenta}{A} \textcolor{blue}{\beta} \) のように \( \textcolor{magenta}{A} \) の前の文字列 \( \textcolor{gray}{\alpha} \) と \( \textcolor{magenta}{A} \) の後の文字列 \( \textcolor{blue}{\beta} \) に分けてから考える。

※ \( \textcolor{gray}{\alpha} \), \( \textcolor{blue}{\beta} \) は空文字OK。例えば、\( S \to A \) であれば、\( \textcolor{gray}{\alpha} \), \( \textcolor{blue}{\beta} \) ともに空文字 \( \varepsilon \) となる。

[公式2] \( \beta \not = \varepsilon \) であれば適用

生成規則 \( S \to \textcolor{gray}{\alpha} \textcolor{magenta}{A} \textcolor{blue}{\beta} \) に対し、\( \textcolor{blue}{\beta} \) が空文字ではない場合、\( \mathrm{First} ( \textcolor{blue}{\beta} ) \) の要素を加える。ただし \( \varepsilon \) は加えない。\[
\mathrm{Follow} ( \textcolor{magenta}{A} ) += \mathrm{First} ( \textcolor{blue}{\beta} ) - \{ \varepsilon \}
\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \) であれば適用

\( \textcolor{blue}{S} \to \alpha \textcolor{magenta}{A} \) のように \( \beta = \varepsilon \) となる場合や、\( \textcolor{blue}{S} \to \alpha \textcolor{magenta}{A} \beta \) の形だが \( \varepsilon \in \mathrm{First} ( \textcolor{blue}{\beta} ) \) となる場合は、\( \mathrm{Follow} ( \textcolor{blue}{S} ) \) の要素を加える。\[
\mathrm{Follow} ( \textcolor{magenta}{A} ) += \mathrm{Follow} ( \textcolor{blue}{S})
\]

(1) Follow(S) の求め方

まず、\( S \) は出発記号なので、初期状態として要素 \( \$ \) を加えます。

つぎに、\( \textcolor{magenta}{S} \) が生成先に出てくる規則は、\( B \to \textcolor{magenta}{S} c \) 1つだけなので、この生成規則に着目しましょう。

着目した生成規則の生成先 \( \textcolor{magenta}{S} \textcolor{blue}{c} \) において、\( \textcolor{magenta}{S} \) より後の文字列は \( \textcolor{blue}{c} \) ですね。よって、\( \textcolor{blue}{\beta} = \textcolor{blue}{c} \) となります。

[公式2] \( \textcolor{blue}{ \beta = c } \not = \varepsilon \) なので〇

生成規則 \( B \to \textcolor{magenta}{S} \textcolor{blue}{ \underbrace{ c }_{ \beta } } \) より、\( \mathrm{Follow} ( \textcolor{magenta}{S} ) \) に追加される要素は、\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{S} ) + & = \mathrm{First} ( \textcolor{blue}{c} ) - \{ \varepsilon \}
\\ & \overset{ \mathrm{R1} }{=} \{ c \} - \{ \varepsilon \}
\\ & = \{ c \}
\end{align*}\]と求められます。よって、\( \mathrm{Follow} ( \textcolor{magenta}{S} ) \) に \( c \) が追加されます。

[公式3] \( \varepsilon \notin \mathrm{First} ( \textcolor{blue}{c} ) = \{ c \} \) なので×

よって、\[\begin{align*}
\mathrm{Follow} (S) & = \{ $ \} \cup \{ c \}
\\ & = \{ c, \$ \}
\end{align*}\]となります。

(2) Follow(A) の求め方

[公式1] \( A \) は出発記号ではないため×

つぎに、\( \textcolor{magenta}{A} \) が生成先に出てくる規則は、\( S \to aA \), \( A \to bBA \) の2つがありますが、\( \textcolor{deepskyblue}{A} \to bB \textcolor{deepskyblue}{A} \) は右再帰なので無視します。そのため、[公式2], [公式3] に当てはめる生成規則は \( S \to aA \) だけでOKです。

着目した規則の生成先 \( a \textcolor{magenta}{A} \) において、\( \textcolor{magenta}{A} \) より後の文字列はありません（＝空文字です）ね。よって、 \( \textcolor{blue}{\beta} = \textcolor{blue}{\varepsilon} \) です。

[公式2] \( \textcolor{blue}{ \beta = \varepsilon } \) なので×

[公式3] \( \varepsilon \in \mathrm{First} ( \textcolor{blue}{ \varepsilon } ) = \{ \varepsilon \} \) なので〇

生成規則 \( \textcolor{blue}{S} \to a \textcolor{magenta}{A} \) より、\( \mathrm{Follow} ( \textcolor{magenta}{A} ) \) に追加される要素は、

\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{A} ) + & = \mathrm{Follow} ( \textcolor{blue}{S} )
\\ & \overset{ \mathrm{(1)} }{=} \{ c, \$ \}
\end{align*}\]と求められます。よって、\( \mathrm{Follow} ( \textcolor{magenta}{A} ) \) に \( c, \$ \) が追加されます。

したがって、\( \mathrm{Follow} (A) \) は\[\begin{align*}
\mathrm{Follow} (A) & = \{ c, \$ \}
\end{align*}\]と計算できます。

(3) Follow(B) の求め方

[公式1] \( B \) は出発記号ではないため×

ここで、\( \textcolor{magenta}{B} \) が生成先に出てくる規則は、\( A \to b \textcolor{magenta}{B} A \) の1つだけですね。なので [公式2], [公式3] に当てはめる生成規則は \( A \to b \textcolor{magenta}{B} A \) だけです。

着目した生成規則の生成先 \( b \textcolor{magenta}{B} A \) において、\( \textcolor{magenta}{B} \) より後の文字列は \( \textcolor{blue}{A} \) ですね。よって、\( \textcolor{blue}{\beta} = \textcolor{blue}{A} \) となります。

[公式2] \( \textcolor{blue}{ \beta = A } \not = \varepsilon \) なので〇

生成規則 \( A \to \textcolor{gray}{b} \textcolor{magenta}{B} \textcolor{blue}{ \underbrace{ A }_{ \beta } } \) より、\( \mathrm{Follow} ( \textcolor{magenta}{B} ) \) に追加される要素は、\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{First} ( \textcolor{blue}{A} ) - \{ \varepsilon \}
\\ & = \{ b, \varepsilon \} - \{ \varepsilon \}
\\ & = \{ b \}
\end{align*}\]と求められます。よって、\( \mathrm{Follow} ( \textcolor{magenta}{B} ) \) に \( b \) が追加されます。

[公式3] \( \varepsilon \in \mathrm{First} ( \textcolor{blue}{ A } ) = \{ b, \varepsilon \} \) なので〇

生成規則 \( \textcolor{blue}{A} \to b \textcolor{magenta}{B} A \) より、\( \mathrm{Follow} ( \textcolor{magenta}{B} ) \) に追加される要素は、

\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{blue}{A} )
\\ & \overset{ \mathrm{(2)} }{=} \{ c, \$ \}
\end{align*}\]と求められます。よって、\( \mathrm{Follow} ( \textcolor{magenta}{B} ) \) に \( c, \$ \) が追加されます。

したがって、\( \mathrm{Follow} (B) \) は\[\begin{align*}
\mathrm{Follow} (B) & = \{ b \} \cup \{ c, \$ \}
\\ & = \{ b, c, \$ \}
\end{align*}\]と計算できます。

(4) Follow集合の計算ミスを防ぐコツ：図を書く

※ このアイデアは、国島 丈生様のこちらのサイトを参考にさせていただきました。
（FOLLOW()の計算を間違えにくくする工夫）

Follow集合は、First集合に比べて計算が複雑になるため、計算ミスがかなり出てきます^[8]実際に私もよく計算ミスします。。

そこで、今回の記事では下の図ように「Follow集合にどの集合の要素が追加されているか」を図で表現しています^[9]下の図の場合「\( \mathrm{Follow} (S) \) を求めるためには \( \mathrm{First} (c) \) と \( \{ \$ \} \) の要素を追加すればOK」ということを表しています。。

さらに、各非終端記号ごとに書いたFollow集合の計算図示を下のように1つにまとめることで、Follow集合同士の関係（どのFollow集合の要素がどのFollow集合に加えられているのか）も明確にすることができます。

図を書くことで、「矢印に従って集合を追加していく」するだけで簡単にFollow集合を求めることができます！

※ 追加時に \( \varepsilon \) が出てくる場合は無視してください。

さらに図を書くもう1つメリットは検算が容易にできることです。

理由は、「ある集合 \( A \) の要素を集合 \( B \) に追加」した場合、集合の包含関係 \( A \subseteq B \) は必ず成立するからです^[10]集合 \( B \) に集合 \( A \) の要素を追加したのに、集合 \( B \) の要素の中に集合 \( A \) … Continue reading。

例えば、下の図は \( \mathrm{First} (c) \) の要素を \( \mathrm{Follow} (S) \) に追加しているため、\( \mathrm{First} (c) \subseteq \mathrm{Follow} (S) \) が必ず成立します。

この包含関係を、書いた図の中に出てくる矢印それぞれ（下の図の場合は5か所）でチェックします^[11]具体的には、\( \{ $ \} \subseteq \mathrm{Follow} (S) \), \( \mathrm{First} (c) \subseteq \mathrm{Follow} (S) \), \( \mathrm{Follow} (S) \subseteq \mathrm{Follow} (A) \), \( \mathrm{First} (A) … Continue reading。矢印すべての箇所で包含関係が成り立っていればOKです。

※ 1つでも成り立っていないものがあれば、計算ミスをしています。

4. Director集合とLL(1)文法の判定

(1) Director集合とは

ある文法がLL(1)文法、つまり「1文字の先読みをするだけで、与えられた文字列を構文解析できる文法」とはどのような文法なのかをもう少し詳しく見ていきましょう。

例えば、文字列 \( baba \) が生成規則\[\begin{align*}
S & \to aS \\
S & \to bA \\
S & \to bAb \\
A & \to a
\end{align*}\]の文法を満たすか「1文字の先読み」で判定することを考えましょう。

まず、1文字目を先読みすると \( b \) となりますね。出発記号 \( S \) から \( \textcolor{blue}{b} \) で始まる規則を探そうとしますが、\( S \to \textcolor{blue}{b} A \) と \( S \to \textcolor{blue}{b} Ab \) の2つが存在してしまっているため、どちらの文法規則を使っていいかわかりません。

このように、同じ非終端記号から生成される文字列を終端記号にした文字列の先頭が\[
S \to \textcolor{blue}{b}A , \ \ \ S \to \textcolor{blue}{b} A b
\]のように重複していると、「1文字の先読みだけでは、どの構文規則を適用すればよいかわからなくなるため、与えられた文字列を構文解析できない」ことがわかりますね。

言い換えると、LL(1)文法であるかを判定するためには、同一非終端記号から生成されるすべての生成規則に対し、生成される可能性がある「終端記号の文字列の先頭文字」がすべて異なっていればOKですね。 

(2) Director集合の定義と計算公式

LL(1)文法であるかを機械的に判定するために登場したのがDirector集合です。

Director集合は、生成規則 \( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{\alpha} \) に対し、「\( \textcolor{magenta}{A} \) から生成される文字列 \( \textcolor{deepskyblue}{\alpha} \) をすべて終端記号にしたときの先頭に来る文字の候補」を表しており、\[
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{\alpha} )
\]と表記します。

[Director集合の計算公式1] αに空文字が来ない場合

ここで、生成規則 \( A \to \alpha \) の生成先 \( \textcolor{deepskyblue}{\alpha} \) をすべて終端記号にしたときの先頭に来る文字の候補というのは、\( \alpha \) に空文字が来ない限り \( \mathrm{First} ( \textcolor{deepskyblue}{\alpha} \) と書き換えることができます。

よって、\( \alpha \) に空文字が来ない場合（\( = \varepsilon \notin \mathrm{First} ( \alpha ) \)）は、\[
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{\alpha} ) = \mathrm{First} ( \textcolor{deepskyblue}{\alpha} )
\]でDirector集合を求めることが可能です。

[Director集合の計算公式2] αに空文字が来る可能性がある場合

しかし、\( A \to \varepsilon \) が代入される可能性がある（\( = \varepsilon \in \mathrm{First} ( \alpha ) \)）場合、下のように \( A \to \varepsilon \) が適用されることで \( A \) のつぎの文字列 \( X \) が先頭に出てくる可能性があります。\[
A \textcolor{blue}{X} \xrightarrow{A \to \varepsilon} \textcolor{blue}{X}
\]そのため、\( \varepsilon \in \mathrm{First} ( \textcolor{deepskyblue}{\alpha} ) \) となる場合は \( \mathrm{First} ( \textcolor{deepskyblue}{\alpha} ) \) に加えて \( A \) の直後に来る終端記号の文字を表す \( \mathrm{Follow} ( \textcolor{magenta}{A} ) \) もDirector集合に加えます。

よって、\( \alpha \) に空文字が来る場合（\( = \varepsilon \in \mathrm{First} ( \alpha ) \)）は、\[
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{\alpha} ) = \mathrm{Follow} ( \textcolor{magenta}{A} )
\]でDirector集合を求めることが可能です。

(3) Director集合を用いたLL(1)文法の判定

LL(1)文法であるかどうかは、同一非終端記号から生成されるすべての生成規則に対し、生成される可能性がある「非終端記号の文字列の先頭文字」がすべて異なっていればOKでしたね。

このLL(1)文法であるかの判定をDirector集合を用いて書くと下のようになります。

[例]

生成規則\[\begin{align*}
A & \to \alpha_1 | \ \alpha_2 \\
B & \to \beta_1 \\
C & \to \gamma_1 | \ \gamma_2 \ | \ \gamma_3
\end{align*}\]からなる文法の場合、2つ以上の生成元を持つ非終端記号は \( A \)（2つ）と \( C \)（3つ）である。

(i) \( A \) で確認する内容\[
\mathrm{Director} ( A , \alpha_1 ) \cap \mathrm{Director} ( A , \alpha_2 ) = \phi
\]

(ii) \( C \) で確認する内容\[\begin{align*}
\mathrm{Director} ( C , \gamma_1 ) \cap \mathrm{Director} ( C , \gamma_2 ) & = \phi \\
\mathrm{Director} ( C , \gamma_1 ) \cap \mathrm{Director} ( C , \gamma_3 ) & = \phi \\
\mathrm{Director} ( C , \gamma_2 ) \cap \mathrm{Director} ( C , \gamma_3 ) & = \phi
\end{align*}\]※ 3つの生成規則の中から2つを選ぶ組み合わせは、(生成規則1, 生成規則2), (生成規則1, 生成規則3), (生成規則2, 生成規則3) の3通りあるので、3通りとも調べる必要あり。

この(i), (ii)で出てきた式（合計4つ）がすべて成立すればLL(1)文法であることが言えます。一方、どれか1つでも成立しなかった時点でLL(1)文法ではありません。

(4) 例題で確認してみよう

Director集合の算出、およびLL(1)文法の確認を例題で確認していきましょう。

[解説]

LL(1)文法であるか判定するためには、2つ以上の生成規則を持つ各非終端記号に対して、Director集合を取り、その積を確認します。

(i) \( A \) が生成元の生成規則 \( A \to bBa \), \( A \to \varepsilon \) に対してDirector集合確認

\( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{bBa} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{bBa} ) & = \mathrm{First} ( \textcolor{deepskyblue}{bBa})
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( b )
\\ & \overset{ \mathrm{R1} }{=} \{ b \}
\end{align*}\]

\( \textcolor{magenta}{A} \to \textcolor{gray}{\varepsilon} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{gray}{\varepsilon} ) & = \mathrm{Follow} ( \textcolor{magenta}{A} )
\\ & = \{ c, \$ \}
\end{align*}\]

\( A \) に関する各Director集合の積を取ると、\[\begin{align*}
\mathrm{Director} ( A, bBa ) \cap \mathrm{Director} ( A, \varepsilon ) & = \{ b \} \cap \{ c , \$ \}
\\ & = \phi
\end{align*}\]となるためOK。

(ii) \( B \) が生成元の生成規則 \( B \to Sc \), \( B \to d \) に対してDirector集合確認

\( \textcolor{magenta}{B} \to \textcolor{deepskyblue}{Sc} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{B} , \textcolor{deepskyblue}{Sc} ) & = \mathrm{First} ( \textcolor{deepskyblue}{Sc} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (S)
\\ & = \{ a \}
\end{align*}\]

\( \textcolor{magenta}{B} \to \textcolor{deepskyblue}{d} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{B} , \textcolor{deepskyblue}{d} ) & = \mathrm{First} ( \textcolor{deepskyblue}{d} )
\\ & \overset{ \mathrm{R1} }{=} \{ d \}
\end{align*}\]

\( B \) に関する各Director集合の積を取ると、\[\begin{align*}
\mathrm{Director} ( B, Sc ) \cap \mathrm{Director} ( B, d ) & = \{ a \} \cap \{ d \}
\\ & = \phi
\end{align*}\]となるためOK。

(i), (ii)よりLL(1)文法であることが確認できた。

※ \( S \) に対しては、\( S \to a A \) の1つの生成規則しかないため、Director集合は求めなくてOK。

5. 練習問題

それでは、ここまでの学習内容を練習問題を通じておさらいしていきましょう。

今回は、2問の練習問題を用意しています。

練習1.

練習2.

6. 練習問題の答え

解答1.

規則\[\begin{align*}
P = \{ \ \ \ S & \to aAa \\ A & \to bB \ | \ SB \\ B & \to cB \ | \ dAb \ | \ \varepsilon \ \ \}
\end{align*}
\]で表される文法に対してFirst集合、Follow集合、Director集合を求めてLL(1)文法を判定する。

(1) First集合の算出

[略解]\[\begin{align*}
\mathrm{First} (S) & = \{ a \} \\
\mathrm{First} (A) & = \{ a,b \} \\
\mathrm{First} (B) & = \{ c,d, \varepsilon \}
\end{align*}\]

(i) \( \mathrm{First} (S) \) の計算

\( S \) が生成元の規則は \( S \to \textcolor{red}{aAa} \) の1つだけなので、\( S \to \textcolor{red}{aAa} \) だけに着目すればOK。

\[\begin{align*}
\mathrm{First} (S) & \overset{ \mathrm{R2} }{=} \underbrace { \mathrm{First} (\textcolor{red}{aAa}) }_{S \to \textcolor{red}{aAa}}
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (a)
\\ & \overset{ \mathrm{R1} }{=} \{ a \}
\end{align*}\]

(ii) \( \mathrm{First} (A) \) の計算

\( A \) が生成元の規則は \( A \to bB \) と \( A \to SB \) の2つがある。

そのため、\( \mathrm{First} (A) \) を求める際には \( A \to \textcolor{red}{bB}\) と \( A \to \textcolor{blue}{SB} \) の2つの規則に着目すればOK。\[
\mathrm{First} (A) \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} (\textcolor{red}{bB}) }_{ A \to \textcolor{red}{bB} } \cup \underbrace{ \mathrm{First} (\textcolor{blue}{SB}) }_{ A \to \textcolor{blue}{SB} }
\]

ここでそれぞれの項のFirst集合は以下のように計算できる。

\[\begin{align*}
\mathrm{First} (bB) & \overset{ \mathrm{R3} }{=} \mathrm{First} (b)
\\ & \overset{ \mathrm{R1} }{=} \{ b \}
\end{align*}\]

\[\begin{align*}
\mathrm{First} (SB) & \overset{ \mathrm{R3} }{=} \mathrm{First} (S)
\\ & \overset{ \mathrm{(1)} }{=} \{ a \}
\end{align*}\]

よって、\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} (bB) }_{ A \to bB } \cup \underbrace{ \mathrm{First} (SB) }_{ A \to SB }
\\ & = \{ b \} \cup \{ a \}
\\ & = \{ a, b \}
\end{align*}\]となる。

(iii) \( \mathrm{First} (B) \) の計算

\( B \) が生成元の規則は \( B \to cB \), \( B \to dAb \), \( B \to \varepsilon \) の3つがある。

そのため、\( \mathrm{First} (B) \) を求める際には \( B \to \textcolor{red}{cB} \), \( B \to \textcolor{blue}{dAb} \), \( B \to \textcolor{green}{\varepsilon} \) の3つの規則に着目すればOK。\[
\mathrm{First} (B) \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} (\textcolor{red}{cB}) }_{ B \to \textcolor{red}{cB} } \cup \underbrace{ \mathrm{First} (\textcolor{blue}{dAb}) }_{B \to \textcolor{blue}{dAb}} \cup \underbrace{ \mathrm{First} (\textcolor{green}{\varepsilon}) }_{B \to \textcolor{green}{\varepsilon}}
\]

ここでそれぞれの項のFirst集合は以下のように計算できる。

\[\begin{align*}
\mathrm{First} (cB) & \overset{ \mathrm{R3} }{=} \mathrm{First} (c)
\\ & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

\[\begin{align*}
\mathrm{First} (dAb) & \overset{ \mathrm{R3} }{=} \mathrm{First} (d)
\\ & \overset{ \mathrm{(1)} }{=} \{ d \}
\end{align*}\]

\[\begin{align*}
\mathrm{First} (\varepsilon) \overset{ \mathrm{R1} }{=} \{ \varepsilon \}
\end{align*}\]

よって、\[\begin{align*}
\mathrm{First} (B) & \overset{ \mathrm{R2} }{=} \mathrm{First} (cB) \cup \mathrm{First} (dAb) \cup \mathrm{First} (\varepsilon)
\\ & = \{ c \} \cup \{ d \} \cup \{ \varepsilon \}
\\ & = \{ c,d, \varepsilon \}
\end{align*}\]となる。

(2) Follow集合の算出

[略解]\[\begin{align*}
\mathrm{Follow} (S) & = \{ a,b,c,d, \$ \} \\
\mathrm{Follow} (A) & = \{ a,b \} \\
\mathrm{Follow} (B) & = \{ a,b \}
\end{align*}\]

(i) \( \mathrm{Follow} (S) \) の算出式

[公式1] \( S \) は出発記号？ → Yes。なので、\( \mathrm{Follow} (S) \) に \( \$ \) を追加。\[
\mathrm{Follow} (S) += \{ \$ \}
\]

\( \textcolor{magenta}{S} \) が生成先に含まれる規則は、\( A \to \textcolor{magenta}{S} B \) のみなので、\( A \to \textcolor{magenta}{S} B \) にのみ着目すればOK。

ここで、\( A \to \textcolor{magenta}{ S } \textcolor{blue}{ \underbrace{B}_{ \beta } } \) より、\( \textcolor{blue}{\beta = B} \) とおく。

[公式2] \( \beta \not = \varepsilon \)？ → \( \beta = B \not = \varepsilon \) なのでYes。

なので、\( A \to \textcolor{magenta}{S} \textcolor{blue}{ B } \) に対し、以下の集合の要素を追加。\( A\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{S} ) + & = \mathrm{First} ( \textcolor{blue}{B} ) - \{ \varepsilon \}
\\ & = \{ c,d, \varepsilon \} - \{ \varepsilon \}
\\ & = \{ c,d \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \beta ) = \{ c,d, \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{A} \to \textcolor{magenta}{S} B \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{S} ) + & = \mathrm{Follow} ( \textcolor{blue}{A} )
\end{align*}\]

よって、\( \mathrm{Follow} (S) \) に追加される要素は以下の図で示す通り。

(ii) \( \mathrm{Follow} (A) \) の算出式

[公式1] \( A \) は出発記号？ → No。

\( \textcolor{magenta}{A} \) が生成先に含まれる規則は、\( S \to a \textcolor{magenta}{A} a \), \( B \to d \textcolor{magenta}{A} b \) の2つなので、この2つの規則に着目すればOK。

[a] \( S \to a \textcolor{magenta}{A} a \) に着目したとき

\( S \to a \textcolor{magenta}{ A } \textcolor{blue}{ \underbrace{a}_{ \beta } } \) とおく。（つまり \( \textcolor{blue}{\beta = a} \)）

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = a} \not = \varepsilon \) なのでYes。

なので、\( S \to a \textcolor{magenta}{A} \textcolor{blue}{ a } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{A} ) + & = \mathrm{First} ( \textcolor{blue}{a} )
\\ & = \{ a \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \textcolor{blue}{\beta} ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} ) = \mathrm{First} ( \textcolor{blue}{a} ) = \{ a \} \) なのでNo。

[b] \( B \to d \textcolor{magenta}{A} b \) に着目したとき

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = b} \not = \varepsilon \) なのでYes。

なので、\( S \to d \textcolor{magenta}{A} \textcolor{blue}{ b } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{A} ) + & = \mathrm{First} ( \textcolor{blue}{b} )
\\ & = \{ b \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} ) = \mathrm{First} ( \textcolor{blue}{b} ) = \{ b \} \) なのでNo。

よって、\( \mathrm{Follow} (A) \) に追加される要素は以下の図で示す通り。

(iii) \( \mathrm{Follow} (B) \) の算出式

[公式1] \( B \) は出発記号？ → No。

\( \textcolor{magenta}{B} \) が生成先に含まれる規則は、\( A \to b \textcolor{magenta}{B} \), , \( A \to S \textcolor{magenta}{B} \) ,\( B \to c \textcolor{magenta}{B} \) の3つ。ただし、\( B \to c \textcolor{magenta}{B} \) は右再帰規則のため無視。なので、\( A \to b \textcolor{magenta}{B} \), \( A \to S \textcolor{magenta}{B} \) の2つの規則に着目すればOK。

[a] \( A \to b \textcolor{magenta}{B} \) に着目したとき

\( A \to b \textcolor{magenta}{ B } \) の \( \textcolor{magenta}{B} \) の後ろの文字が存在しない。そのため、\( \textcolor{blue}{\beta = \varepsilon} \) である。

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = \varepsilon} \) なのでNo。

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} ) = \mathrm{First} ( \textcolor{blue}{ \varepsilon } ) = \{ \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{A} \to b \textcolor{magenta}{B} \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{blue}{A} )
\end{align*}\]

[b] \( A \to S \textcolor{magenta}{B}\) に着目したとき

\( A \to S \textcolor{magenta}{ B } \) の \( \textcolor{magenta}{B} \) の後ろの文字が存在しない。そのため、\( \textcolor{blue}{\beta = \varepsilon} \) である。

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = \varepsilon} \) なのでNo。

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} ) = \mathrm{First} ( \textcolor{blue}{ \varepsilon } ) = \{ \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{A} \to S \textcolor{magenta}{B} \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{blue}{A} )
\end{align*}\]

※ 式から察している人もいるかもしれませんが、[a] の生成式と全く同じ結果が出てきます。

よって、\( \mathrm{Follow} (B) \) に追加される要素は以下の図で示す通り。

それぞれの計算結果をまとめてFollow集合を算出

先ほど出した \( \mathrm{Follow} (S) \), \( \mathrm{Follow} (A) \), \( \mathrm{Follow} (B) \) の計算過程を1つの図に表すと、下のようになる。

あとは、求められるFollow集合から順にFollow集合を求めていけばOK。

※ 今回の場合は、\( \mathrm{Follow} (A) \) を求めてから、\( \mathrm{Follow} (S) \) と \( \mathrm{Follow} (B) \) を求めていく流れになりますね（\( \mathrm{Follow} (S) \) と \( \mathrm{Follow} (B) \) はどっちから求めてもOK）。

(ii) \( \mathrm{Follow} (A) \) の計算結果

[計算式]\[\begin{align*}
\mathrm{Follow} (A) & = \mathrm{First} (a) \cup \mathrm{First} (b) - \{ \varepsilon \}
\\ & = \{ a \} \cup \{ b \}
\\ & = \{ a, b \}
\end{align*}\]

(i) \( \mathrm{Follow} (S) \) の計算結果

[計算式]\[\begin{align*}
\mathrm{Follow} (S) & = \mathrm{First} (B) \cup \mathrm{Follow} (A) \cup \{ \$ \} - \{ \varepsilon \}
\\ & = \{ c, d, \varepsilon \} \cup \{ a,b \} \cup \{ \$ \} - \{ \varepsilon \}
\\ & = \{ a, b, c, d, \$ \}
\end{align*}\]※ \( \varepsilon \) を無視するのを忘れずに

(iii) \( \mathrm{Follow} (B) \) の計算結果

[計算式]\[\begin{align*}
\mathrm{Follow} (B) & = \mathrm{Follow} (A)
\\ & = \{ a, b \}
\end{align*}\]※Follow集合の要素には \( \varepsilon \) が出てこないので、\( \varepsilon \) を引いていません。（引いてもOKです。）

(3) Director集合の算出とLL(1)文法の判定

各非終端記号に対して、生成元から2つ以上の生成規則を持つものは、

1. \( A \) が生成元となる規則：\( A \to bB \), \( A \to SB \)
2. \( B \) が生成元となる規則：\( B \to cB \), \( B \to dAb \), \( B \to \varepsilon \)

である。あとは、非終端記号ごとに「どの生成規則同士の積をとっても、Director集合が空集合になること」を確認すればOK。

1) \( A \) が生成元の生成規則 \( A \to bB \), \( A \to SB \) に対してDirector集合確認

\( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{bB} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{bB} ) & = \mathrm{First} ( \textcolor{deepskyblue}{bB} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( b )
\\ & \overset{ \mathrm{R1} }{=} \{ b \}
\end{align*}\]

\( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{SB} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{SB} ) & = \mathrm{First} ( \textcolor{deepskyblue}{SB} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( S )
\\ & = \{ a \}
\end{align*}\]

\( A \) に関する各Director集合同士の積を取ると、\[\begin{align*}
\mathrm{Director} ( A, bB ) \cap \mathrm{Director} ( A, SB ) & = \{ b \} \cap \{ a \}
\\ & = \phi
\end{align*}\]となるためOK。

2) \( B \) が生成元の生成規則 \( B \to cB \), \( B \to dAb \), \( B \to \varepsilon \)に対してDirector集合確認

\( \textcolor{magenta}{B} \to \textcolor{deepskyblue}{cB} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{B} , \textcolor{deepskyblue}{cB} ) & = \mathrm{First} ( \textcolor{deepskyblue}{cB} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( c )
\\ & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

\( \textcolor{magenta}{B} \to \textcolor{deepskyblue}{dAb} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{B} , \textcolor{deepskyblue}{dAb} ) & = \mathrm{First} ( \textcolor{deepskyblue}{dAb} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( d )
\\ & \overset{ \mathrm{R1} }{=} \{ d \}
\end{align*}\]

\( \textcolor{magenta}{B} \to \textcolor{gray}{\varepsilon} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{B} , \textcolor{gray}{\varepsilon} ) & = \mathrm{Follow} ( \textcolor{magenta}{B} )
\\ & = \{ a, b \}
\end{align*}\]

\( B \) に関する各Director集合同士の積を取ると、\[\begin{align*}
\mathrm{Director} ( B, cB ) \cap \mathrm{Director} ( B, dAb ) & = \{ c \} \cap \{ d \}
= \phi \\
\mathrm{Director} ( B, cB ) \cap \mathrm{Director} ( B, \varepsilon ) & = \{ c \} \cap \{ a,b \}
= \phi \\
\mathrm{Director} ( B, dAb ) \cap \mathrm{Director} ( B, \varepsilon ) & = \{ d \} \cap \{ a,b \}
= \phi
\end{align*}\]となるためOK。

1), 2) より、題意の文法はLL(1)文法である。

解答2.

規則\[\begin{align*}
P = \{ \ \ \ S & \to AaB \\ A & \to cCA \ | \ c \\ B & \to S \ | \ BA \ | \ \varepsilon \\ C & \to Bc \ \ \ \ \ \ \ \ \ \ \ \ \ \ \}
\end{align*}
\]で表される文法に対してFirst集合、Follow集合、Director集合を求めてLL(1)文法を判定する。

(1) First集合の算出

[略解]\[\begin{align*}
\mathrm{First} (S) & = \{ c \} \\
\mathrm{First} (A) & = \{ c \} \\
\mathrm{First} (B) & = \{ c, \varepsilon \} \\
\mathrm{First} (C) & = \{ c \}
\end{align*}\]

(i) \( \mathrm{First} (S) \) の計算 (途中まで)

\( S \) が生成元の規則は \( S \to \textcolor{red}{AaB} \) の1つだけなので、\( S \to \textcolor{red}{AaB} \) だけに着目すればOK。

\[\begin{align*}
\mathrm{First} (S) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} ( \textcolor{red}{AaB} ) }_{S \to \textcolor{red}{AaB}}
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (A)
\end{align*}\]※ まだ \( \mathrm{First} (A) \) が求まっていないため保留

(ii) \( \mathrm{First} (A) \) の計算（と \( \mathrm{First} (S) \) の計算再開）

\( A \) が生成元の規則は \( A \to cCA \) と \( A \to c \) の2つがある。

そのため、\( \mathrm{First} (A) \) を求める際には \( A \to \textcolor{red}{cCA} \) と \( A \to \textcolor{blue}{c} \) の2つの規則に着目すればOK。\[
\mathrm{First} (A) \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} (\textcolor{red}{cCA}) }_{A \to \textcolor{red}{cCA}} \cup \underbrace{ \mathrm{First} ( \textcolor{blue}{c}) }_{A \to \textcolor{blue}{c}}
\]

ここでそれぞれの項のFirst集合は以下のように計算できる。

\[\begin{align*}
\mathrm{First} (cCA) & \overset{ \mathrm{R3} }{=} \mathrm{First} (c)
\\ & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

\[\begin{align*}
\mathrm{First} (c) & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

よって、\[\begin{align*}
\mathrm{First} (A) & \overset{ \mathrm{R2} }{=} \mathrm{First} (cCA) \cup \mathrm{First} (c)
\\ & = \{ c \} \cup \{ c \}
\\ & = \{ c \}
\end{align*}\]となる。また、\( \mathrm{First} (S) \) も

\[\begin{align*}
\mathrm{First} (S) & \overset{ \mathrm{R2} }{=} \mathrm{First} (AaB)
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} (A)
\\ & = \{ c \}
\end{align*}\]と求められる。

(iii) \( \mathrm{First} (B) \) の計算

\( B \) が生成元の規則は \( B \to S \), \( B \to BA \), \( B \to \varepsilon \) の3つがある。

ただし、\( B \to B A \) は左再帰の文法なので無視する。そのため、\( \mathrm{First} (B) \) を求める際には \( B \to \textcolor{red}{cB} \), \( B \to \textcolor{blue}{dAb} \) の2つの規則に着目すればOK。\[
\mathrm{First} (B) \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} (\textcolor{red}{cB}) }_{B \to \textcolor{red}{ cB }} \cup \underbrace{ \mathrm{First} ( \textcolor{blue}{dAb} ) }_{B \to \textcolor{blue}{dAb} }
\]

ここで、\[\begin{align*}
\mathrm{First} (\varepsilon) \overset{ \mathrm{R1} }{=} \{ \varepsilon \}
\end{align*}\]なので、\( \mathrm{First} (B) \) は\[\begin{align*}
\mathrm{First} (B) & \overset{ \mathrm{R2} }{=} \mathrm{First} (S) \cup \mathrm{First} (\varepsilon)
\\ & = \{ c \} \cup \{ \varepsilon \}
\\ & = \{ c, \varepsilon \}
\end{align*}\]と計算できる。

(iv) \( \mathrm{First} (C) \) の計算

\( C \) が生成元の規則は \( C \to \textcolor{red}{Bc} \) だけなので、この規則のみに着目する。

よって、\[\begin{align*}
\mathrm{First} (C) & \overset{ \mathrm{R2} }{=} \underbrace{ \mathrm{First} ( \textcolor{red}{Bc} ) }_{C \to \textcolor{red}{Bc}}
\\ & \overset{ \mathrm{R3} }{=} \left( \mathrm{First} (B) - \{ \varepsilon \} \right) \cup \{ c \} \ \ \because \left( \varepsilon \in \mathrm{First} (B) \right)
\\ & = \{ c \} \cup \{ c \}
\\ & = \{ c \}
\end{align*}\]※ \( \mathrm{First} (B) \) に \( \varepsilon \) が含まれているため、公式が変化する点に注意！

(2) Follow集合の算出

[略解]\[\begin{align*}
\mathrm{Follow} (S) & = \{ c , \$ \} \\
\mathrm{Follow} (A) & = \{ a, c, \$ \} \\
\mathrm{Follow} (B) & = \{ c, \$ \} \\
\mathrm{Follow} (C) & = \{ c \}
\end{align*}\]

(i) \( \mathrm{Follow} (S) \) の算出式

[公式1] \( S \) は出発記号？ → Yes。なので、\( \mathrm{Follow} (S) \) に \( \$ \) を追加。\[
\mathrm{Follow} ( \textcolor{magenta}{S} ) += \{ \$ \}
\]

ここで、\( \textcolor{magenta}{S} \) が生成先に含まれる規則は、\( B \to \textcolor{magenta}{S} \) のみなので、\( B \to \textcolor{magenta}{S} \) にのみ着目すればOK。

\( B \to \textcolor{magenta}{ S } \) において、 \( \textcolor{magenta}{S} \) の後ろの文字が存在しない。そのため、\( \textcolor{blue}{\beta = \varepsilon} \) である。

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = \varepsilon} \) なのでNo。

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{\varepsilon} ) = \{ \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{B} \to \textcolor{magenta}{S} \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{S} ) + & = \mathrm{Follow} ( \textcolor{blue}{B} )
\end{align*}\]

よって、\( \mathrm{Follow} (S) \) で追加する要素（計算過程）は以下の図の通りである。

(ii) \( \mathrm{Follow} (A) \) の算出式

[公式1] \( A \) は出発記号？ →No。なにもしない。

ここで、\( \textcolor{magenta}{A} \) が生成先に含まれる規則は、\( S \to \textcolor{magenta}{A} a B \), \( A \to cC \textcolor{magenta}{A} \), \( B \to B \textcolor{magenta}{A} \) の3つがあるが、\( A \to cC \textcolor{magenta}{A} \) は右再帰な規則なので無視。よって、\( S \to \textcolor{magenta}{A} a B \), \( B \to B \textcolor{magenta}{A} \) の2つに着目すればOK。

[ii-a] \( S \to a \textcolor{magenta}{A} a B \) に着目したとき

\( S \to a \textcolor{magenta}{ A } \textcolor{blue}{ \underbrace{aB}_{ \beta } } \) とおく。（つまり \( \textcolor{blue}{\beta = a} \)）

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = aB} \not = \varepsilon \) なのでYes。

なので、\( S \to a \textcolor{magenta}{A} \textcolor{blue}{ aB } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{A} ) + & = \mathrm{First} ( \textcolor{blue}{aB} )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( \textcolor{blue}{a} )
\\ & \overset{ \mathrm{R1} }{=} \{ a \}
\\ & = \{ a \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{aB} ) = \{ \varepsilon \} \) = \{ a \} \) なのでNo。

[ii-b] \( B \to B \textcolor{magenta}{A} \) に着目したとき

この規則では、\( \textcolor{magenta}{S} \) の後ろの文字が存在しない。そのため、\( \textcolor{blue}{\beta = \varepsilon} \) である。

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = \varepsilon} \) なのでNo。

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \beta ) = \{ \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{B} \to B \textcolor{magenta}{A} \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} (\textcolor{magenta}{A} ) + & = \mathrm{Follow} ( \textcolor{blue}{B} )
\end{align*}\]

よって、\( \mathrm{Follow} (A) \) に追加される要素は以下の図で示す通り。

(iii) \( \mathrm{Follow} (B) \) の算出式

[公式1] \( B \) は出発記号？ →No。なにもしない。

ここで、\( \textcolor{magenta}{B} \) が生成先に含まれる規則は、\( S \to Aa \textcolor{magenta}{B} \), \( B \to \textcolor{magenta}{B} A \), \( C \to B \textcolor{magenta}{c} \) の3つがあるため、この3つの規則に着目すればOK。

[iii-a] \( S \to Aa \textcolor{magenta}{B} \) に着目したとき

この規則では、\( \textcolor{magenta}{B} \) の後ろの文字が存在しない。そのため、\( \textcolor{blue}{\beta = \varepsilon} \) である。

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = \varepsilon} \) なのでNo。

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{\varepsilon} ) = \{ \varepsilon \} \) なのでYes。

なので、\( \textcolor{blue}{S} \to A a\textcolor{magenta}{B} \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} (\textcolor{magenta}{B} ) + & = \mathrm{Follow} ( \textcolor{blue}{S} )
\end{align*}\]

[iii-b] \( B \to \textcolor{magenta}{B} A \) に着目したとき

\(B \to \textcolor{magenta}{ B } \textcolor{blue}{ \underbrace{A}_{ \beta } } \) とおく。（つまり \( \textcolor{blue}{\beta = A} \)）

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = A} \not = \varepsilon \) なのでYes。

なので、\( B \to a \textcolor{magenta}{B} \textcolor{blue}{ A } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{First} ( \textcolor{blue}{A} )
\\ & = \{ c \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{A} ) = \{ c \} \) なのでNo。

[iii-c] \( C \to \textcolor{magenta}{B} c \) に着目したとき

\(C \to \textcolor{magenta}{ B } \textcolor{blue}{ \underbrace{c}_{ \beta } } \) とおく。（つまり \( \textcolor{blue}{\beta = c} \)）

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = c} \not = \varepsilon \) なのでYes。

なので、\( C \to a \textcolor{magenta}{B} \textcolor{blue}{ c } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{B} ) + & = \mathrm{First} ( \textcolor{blue}{c} )
\\ & = \{ c \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{c} ) = \{ c \} \) なのでNo。

[iii-a]～[iii-c] より、\( \mathrm{Follow} (B) \) に追加される要素は以下の図で示す通り。

(iv) \( \mathrm{Follow} (C) \) の算出式

[公式1] \( C \) は出発記号？ →No。なにもしない。

ここで、\( \textcolor{magenta}{C} \) が生成先に含まれる規則は、\( A \to c \textcolor{magenta}{C} A \) のみ。なのでこの規則に着目すればOK。

この規則について、\(A \to c \textcolor{magenta}{ C } \textcolor{blue}{ \underbrace{A}_{ \beta } } \) とおく。（つまり \( \textcolor{blue}{\beta = A} \)）

[公式2] \( \beta \not = \varepsilon \)？ → \( \textcolor{blue}{\beta = A} \not = \varepsilon \) なのでYes。

なので、\( C \to c \textcolor{magenta}{C} \textcolor{blue}{ A } \) に対し、以下の集合の要素を追加。\[\begin{align*}
\mathrm{Follow} ( \textcolor{magenta}{C} ) + & = \mathrm{First} ( \textcolor{blue}{A} )
\\ & = \{ c \}
\end{align*}\]

[公式3] \( \varepsilon \in \mathrm{First} ( \beta ) \)？ → \( \mathrm{First} ( \textcolor{blue}{\beta} )= \mathrm{First} ( \textcolor{blue}{A} ) = \{ c \} \) なのでNo。

よって、\( \mathrm{Follow} (C) \) に追加される要素は以下の図で示す通り。

それぞれの計算結果をまとめてFollow集合を算出

先ほど出した \( \mathrm{Follow} (S) \), \( \mathrm{Follow} (A) \), \( \mathrm{Follow} (B) \), \( \mathrm{Follow} (C) \) の計算過程を1つの図に表すと、下のようになる。

※ 点線部分は、間接的な右再帰により、2つのFollow集合が等しい（＝一心同体）になっていることを表す。つまり \( \mathrm{Follow} (S) = \mathrm{Follow} (B) \)。

あとは、求められるFollow集合から順にFollow集合を求めていけばOK。

※ 今回の場合は、\( \mathrm{Follow} (A) \) 集合は点線部分のFollow集合が求まらないと計算できません。それ以外の集合は自由な順番で計算できます。

(iv) \( \mathrm{Follow} (C) \) の計算結果

[計算式]\[\begin{align*}
\mathrm{Follow} (C) & = \mathrm{First} (a)
\\ & = \{ c \}
\end{align*}\]

(i), (iii) \( \mathrm{Follow} (S) \), \( \mathrm{Follow} (B) \) の計算結果（2つのFollow集合は等しい）

[計算式]\[\begin{align*}
\mathrm{Follow} (S) & = \{ \$ \} \cup \mathrm{First} (A) \cup \mathrm{First} (c)
\\ & = \{ \$ \} \cup \{ c \} \cup \{ c \}
\\ & = \{ c , \$ \}
\end{align*}\]※ \( \mathrm{Follow} (B) \) 加えられている要素もいったん \( \mathrm{Follow} (S) \) に足している。

\[\begin{align*}
\mathrm{Follow} (B) & = \mathrm{Follow} (S)
\\ & = \{ c , \$ \}
\end{align*}\]

(ii) \( \mathrm{Follow} (A) \) の計算結果

[計算式]\[\begin{align*}
\mathrm{Follow} (A) & =\mathrm{Follow} (B) \cup \mathrm{First} (a)
\\ & = \{ c, \$ \} \cup \{ a \}
\\ & = \{ a, c , \$ \}
\end{align*}\]※ \( \mathrm{Follow} (B) \) を \( \mathrm{Follow} (S) \) としてもOK。

(3) Director集合の計算・LL(1)文法の判定

各非終端記号に対して、生成元から2つ以上の生成規則を持つものは、

1. \( A \) が生成元となる規則：\( A \to cCA \), \( A \to c \)
2. \( B \) が生成元となる規則：\( B \to S \), \( B \to BA \), \( B \to \varepsilon \)

である。あとは、非終端記号ごとに「どの生成規則同士の積をとっても、Director集合が空集合になること」を確認すればOK。

1) \( A \) が生成元の生成規則 \( A \to cCA \), \( A \to c \) に対してDirector集合確認

\( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{cCA} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{cCA} ) & = \mathrm{First} ( cCA )
\\ & \overset{ \mathrm{R3} }{=} \mathrm{First} ( c )
\\ & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

\( \textcolor{magenta}{A} \to \textcolor{deepskyblue}{c} \) のDirector集合\[\begin{align*}
\mathrm{Director} ( \textcolor{magenta}{A} , \textcolor{deepskyblue}{c} ) & = \mathrm{First} ( c )
\\ & \overset{ \mathrm{R1} }{=} \{ c \}
\end{align*}\]

\( A \) に関する各Director集合同士の積を取ると、\[\begin{align*}
\mathrm{Director} ( A, cCA ) \cap \mathrm{Director} ( A, c ) & = \{ c \} \cap \{ c \}
\\ & = \{ c \}
\end{align*}\]となるためNG。

よって、題意の文法はLL(1)文法ではない。

※ 1つでも \( \phi \) にならないものがあればその時点でLL(1)文法ではないことが確認できるため、他のDirector集合は求めなくてOKです。

7. さいごに

かなり長い記事となっていましたが、以上が

• LL(1)文法
• First集合
• Follow集合
• Director集合

に関する説明でした。

この記事を見て、少しでもLL(1)文法やFirst, Follow, Director集合の計算の方法について理解いただけたのであれば非常にうれしいです。

次回は、左再帰な文法についての「問題点」と「左再帰を解消する方法」について説明する予定です。

[練習問題の中に入れられなかったおまけ問題] 生成規則 \( A \to B \) に対するDirector集合 \( \mathrm{Director} (A,B) \) を求めなさい。ただし、\[\begin{align*}
\mathrm{First} (A) & = \{ a \} \\
\mathrm{First} (B) & = \{ b, \varepsilon \} \\
\mathrm{Follow} (A) & = \{ c \} \\
\mathrm{Follow} (B) & = \{ d, \$ \}
\end{align*}\]とする。解答はこの注釈に書いています^[12]\( \varepsilon \in \mathrm{First} (B) \) なので、\( B \) が空文字になる可能性を考慮するのがミソです。\[\begin{align*}\mathrm{Director} (A,B) & = \mathrm{First}(B) \cup … Continue reading。

第2羽となる今回から、コンパイラの処理の中の第2フェーズである「構文解析」で出てくる様々な仕組みについて数記事にわけて見ていきましょう。

皆さんは、高校で英語を習う際に「英文の構造を把握してから」英文を理解したり、和訳したりした思い出があると思います^[1]SV, SVC, SVO, SVOO, SVOCの5種類。。

コンパイラの世界でも同じように、「書かれたプログラムの構造を把握しながら」C言語などの高級言語をコンピュータ上で実行できる形（機械語）に翻訳するコンパイルが実行されるのですが、その際にコンピュータ上でプログラムの構造を

今回は、コンパイラで「書かれたプログラムの構造を（文法的に）把握する」する際に出てくる「解析木」や「構文木」について、例題や練習問題も踏まえながら学習していきましょう。

[復習] 文脈自由文法とは

まずは、コンピュータ上で文法を表現する方法の1つである文脈自由文法について復習しましょう。

文脈自由文法は、

• 非終端記号 \( N \)
• 終端記号 \( \Sigma \)
• 生成規則 \( P \)
• 出発記号 \( S \)

の4つの要素で構成されており、この4種類で「文字列が文法のルールを満たしているか否か」を判定します。

ここからは、具体的にそれぞれ4種類の記号がどのような働きをしているかを見ていきましょう。

(1) 非終端記号

文法を表現する際に使う「仮の変数」です。数学でいう「nとおく。」のnみたいなものだと思ってください。

非終端記号は、(4)で説明する生成規則に書き換えることが可能です。\( S \), \( E \), \( T \) などのアルファベット大文字で書かれることが多いです。

[余談] アルファベット大文字以外にも、<式>, <変数>. <数字> など、<名前> の形で非終端記号が表されることもあります。（基本情報や応用情報がまさにこの形で非終端記号を使っています）

(2) 終端記号

実際に文字列内に出てくる（仮の変数ではない）文字や記号が終端記号です。(4) で説明する生成規則によって書き換えることが出来ないのが特徴です。

終端記号には、\( a \), \( b \) などの小文字や数字、英単語、単語、記号（括弧・演算記号など）などの日常的に使われる文字（文字列）が指定されることが多いです。

(3) 生成規則

文法のルールを表す文脈自由文法の心臓部分です。

実際に「ある文字列」が文法のルールを満たしているか否かは、(4)で出てくる出発記号 \( S \) を生成規則 \( P \) で書き換えていった際に出てくる終端記号「ある文字列」を表現できるかどうかで判定します。

[Point] 生成規則のまとめ書き

\( S \to AB \), \( S \to C \) のように、同じ文字列から生成される規則は、\[
S \to AB | C
\]のように | を用いてまとめて書くのが一般的なので覚えておきましょう！

(4) 出発記号

名前の通り、生成規則を最初に加える非終端記号を指します。

ここで、実際に文脈自由文法についての復習問題を解いてみましょう。

[解答] (ア)

実際に、出発記号 \( S \) から連鎖的に文法規則を適用していき、（ア）と（イ）のどちらが文法規則を適用した際に現れるかを確認すればOKです。

すると、\( aaaa \) という文字列が出てきますね。よって答えは（ア）です。

文脈自由文法についてもう少し復習したいなという人は、下の記事をご覧ください！

うさぎでもわかるオートマトンと言語理論　第07羽　文脈自由文法

今回は、オートマトンと言語理論の中でも重要な文脈自由文法についてまとめました。文脈自由文法を読む方法、正規文法、チョムス

[余談] 生成規則の書き方について

生成規則は、基本的に\[
P = \{ S \to Aa , \ A \to a \ | \ Aaa \}
\]のように「(生成元の非終端集合) → (生成される文字列)」の形で書くのが一般的ですが、\[
S \to Aa, \ \ A \to a \ | \ Aaa
\]のように文字列を列挙して書く方法や、

S ::= Aa
A ::= a
A ::= Aaa

のように \( \to \) を ::= と書く手法もあります^[2]基本情報や応用情報で出てくる文脈自由文法がまさに (生成元)::=(生成先) のような書き方をしています。（BNF記法などとも呼ばれます。）。

文脈自由文法について復習できたところで、いよいよ「解析木」や「構文木」の書き方を見ていきましょう！

1. 解析木の書き方

解析木は、出発記号 \( S \) からどのような文法規則を適用すると与えられた文字列になるのかを表した図です。

と言われても少しわかりにくいと思うので、実際に例題を見ながら「解析木」の書き方、および解析木がどんなものなのかを見ていきましょう。

[解説1]

解析木は、「与えられた文字列が出発記号 \( S \) からどのような生成規則 \( P \) が適用して出てきたか」を表します。

つまり、解析木を書く問題は与えられた文字列から生成規則を逆方向にたどっていき、出発記号 \( S \) に戻すパズルだと思っていただけたらOKです^[3]生成規則を逆方向にたどるとは、例えば \( A \to B + C \) の生成規則に対して、\( B+ C \) を \( A \) に変換することを表します。。

ということで、早速例題の生成規則 \( P \) からなる文法 \( G \) に対する文字列 \( (a+b) * (c+d) \) の解析木を書いていきましょう。

Step1. 方針を建てる

やみくもに生成規則を逆にたどっていくのではなく、まず方針をたてましょう。

方針を建てる際には、生成規則内で1回しか出てこない非終端記号に着目できる場合は、その規則を使っていきます^[4]この問題では、どの非終端記号 + , * , a, b, c, d も1回ずつを使っているので、。

[方針1] \( (S+S) \) の形を作り出す

まず、括弧と＋が生成される規則は \( S \to (S+S) \) の1つにしか出てきません。なので、括弧 ( ) 部分は下のように \( (S+S) \) の形を作ってから \( S \to (S+S) \) を逆にたどるのかなという方針を立てます。

[方針2] \( S*S \) の形を作り出す

また、\( * \) が生成される規則は \( S \to S * S \) の1つにしかないので、\( * \) は、下のように \( S*S \) を作ってから \( S \to S*S \) を逆にたどるのかなと方針を立てます。

[木構造]

方針がたてれたところで、いよいよ解析木を作っていきましょう。

まず、\( V \to \ a \ | \ b \ | \ c \ | \ d \) を逆に適用することで、 \( a \), \( b \), \( c \), \( d \) を \( V \) に変換します。

つぎに、\( V \) が生成される規則は \( S \to V \) の1つだけですね。

なので、先程出てきた \( V \) に対して生成規則を逆にたどることで \( S \) にします。

すると、文字列は \( (S+S) * (S+S) \) となります。

ここで、[方針1]で登場した \( (S+S) \) の形が2つ出てきましたね。なので、\( S \to (S+S) \) の規則を逆に適用して、\( (S+S) \) を \( S \) にします。

すると、文字列が \( S*S \) の形となり、[方針2]で登場した \( S*S \) の形となりました。

なので、最後に \( S \to S * S \) を逆に適用すれば、めでたく文字列を出発記号 \( S \) にすることができます！

よって、解析木は下のようになります。

[余談] 下のように、元の文字列を上に書き、出発記号 \( S \) が下になるような書き方をしてもOKです。

2. 構文木の書き方

解析木から「非終端記号」や「括弧などの関係ない記号」を取り除いたものが構文木となります。

先程の例題1を使って、解析木から構文木を作ってみましょう！

[解説2]

例題1で書いた解析木はこちらです。

まず、この解析木から下のの2つの操作をします。

• 非終端記号の削除
• 余計な括弧 ( ) の除去

さらに、削除された（2つ以上の子をもつ）非終端記号の部分に対し、1つの子を削除された非終端記号の部分に移動させます^[5]移動させる終端記号の選び方ですが、出発記号 \( S \) … Continue reading。

すると、下のような構文木が出来上がります。

3. 練習問題にチャレンジ！

実際に解析木（や構文木）が書けるかどうか、2種類の練習問題にてチャレンジしてみましょう！

練習1. 解析木・構文木を書いてみよう

練習2. 解析木が書ける文字列はどっち？

4. 練習問題の答え

解答1.

(1) 解析木

最初に | でつながれている生成規則を1個ずつ省略せずに書き直してから、方針をたてましょう。

★ 方針 ★

[方針1]

まず、\( + \) が生成できる規則は、\( E \to E + T \) 1つのみですね。

なので、文字列の \( i + i \) の部分を生成規則を逆にたどっていくことで \( E+T \) にすることを考えます。

[方針2]

また、括弧が生成できる規則は、\( T \to (S) \) のみです。

そのため、文字列中に括弧が出てくる \( (i+i) \) 部分について、生成規則を逆にたどっていくことにより、\( (S) \) にすることを考えます。

[方針3]

さらに、\( = \) が生成できる規則は \( S \to i = S \) のみです。

なので、\( i = \textcolor{orange} {( i+ i)} \) 部分については、生成規則を逆にたどっていくことで \( i = \textcolo{orange}{ S } \) にすることを目指します^[6]\( \textcolor{blue}{i =} (i+i)\) の \( \textcolor{blue}{ i = } \) の部分は終端記号なため、実質 \( \textcolor{orange}{ (i+i) } \) 部分を \( \textcolor{orange}{S} \) … Continue reading。

[解析木の作り方]

方針をたてられたので、生成規則を逆にたどっていく（以下：逆にたどっていくことを逆変換と表記します）ことにより、解析木を創りましょう。

まずは、[方針1] の通り、\( i + i \) から生成規則を逆変換していくことにより、\( E \) にします。

つぎに、[方針2] の通り、括弧部分を逆変換によりひとまとめにします。

最後に、[方針3] の通り、\( = \) を逆変換によりまとめれば、出発記号 \( S \) だけになるため、解析木の完成です！

(2) 構文木

まず、(1)で求めた解析木から、

• 非終端記号の削除
• 括弧の除去

をします。

つぎに、削除された非終端記号のうち、○の部分（2つ以上の子をもつ部分）に対し、1つの子を削除された非終端記号の部分に移動させます。

すると、下のような構文木が完成します。

解答2.

(1) 文字列が文法を満たしているかの判定

文字列が文法 \( G \) を満たしているかを判定する際には、文字列の一部分を切り出してその部分が文法的に満たせそうかを確認する方法がおすすめです。

今回は、

(ア) \( ( ( i ) + i ) \)
(イ) \( i + ( + i ) \)

の2つの文字列のうち、どちらが文法を満たしているのかを判定するのでしたね。

なので、まずは文字列の一部分が文法を満たしているのかを確認していきましょう。

まず、(ア) の \( (i) \) と \( (i)+i \) に着目して構文木を書いてみましょう。

すると、どちらも \( S \) 1文字に書き換えることができました^[7]一部分が \( S \) 1文字に書き換えられなからといって、与えられた文字列が文法を満たしていないとは限らない点に注意が必要です。。

さらに、\( \textcolor{red}{( i ) + i} \) が \( \textcolor{red}{S} \) に書き換えられることが分かったので、(ア) の文字列 \( ( \textcolor{red}{( i ) + i} ) \) は \( ( \textcolor{red}{S} ) \) に書き換えられそうですね。

ここで、\( (S) \) は、\( S \to E \to (S) \) で導出できるため、(ア)の文字列は文法 \( G \) を満たすことがわかります。

一方 (イ) の規則はどうでしょうか。

文字列 \( (+i) \) 部分を変形しながら見ていきましょう。

すると、\( (+E) \) までは逆変換することができます。しかし、\( + \) を逆変換できる式は \( S \to S + E \) の1種類しか存在しない上、生成規則的に \( S \) に空文字 \( \varepsilon \) は入らなさそうなため、どう頑張っても \( (+E) \) から文字列を逆変換することができません。

そのため、(イ) は文法 \( G \) を満たしませんね。

よって、文法 \( G \) を満たす文字列は (ア) となります。 ← (1) の答え

(2) 解析木

文法 \( G \) を満たす (ア) の文字列 \( ( ( i ) + i ) \) を書いていけばOKです。

ここで、(1)で書いた文字列の一部分 \( (i) \) と \( (i)+i \) の解析木を確認しましょう。

あとは、この解析木を参考にしながら (ア) の文字列全体 \( ( ( i ) + i ) \) の解析木を書けばOKです！

[記事1] うさぎでもわかるオートマトンと言語理論　第09羽　正規表現と有限オートマトン

うさぎでもわかるオートマトンと言語理論　第09羽　正規表現と有限オートマトン

今回は正規表現について簡単にですがまとめています。よく使われる正規表現の種類、正規表現を非決定性オートマトンで表す方法を

[記事2] うさぎでもわかる計算機システム　Part11　コンパイラの処理の流れ（字句解析と意味解析のしくみ）

うさぎでもわかる計算機システム　Part11　コンパイラの処理の流れ（字句解析と意味解析のしくみ）

今回はコンパイラの処理の流れについて、特に字句解析・意味解析を中心に説明しています。

こんにちは、ももやまです。

皆さんが書いたプログラム（C言語など）が実際にコンピュータ上で実行できる形（機械語）にするためには、「コンパイル」をする必要があるのでしたね^[1] … Continue reading。

この「コンパイル」の流れ（C言語が機械語になるまでの過程）ですが、大まかに分けると下の4つに分けることができます。

今回は、上の4つの過程の中でも最初の「字句解析」を実際に体験することができるLex(Flex)の読み方や書き方について見ていきます。

※ FlexはLexの上位互換みたいなもので、基本的な使い方などはLexと同じです。そのため、Flexについて知りたい人もこの記事をご覧いただいてOKです。
（具体的にFlexとLexがどう違うのかはこの記事では割愛します。）

1. 字句解析ってなに？[復習]

Lexについて勉強する前に、字句解析ではどんなことをするかを軽く復習しておきましょう。

皆さんは「英語で書かれた文章を日本語に直しなさい」という作業を英語の期末試験やら入試でやったことがあると思います。

そのときに、英文に出てくる各英単語が「どんな品詞を持って、どんな意味を持つのか」を考えながら翻訳していたと思います。

コンパイラの世界でも、C言語（のような高級言語）をコンピュータが実行できる言語に翻訳する1つ目のステップとして、C言語で書かれたファイルの文字列を、単語単位に分割していき、その単語の属性（英語でいう品詞）がどれにあたるのかを機械的にチェックしていきます。

このファイル内の文字列を単語単位に分割し、分割した単語（字句と呼びます）がどの属性（例: 識別子、キーワード、定数、文字列、etc...）にあたるのかをチェックしていく過程が字句解析なのです！

※ 属性というのはあまり一般的な言い方ではありませんが、わかりやすく表現するために本記事では属性という表現を使っています。

2. 正規表現 [復習]

字句解析では、ファイル内の文字列を字句ごとに分割したあとに、「それぞれの字句がどの属性（識別子、キーワード、定数、文字列、etc...）」に分類する際に、字句の属性ごとに「この文字列だったらこの属性になるよ～」というのを列挙します。

言い換えると、各属性ごとに「文字列を列挙した集合^[2]文字列が集まった箱のようなものだと思ってください。」を用意し、ファイル内の文字列を分割した書く字句ごとにどの集合に属するかを調べていくことをします^[3]各字句がどの属性の文字列集合（文字列が集まった箱か）に属するかを調べていくかというのを考えます。。

しかし、文字列を列挙した集合を作る際に、特定の文字列を指定するだけならともかく、「最初の1文字目はアルファベット、2文字目以降はアルファベット or 数字の文字列」のような指定の仕方をする場合、いちいち該当する文字を1文字1文字列挙していっては何日たっても列挙が終わりません。

ここで出てくる魔法のテクニックが正規表現です。正規表現では「最初の1文字目はアルファベット、2文字目以降はアルファベット or 数字の文字列」のように一定のルールに従った文字列を（いちいち列挙することなく）1単語ですべて表現することができます。

ここからは、Lexでよく使う正規表現をサクッと復習していきましょう。

(1) 繰り返しを表す記号

(1-a) 0回以上の繰り返し *

* をつけた直前の文字を0回以上繰り返します。

例: smo*ch の場合に当てはまる文字列の例

• smch
• smoch
• smooch
• smoooch
• smoooooooooooooooooooooooooooooooch

(1-b) 1回以上の繰り返し +

+ をつけた直前の文字を1回以上繰り返します。

例: smo+ch の場合に当てはまる文字列の例

• smoch
• smooch
• smoooch
• smoooooooooooooooooooooooooooooooch

smo+ch と列挙した場合、smch は + の直前の文字列oを1回も繰り返していないため、当てはまらない。

(1-c) 0回もしくは1回の繰り返し ?

? をつけた直前の文字を0回 or 1回繰り返します。

例: smo?ch の場合に当てはまる文字列

• smch
• smoch

※ この2種類以外の文字列は当てはまらない

(1-d) 特定回数の繰り返し {min,max}

{min,max} をつけた直前の文字列を min 回 ～ max 回の間繰り返します。

※ min, max のどちらか片方は省略可能です。

例1: smo{2,4}ch の場合に当てはまる文字列 (min = 2, max = 4)

• smooch
• smoooch
• smooooch

※1 {2,4}をつけた直前の文字列 o を2～4回繰り返しているものだけが当てはまる
※2 この3種類以外の文字列は当てはまらない

例2: smo{,3}ch の場合に当てはまる文字列 (min = 指定なし, max = 3)

• smch
• smoch
• smooch
• smoooch

※1 {,3}をつけた直前の文字列 o を3回以下繰り返しているものだけが当てはまる
※2 この4種類以外の文字列は当てはまらない

例3: smo{3,}ch の場合に当てはまる文字列の例 (min = 3, max = 指定なし)

• smoooch
• smooooch
• smoooooch
• smoooooooooooooooooch

※ {3,}をつけた直前の文字列 o を3回以上繰り返しているものだけが当てはまる

(2) 文字列を指定する表現

(2-a) グループ化のカッコ ( )

文字列を ( ) すると、カッコ内の文字列をグループ化することができます。

(1)で説明した「繰り返しを表す記号」で使われます。

例: (usa)+dayo の場合に当てはまる文字列の例

• usadayo
• usausadayo
• usausausadayo

※ usaで1グループなので、usaudayo のように、usa単位で繰り返しをしていない文字列は当てはまらない

(2-b) いずれかを表す記号 | ※ ( ) と同時に使用OK

複数パターンの文字列を当てはめる場合に使います。

例1: center|centre の場合に当てはまる文字列

• center
• centre

例2: cent(er|re) の場合に当てはまる文字列

• center
• centre

※ 基本的には、例2のように複数パターン当てはまる部分だけを ( ) と | を使って表すことが多い。

(2-c) 1文字単位で当てはまる文字を指定する記号 [ ]

カッコ [ ] を使うと、カッコ内で指定した文字が当てはまるようになります。

※ カッコ単体ではあまり使わず、他の文字列や記号、繰り返しを組み合わせて使うのが基本です。

例1: [ABC] の場合に当てはまる文字列(文字?)

• A
• B
• C

例2: [01]+ の場合に当てはまる文字列の例

• 0
• 1
• 00
• 01
• 10
• 11

※ [01]+ は、0, 1だけが出てくる1文字以上の文字列がすべて当てはまる

例3: 00[01]* の場合に当てはまる文字列の例

• 00
• 000
• 001
• 0000
• 0001
• 0010
• 0011

※ 「00」 or 「00が最初に来たあとに、0もしくは1だけが続く」文字列が当てはまります。

(2-d) 1文字の指定 [ ] をする際の省略記法 -

複数文字を指定する際に、ASCIIコード的に連続している文字を指定する場合は下のように省略記法 - を使うことができます。

[表記例]

• [A-Z] → アルファベット大文字を指定
• [a-z] → アルファベット小文字を指定
• [A-Za-z] → アルファベットを指定
• [0-9] → 数字を指定
• [A-Za-z0-9] → アルファベット or 数字を指定

実際の使用例も何個か見てみましょう。

例1: [A-C] の場合に当てはまる文字列(文字?)

• A
• B
• C

※ [A-C] は [ABC] と同じ

例2: [0-9]+ の場合に当てはまる文字列の例

• 3
• 0124151
• 534290
• 52309432865

※ [0-9]+ は、数字が1文字以上繰り返されるのを表す

(2-e) 任意の1文字を表す記号 .

. は1文字であればどんな文字でもOKです。
（ワイルドカード的な効果を持つと思っていただけたらOKです）

例1: usa.iの場合に当てはまる文字列の例

• usaai
• usagi
• usa#i

例2: .+の場合に当てはまる文字列の例

• a
• ohayo
• hello
• nihao
• annyonghaseyo

※ 1文字以上の文字列すべてがすべて当てはまります

これで、Lexで使う知識の復習は完了です。いよいよLexの中身に入っていきましょう。

3. Lex(Flex)の書き方（構造）

Lexプログラムの構造としては「定義部」、「規則部（ルール部）」、「ユーザー定義サブルーチン部」の3層構造となっており、拡張子は .l で表されます。

それでは、「定義部」、「規則部（ルール部）」、「ユーザー定義サブルーチン部」で具体的にどのような内容が記述されるかを実際に見ていきましょう。

(1) 定義部 [省略OK]

「規則部」や「ユーザー定義サブルーチン部」で使う外部ヘッダファイルをインクルードしたり、外部変数を宣言する際に使います。

書き方としては、定義部の始点に %{ 、終点に %} を書き、その間に必要な外部ヘッダファイルのインクルードや外部変数の宣言をC言語で行います。

%{ // 定義部スタートは必ず %{
#include <stdio.h> // 外部ヘッダファイル読み込み
int alphabet_capital = 0; // 外部変数
int alphabet_small   = 0; 
int number           = 0; 
int others           = 0; 
// 定義部の終わりは必ず %}
%} 

(2) 規則部（ルール部）

字句解析の規則を記述するLexの心臓部分で、Lexで最も重要な箇所です。

書き方としては、まず規則部の始点と終点に %% を書き、その間に「字句解析のルール」と、「ルールを満たしたときに処理される内容(C言語で記述)」を書きます。

lex限定の変数 - yytextとyyleng

ルールを満たしたときに処理される内容を括弧内 { } にC言語で記述する際に、Lex専用の変数 yytext, yychar を使うことができます。変数の特性は、下の通りです。

• yytext → ルールを満たしたとき、どの文字列でルールを満たしたかを文字列の形で表す
• yyleng → yytext の文字列の長さを表す

[例] 文字列 ABABC がルール [A-Z]+ にマッチした場合

• yytext → ABABC
• yyleng → 5

(3) ユーザー定義サブルーチン部 [省略OK]

(2)の字句解析をした結果を利用したC言語プログラムを書くことができます^[4]下の例は、main 関数しかありませんが、新たに自分自信で関数を定義することもできます。。

(1)の定義部と同じく省略することもできますが、省略しない場合はプログラム中の字句解析をする箇所に yylex(); を必ず書く必要があります^[5] yylex(); を書かない場合、字句解析が行われずにプログラムが終了します。。

int main(void) {
    yylex(); // ここで (2)規則部に従って字句解析が行われる
    printf("英大文字:%3d文字\n",alphabet_capital);
    printf("英小文字:%3d文字\n",alphabet_small);
    printf("算用数字:%3d文字\n",number);
    printf("その他　:%3d文字\n",others);
}

第4章からは、Lexの心臓部分である「規則部(ルール部)」に着目して、Lexでの字句解析の動きを見ていきましょう。

4. Lexの動きを見てみよう（基本編）

規則部では、入力した文字列を「規則部内に正規表現で書いた各ルール」に従って先頭から1文字ずつ字句解析をしていきます。しかし、正規表現に慣れている人にとっても、Lexでの字句解析は少し複雑です。

そこで、ここからは実際にLexを用いて字句解析をする場合、どのような動作をするのかを全6パターンを用いて説明していきます。

(1) レベル1　1文字を入力した場合

まずは、1文字だけを入力する一番カンタンなパターンで字句解析の仕組みを把握しましょう。

3章で軽く説明した通り、規則部には「字句解析の各ルール」と「各ルールを満たした場合の各処理内容」が列挙されているのでしたね。

例えば、入力として A という文字列が来た場合を考えましょう。

A という文字列は、各ルールの中の一番上のルール [A-Z] にマッチしますね。そのため、[A-Z] の右側にかかれている

printf("CAP[%s]",yytext);

が実行され、CAP[A] というのが出力されます。

※ 規則部の出力で yytext と書くと、ルールにマッチした部分の文字列が出力されます。（今回の場合は A が出力される）

では、9 という文字列が来た場合、上から何番目の規則にマッチして何が出力されるでしょう？ 少し考えてみましょう。

%%
[A-Z] { printf("CAP[%s]",yytext); }
[a-z] { printf("SML[%s]",yytext); }
[0-9] { printf("NUM[%s]",yytext); }
%%

正解は、上から3番目のルールです。ですので、3番目のルール [0-9] 右側にかかれているprintfの内容

printf("NUM[%s]",yytext);

が実行され、NUM[9] が出力されますね。

(2) レベル2　複数文字入力した場合

今度は、複数文字入力した場合を見ていきましょう。

複数文字を入力した場合、文字列の終点にたどり着くまで1文字目から順番にマッチする文字列を探していきます。

例えば、先程と同じ規則部を持つLexファイルに対して、AbB3 を入力した場合、出力がどうなるかをアニメーションで追ってみましょう。

%%
[A-Z] { printf("CAP[%s]",yytext);}
[a-z] { printf("SML[%s]"  ,yytext);}
[0-9] { printf("NUM[%s]" ,yytext);}
%%

[アニメーション]

よって、出力内容が

CAP[A]SML[b]CAP[B]NUM[3]

となることがわかります。

(3) レベル3　どのルールにも当てはまらない場合

Lexで字句解析を行う際に「どの規則にも当てはまらない文字列」が出てきた場合、どのような動きをするかも確認しておきましょう。

例えば、下の規則に文字列 A3b を入力することを考えます。

%%
[A-Z] { printf("CAP[%s]",yytext);}
[a-z] { printf("SML[%s]",yytext);}
%%

すると、最初の1文字 A までは CAP[A] と順調に規則にマッチするのですが、2文字目〜4文字目の 3, 3, 4 にマッチする規則はありません。

このようにマッチする規則がない場合は、入力した文字がそのまま出力されます。そのため、CAP[A] に引き続き、入力した 334 が出力されます。

ただし最後の5文字目は、上から2番目の規則にマッチするため、SML[b] が CAP[A]334 に引き続き出力されます。

よって、最終的な出力は CAP[A]334SML[b] となります。

5. Lexの動きを見てみよう（応用編）

4章の基本編では、規則部の動きを確認するために、文字列を1文字ずつ字句解析させていき、その動きを確認しました。

この応用編では少しレベルを上げて、複数文字をマッチできるルールを入れたときの字句解析させたときのプログラムの動きを確認しましょう。

(1) レベル4　複数文字のマッチが可能な場合の動き

例えば、次の規則部を持つLexプログラムに対して、1423DB と入力することを考えましょう。

%%
[A-D]   { printf("CAP[%s]" ,yytext);}
"3D"    { printf("3DD[%s]" ,yytext);}
1[0-9]+ { printf("NUM[%s]" ,yytext);}
.       { printf("???[%s]" ,yytext);}
%%

まず、最初に上から3番目のルール 1[0-9]+ とマッチします。ここで、1[0-9]+ というのは、「1で始まり、その後に0～9が1文字以上続く文字列」を表します。そのため、

• 1だけマッチさせる
• 14までマッチさせる
• 142までマッチさせる
• 1423までマッチさせる

のどのパターンでも3番目のルールを適用させることが可能です。

このようなパターンの場合、Lexは（ルールを満たす中で）マッチする文字数が最も多くなるパターンを選択します^[6]難しい言い方をすると、yytext に入る文字数が最も多くなる（＝yyleng が最大になる）パターンを選択するとも言えます。。そのため今回の場合は、1423まで 1[0-9]+ のルールでマッチします。

※ 残りの2文字D, Bは、それぞれ [A-D] のルールに1文字ずつマッチさせられるので、 NUM[1423] に引き続いて CAP[D]CAP[B] と出力されます。

(2) レベル5　適用できるルールが複数ある場合の動き

例えば、下のLexプログラムに対して、CCSakura と入力することを考えましょう。

※ Lexでは上から3番目のルール CC のように、マッチさせる文字列を "CC" のようにダブルクオーテーション "" で囲んで示すことができます

%%
[A-Z]   { printf("CAP[%s]" ,yytext);}
[a-z]+  { printf("SML[%s]" ,yytext);}
"CC"    { printf("CCC[%s]" ,yytext);}
%%

まず、最初にどの規則をマッチするかを考えましょう。すると、

• 一番上の規則 [A-D] でCとマッチ（1文字分マッチ）
• 一番下の規則 "CC" でCCとマッチ（2文字分マッチ）

のどちらかを適用できそうですね。

このように適用できるルールが複数ある場合は、より長い文字数分マッチする規則が優先して適用されます。言い換えると、適用可能なルールの中で、マッチする文字列の文字数が最も長くなるようなルールが適用されます。

そのため、最小に適用される規則は「一番下の規則 "CC" が優先され、CCC[CC] が出力」されます。

※ 残りの文字列Sakuraは、順番に

• 上から1番目の規則 [A-Z] → S をマッチ
• 上から2番目の規則 [a-z]+ → akura をマッチ

と適用できるため、CCC[CC] に引き続いて CAP[S]SML[akura]と出力されます。

(3) レベル6　適用できるルールが複数 & マッチする文字列が最長となる規則が複数ある場合

適用できるルールが複数ある場合は、「マッチする文字列の文字数が最も長くなる規則」が優先して適用されるのでしたね。

しかし、「マッチする文字列の文字数が最も長くなる規則」が複数ある場合が出てくる場合があり、文字列の長さだけではマッチさせるルールが決まらないことがあります。

例えば、下のLexプログラムに対して、C# と入力することを考えましょう。

%%
[A-Z] { printf("CAP[%s]",yytext); }
[a-z] { printf("SML[%s]",yytext); }
[0-9] { printf("NUM[%s]",yytext); }
.     { printf("???[%s]",yytext); }
%%

まず、最初にどの規則をマッチするかを考えましょう。すると、

• 一番上の規則 [A-Z] でCとマッチ → 1文字マッチ
• 一番下の規則 . でCとマッチ → 1文字マッチ

のどちらかを適用できそうですが、どちらの規則も「1文字分」しかマッチしません。

このように適用できるルールが複数あり、なおかつ「マッチする文字列の文字数が最も長くなる規則」が複数ある場合は、適用可能で最もマッチする文字列の文字数が長くなるルールのうち、最も上に書かれているルールが適用されます。

今回の場合、より上にかかれている1番上の規則 [A-Z] が適用されるため、出力は CAP[C] となります。

※ 残りの文字列 # は、一番下の規則以外満たさないため、CAP[C] に引き続いて ???[#] が出力されます。

6. 練習問題 (Lexの動きを確認しよう)

それでは、規則部の動きについて理解できているかどうかを、練習問題を通じて確認しましょう。

問題.

以下のLexプログラム（規則部以外は省略されている）に、(1)〜(4)の文字列をそれぞれ入力したときの出力を答えなさい。

%%
[0-1][0-9]+ { printf("OP1[%s]",yytext); }
[A-C]+0*    { printf("OP2[%s]",yytext); }
"3C"        { printf("OP3[%s]",yytext); }
"B1"        { printf("OP4[%s]",yytext); }
"#"|"@"     { printf("OP5[%s]",yytext); }
.           { printf("???[%s]",yytext); }
%%

(1) 0120
(2) 3CA#@
(3) ABC02
(4) B197

解答.

それぞれのルールを日本語に直すと下のようになります。

• [0-1][0-9]+ → 最初に0 or 1、その後に1文字以上数字が来ればマッチ
• [A-C]+0* → A, B, Cのいずれかが1文字以上来ればマッチ。A, B, Cが1文字以上続いたあとに0が続く文字列でもマッチ。
• "3C" → 3C だけマッチ。それ以外の文字列にはマッチしない。
• "B1" → B1 だけマッチ。それ以外の文字列にはマッチしない。
• "#"|"@" → # もしくは @ が来たときにマッチ。
• . → 任意の1文字にマッチ

これを踏まえて、(1)〜(4)の出力を考えていきましょう。

(1) 入力: 0120

文字列0120は、一番上の規則

[0-1][0-9]+ { printf("OP1[%s]",yytext); }

に全てマッチできますね。（0120 → [0-1][0-9]+）

そのため、出力は OP1[0120] となります。

(2) 入力: 3CA#@

まず、最初の2文字 3C は上から3番目の規則

"3C"        { printf("OP3[%s]",yytext); }

にマッチします。（出力: OP3[3C] ）

つぎに、3文字目 A が上から2番目の規則

[A-C]+0*    { printf("OP2[%s]",yytext); }

にマッチします。（出力: OP2[A] ）

※ 上から6番目の規則 . にもマッチしますが、より上にかかれている規則にもマッチするため、上から2番目の規則が優先的に選ばれます。

つぎに、4文字目 # が上から5番目の規則

"#"|"@"     { printf("OP5[%s]",yytext); }

にマッチします。（出力: OP5[#] ）

※ 上から6番目の規則 . にもマッチしますが、より上にかかれている規則にもマッチするため、上から2番目の規則が優先的に選ばれます。

最後に5文字目 @ も上から5番目の規則

"#"|"@"     { printf("OP5[%s]",yytext); }

にマッチします。（出力: OP5[@] ）

※ 上から6番目の規則 . にもマッチしますが、より上にかかれている規則にもマッチするため、上から2番目の規則が優先的に選ばれます。

よって、3CA#@ を入力したときの出力内容は OP3[3C]OP2[A]OP5[#]OP5[@] となります。

(3) 入力: ABC02

まず、最初の4文字 ABC0 まで上から2番目の規則

[A-C]+0*    { printf("OP2[%s]",yytext); }

にマッチします。（出力: OP2[ABC0] ）

つぎに、最後の1文字 2 が一番下（上から6番目）の規則

.           { printf("???[%s]",yytext); }

にマッチします。（出力: ???[2] ）

よって、ABC02 を入力したときの出力内容は OP2[ABC0]???[2] となります。

(4) 入力: B197

まず、最初の2文字 B1 までは上から4番目の規則

"B1"        { printf("OP4[%s]",yytext); }

にマッチします。（出力: OP4[B1] ）

[補足] 上から2番目の規則

[A-C]+0*    { printf("OP2[%s]",yytext); }

にマッチするのでは？ と思った人もいるかもしれませんが、上から2番目の規則 [A-C]+0*の場合、最初の1文字 B にしかマッチしないため、より多くの文字列をマッチできる上から4番目の規則 "B1" が優先的に選ばれます。

つぎに、3文字目の9、4文字目の7は上から6番目の規則

.           { printf("???[%s]",yytext); }

に1文字ずつマッチします^[7]上から1番目の規則 （0始まりの2桁以上の数字でないと受理しない）と間違えないように注意！。そのため、OP4[B1] に引き続いて ???[9]???[7] とマッチします。

よって、B197 を入力したときの出力内容は OP4[B1]???[9]???[7] となります。

[おまけ] 実際にLexを動かしてみよう！ (Mac・Linux)

最後に、実際にコンピュータ上でLexプログラムを動かしてみましょう！

※ Mac・Linuxユーザーの人は何もインストールすることなく、Lexを使うことができます。
Windowsの人も「Flex for Windows」などをインストールをすればLexを動かすことは可能ですが、少し手順がめんどくさいです。）

Step1. Lexプログラムを作成する

まずは、テキトーなエディタを開き、下のプログラムを貼り付けて debt.l という名前で保存してください。（練習問題と同じプログラムです）

%%
[0-1][0-9]+ { printf("OP1[%s]",yytext); }
[A-C]+0*    { printf("OP2[%s]",yytext); }
"3C"        { printf("OP3[%s]",yytext); }
"B1"        { printf("OP4[%s]",yytext); }
"#"|"@"     { printf("OP5[%s]",yytext); }
.           { printf("???[%s]",yytext); }
%%

保存し終わったら、ターミナルを開き、つぎの2つのコマンドを上から順番に1つずつ打ってください。

※ 何かしらのwarningが出た場合でも無視してOKです。エラーが出た場合は貼り付けが正しくできているかを確認してください。

lex lex_pattern1.l
cc lex.yy.c -ll

すると、Lexファイルがコンパイルされ、実行ファイル a.out ができます。あとはこの a.out を実行すればOKです。

./a.out

実行すると、「文字列の入力を待機している状態」になります。
（何もメッセージが出ていないからといって、応答なし状態になっているわけではないのでご安心ください。）

試しに、3CA#@ と入れてEnterと押してみましょう。（練習問題(2)と同じ文字列です）

すると、練習問題(2)の解答と同じ文字列が出力されるはずです…！

OP3[3C]OP2[A]OP5[#]OP5[@]

※ 出力された場合はLexで実際に字句解析させることに成功しました！

8. さいごに

今回は、実際にLexプログラムを使って（ポインタや文字列操作のような複雑なC言語の知識を使うことなしに）字句解析を体験していきました。

次回からは、構文解析について数回に分けて学習していきましょう！

皆さんは、スマートフォンで撮影した画像を「他の人にLINEで送る」、「SNSに投稿をする」際にに画像を加工したことってありませんか？

この画像の加工、実は画像処理の技術がたっぷり詰まっているんですよ…！

そこで今回は、

• 画像の加工の仕組みの中でも最も基本的な画像処理とは何か？
• 最も基本的な画像処理で出てくるトーンカーブとは何か？
• 実際の画像処理の例を見てみよう！
• カラー画像特有の画像処理テクニックを見てみよう！

の4つについて勉強していきましょう。

[注意] コンピュータ上でどのように画像が扱われているかを全く知らない人は、下の記事を読んで勉強することをおすすめします。

（※ 画素、画素値などの専門的な用語が何を表しているのか、およびカラー画像の扱い方を知っていれば読み飛ばしてOKです。)）

うさぎでもわかる画像処理　Part01　コンピュータとデジタル画像

こんにちは、ももやまです。 コンピュータの世界では、あらゆるもの（命令・データ）が2進数（0 or 1）で管理されているのでしたね

1. 最も基本的な画像処理とは？

(1) グレースケール画像の場合

画像処理には様々な方法がありますが、上で説明した通り最も単純で基本的な方法は、下のように元の画像の画素値に対して、一定のルールに基づいて画素値を書き換えてあげる方法です。

例えば、上の例で紹介したルール^[1]入力画像の画素値 \( x \) を2倍したものを出力画像の画素値 \( y \) とする、つまり \( y = 2x \) の変換を行うルールを用いて実際に画像処理をすると、下のような出力画像を生成することができます。

もちろん「単に画素値を2倍にする」のような単純な変換だけでなく、下のように複雑な式を使って画像処理をすることもできます。

(2) カラー画像の場合

カラー画像の場合も、基本的には「最も基本的な画像処理」の仕方は同じです。

しかし、グレースケール画像と異なる点として、カラー画像はコンピュータ上では「R(赤)成分の画像」、「G(緑)成分の画像」、「B(青)成分の画像」の3種類を組み合わせて表現されます。

言い換えると、グレースケール画像では1種類の画素値しかなかったのに対し、カラー画像の各画素には、

• R成分の画素値
• G成分の画素値
• B成分の画素値

の3種類の画素値が与えられております。

なので、カラー画像の画像処理は、R, G, B各成分の画素値を一定のルールに基づいて書きかえることで実現されます。

この3種類（R成分、G成分、B成分）の画素値の書き換えのルールとしては、大きく分けても

1. R, G, B各成分を同じルールに基づいて書き換える
2. R, G, B各成分の一部を書き換える

の2種類あるため、グレースケール画像に比べて画像処理の幅は広がります。

例1. R, G, B各成分を同じルールに基づいて書き換える場合

まずはR, G, B各成分を同じルールで変換すると、どのような画像が生まれるかを見てみましょう。
（下で示した変換ルール1に従って変換をします）

実際に変換を行うと、明るさが変わった画像が出力されます。

このように、R, G, B成分を同じルール変換することで、画像の明るさやコントラストを調整することができます。

例2. R, G, B各成分の一部をルールに従って書き換える場合

今度は、R, G, B各成分うち、一部を書き換えた場合はどうなるかを見てみましょう。
（下で示した変換ルール2に従って変換をします）

すると、下のように特定の色が強調された（弱めた）ような出力画像が出てきます。

このように、R, G, B成分の一部を変換することで、画像内の色のバランスを調整することができます。

2. トーンカーブ

(1) なぜトーンカーブを使うのか

画像処理で行う画素値の変換が「各画素値を2倍にする」のように単純なものであれば、数式だけでも画像処理の内容が直観的に理解できるかもしれません。

しかし、下のように複雑な数式になると、（数学が得意な一部分の人を除き）画像処理の内容は直観的には理解できませんよね。

そこで画像処理の世界では、どのような変換を行ったかを下のような入力画素値 \( x \) に対する出力画素値 \( y \) を表したグラフで表現します。このグラフのことをトーンカーブと呼びます。

変換内容を数式ではなくグラフで示すことで、より画像処理の内容を直観的に確認することができますね！

(2) トーンカーブの読み方

ここで、入力画素値 \( x \) が127のときを例にして、トーンカーブから出力画素値 \( y \) を読み取る方法を確認しましょう。

入力画素値 \( x \) [横軸の値] が127のときの出力画素値 \( y \) [縦軸の値] を見てみると、127近くにあることがわかりますね。

(3) カラー画像の場合のトーンカーブ

カラー画像の場合は、下のようにR成分、G成分、B成分それぞれのトーンカーブを示します。

3. 基本的な4種のトーンカーブ [Python, MATLABコード付き]

ここからは、画像処理の中でも最も基本的な4種類のトーンカーブについて

• グレースケール画像のとき
• カラー画像のとき（R, G, B成分全て同じトーンカーブを適用）

それぞれでみていきましょう。

さらに、変換をするための Python, MATLABコードも紹介します！
(Pythonを使用する場合、numpy, cv2 をインストールする必要があるので注意！)

(1) 折れ線型トーンカーブ

単純に画素値を \( k \) 倍する処理をすることで、画像全体の明るさを変更するトーンカーブです

数式で書くと、\[ y = kx \]となります。
（入力画素値: \( x \), 出力画素値: \( y \)）

(1-a) 画素値をk倍 (k > 1)

\( k \) に1より大きい値を入れると、元の画像よりも明るくなります。

例) \( k = 2 \)、つまり画素値を2倍する変換 \( y = 2x \)

[グレースケール画像]

[カラー画像]

ただし、計算結果 \( kx \) が255を超える場合は出力画素値 \( y \) が255を超えず、255でとどまる点に要注意です^[2]余談ですが、画素値255オーバーしていて画像が白くなる現象のことを、「白飛びする」とか「サチる」などと呼ぶことがあります。。

(1-b) 画素値をk倍 (k < 1)

\( k \) に1より小さい値を入れると、元の画像よりも暗くなります。

例) \( k = 1/2 \)、つまり画素値を1/2倍する変換 \( y = \frac{1}{2} x \)

[グレースケール画像]

[カラー画像]

(1-c) ソースコード

入力画像 input_img、倍率 k を引数とすることで、折れ線型トーンカーブを適用した画像を返す関数を紹介します。

[Python]

import numpy as np

def polygonalTone(input_img,k):
    return np.dot(k,input_img) # np.dot は画素値が255を超える画素を自動的に255に置き換えてくれる

[MATLAB]

function output_img = polygonalTone(input_img,k)
    % MATLABではオーバーフローはそのまま255となるので、特別な対策は不要
    output_img = k * input_img; 
end

折れ線型トーンカーブまとめ

(2) 初期値付き折れ線型トーンカーブ

単純に入力画素値を \( k \) 倍する処理に加えて、一定値 \( a \) を出力画素値に加えます。

式で書くと、\[
y = kx + a
\]ですね。（入力画素値: \( x \), 出力画素値: \( y \)）

例) 初期値 \( a = 127 \)、\( k = 1/2 \) のとき → コントラストを下げた画像が出力される

[グレースケール画像]

[カラー画像]

ソースコード

入力画像 input_img、倍率 k 、初期値 a を引数とすることで、初期値付き折れ線型トーンカーブを適用した画像を返す関数を紹介します。

[Python]

import numpy as np

def polygonalToneWithIni(input_img,k,a):
    return a + np.dot(k,input_img) # np.dot は画素値が255を超える画素を自動的に255に置き換えてくれる

[MATLAB]

function output_img = polygonalToneWithIni(input_img,k,a)
    output_img = a + k * input_img; 
end

初期値付き折れ線型トーンカーブまとめ

(3) 2値化

画像内の明るい部分(画素)を真っ白(画素値255) に、暗い部分(画素)を真っ黒(画素値0) に変換する処理です。言い換えると、画像内の各画素を「真っ白」or「真っ黒」の2色にする処理と言えます。

数式で書くと、\[
y = \left\{ \begin{array}{cc} 255 & ( x \geqq a ) \\ 0 & ( x < a ) \end{array} \right.
\]となります。（※ \( a \) はしきい値、入力画素値: \( x \)、出力画素値: \( y \)）

例) 画素値128以上を白、128未満を黒とする場合 \( a = 128 \)

[グレースケール画像の場合]

[カラー画像の場合]

R成分, G成分, B成分それぞれに2値化判定を行います^[3]例えば、R成分の画素値が 200, G成分の画素値が150, B成分の画素値が100であれば、R, … Continue reading。

ソースコード

入力画像 input_img、しきい値 threshold を引数とすることで、2値化を適用した画像を返す関数のソースコードです。

[Python]

import numpy as np

def binTone(input_img,threshold):
    # しきい値 threshold 以上を真っ白(画素値255)、しきい値未満を真っ黒(画素値0)とする
    return np.where(input_img >= threshold, 255, 0) 

[MATLAB]

function output_img = binTone(input_img,threshold)
    output_img = (input_img >= 128) * 255;
end

2値化まとめ

(4) ネガポジ変換

画像内の濃淡を入れ替える変換です。言い換えると、画像内の明るい画素を暗い画素に、暗い画素を明るい画素に変換する処理です。

数式で書くと、\[
y = 255 - x
\]です。（入力画素値: \( x \), 出力画素値: \( y \)）

[グレースケール画像の場合]

白うさぎは黒うさぎに、黒うさぎは白うさぎになりますね。

[カラー画像の場合]

ソースコード

入力画像 input_img を引数とすることで、ネガポジ変換を適用した画像を返す関数のソースコードです。

[Python]

import numpy as np

def negaposiTone(input_img):
    return 255 - input_img

[MATLAB]

function output_img = negaposiTone(input_img)
    output_img = 255 - input_img;
end

ガンマ補正(変換)まとめ

4. 応用的なトーンカーブ [Python, MATLABコード付き]

先ほど（3章）よりも少し複雑なトーンカーブも見ていきましょう。

(1) ガンマ補正(変換)

(1-a) ガンマ変換とは

理論的には「画素値を \( n \) 倍にすると、ディスプレイ（などの出力装置）の明るさも \( n \) 倍に変化」します。（この状態のことをリニアと呼びます。）

しかし、実際の出力装置（ディスプレイなど）は必ずしも理論的な変化をするとは限りません。

そこで、実際の出力装置をリニアに近づけるための処理を行います。この処理のことをガンマ補正と呼びます。

ガンマ補正では、入力画素値 \( x \)、出力画素値 \( y \) に対して\[
y = 255 \left( \frac{x}{255} \right)^{\gamma}
\]の処理を与えます^[4]指数部分を \( \frac{1}{ \gamma } \) とし、\[y = 255 \left( \frac{x}{255} \right)^{ \frac{1}{\gamma} }\]と表記することも多いです。というのも、元画像 \( y \) … Continue reading
（※ \( \gamma \) は出力装置ごとに最も適した値を設定する）

(1-b) ガンマ変換と明るさの関係

実際にガンマ値 \( \gamma \) を変化させながらガンマ補正を行うと、どんな画像が生成できるかを見てみましょう。

具体的には、

• ガンマ値 \( \gamma > 1 \) → 元の画像より暗くなる変換
• ガンマ値 \( \gamma = 1 \) → 元の画像と全く同じ変換（明るさ変化なし）
• ガンマ値 \( \gamma < 1 \) → 元の画像より明るくなる変換

となります^[5]ガンマ補正を逆数\[y = 255 \left( \frac{x}{255} \right)^{ \frac{1}{\gamma} }\] で定義した場合は、 ガンマ値 \( \gamma > 1 \) → … Continue reading。

(1-c) 様々なガンマ値とトーンカーブ

ガンマ値を 0.25 ～ 4 まで変化させるとトーンカーブはどのように変化するかを、実際にグラフを描画することで確認してみましょう。

各グラフのガンマ値は下の通りです。

• 紫 → \( \gamma = 0.25 \)
• 青 → \( \gamma = 0.50 \)
• 緑 → \( \gamma = 1.00 \)
• 黄 → \( \gamma = 2.00 \)
• 赤 → \( \gamma = 4.00 \)

(1-d) ソースコード紹介

入力画像 input_img, およびガンマ値 gamma を引数とすることで、ガンマ変換を行う関数です。

※ 途中の計算で小数が出てくるため、いったん計算結果を小数で出してから整数型(uint8)に変換しています。

[Python]

import numpy as np

def gammaTone(input_img,gamma):
    output_float = 255 * np.power(input_img / 255, gamma) # 計算結果をいったん実数型(float)で保持
    return output_float.astype(np.uint8)

[MATLAB]

function output_img = gammaTone(input_img,gamma)
    output_double = 255 * power(double(input_img) / 255,gamma); % 計算結果をいったん実数型(double)で保持
    output_img = uint8(output_double);
end

ガンマ補正まとめ

(2) S字トーンカーブ変換

下のように、S字カーブを描くトーンカーブを用いて変換を行うと、コントラストが高くなった画像を出力することができます。

数式でS字カーブを描くためには\[
y = \frac{255}{2} \left\{ 1 - \cos \left( \frac{\pi}{255} x \right) \right\}
\]のように三角関数を使う方法や、ロジスティック方程式\[
y = \frac{255}{1 + ae^{ -b \left( x - \frac{255}{2} \right) } }
\]を使う方法があります^[6] … Continue reading。（ただし \( a > 0 \), \( b > 0 \)）

[グレースケール画像]

[カラー画像]

ソースコード

入力画像 input_img を引数とすることで、S字変換を適用した画像を返す関数のソースコードです。（ロジスティック方程式を利用しました）

※ 途中の計算で小数が出てくるため、いったん計算結果を小数で出してから整数型(uint8)に変換しています。

[Python]

import numpy as np

def sigmoidTone(input_img):
    output_float = 255 / (1 + np.exp(-0.05 * (input_img - 127.5) ) ) # 計算結果をいったん実数型(float)で保持
    return output_float.astype(np.uint8)

[MATLAB]

function output_img = sigmoidTone(input_img)
    output_double = 255 ./ (1 * exp(-0.05 * (double(input_img) - 127.5)));  % 計算結果をいったん実数型(double)で保持 
    output_img = uint8(output_double);
end

S字カーブ変換まとめ

(3) ソラリゼーション変換

濃淡の一部分を反転することで、ネガとポジが混ざり合った効果を持つ画像を生み出します。

数式では\[
y = \frac{255}{2} \left\{ 1 - \cos \left( \frac{3 \pi}{255} x \right) \right\}
\]のように三角関数を使うことで表現可能です^[7]導出方法ですが、まず \( - \cos x \) の \( 0 \leqq x \leqq 3 \pi \) のグラフに着目します。あとは、このグラフの周期を \( 2 \pi \) から 170 に変換するように … Continue reading。

[グレースケール画像]

[カラー画像]

あら不思議。虹色のうさぎさんが出てきましたね。

ソースコード

入力画像 input_img を引数とすることで、ソラリゼーション変換を適用した画像を返す関数のソースコードです。

※ 途中の計算で小数が出てくるため、いったん計算結果を小数で出してから整数型(uint8)に変換しています。

[Python]

import numpy as np
import math

def solaTone(input_img):
    output_float = 127.5 - 255 / 2 * np.cos(3 * math.pi / 255 * input_img)
    return output_float.astype(np.uint8)

[MATLAB]

function output_img = solaTone(input_img)
    output_double = 127.5 - 255 / 2 * cos(3 * pi / 255 * double(input_img));  % 計算結果をいったん実数型(double)で保持
    output_img = uint8(output_double);
end

ソラリゼーション変換まとめ

5. カラー画像特有の画像処理 [Python, MATLABコード付き]

カラー画像では、全体のコントラストを変える画像処理の他にも、色を調整するという画像処理のテクニックがあります。

具体的には、R, G, Bのトーンカーブに対し、「カラー画像のR, G, Bのうちの一部にトーンカーブを適用し、色のバランスを変える」ということをします。

ただ文章で説明されるより、実際に例を見たほうが分かりやすいと思うので、実際に2パターンほど「カラー画像特有の画像処理テクニック」を見ていきましょう！

(1) 特定の色を強調する変換

特定の色を強調する場合は、強調したい色のトーンカーブに「折れ線型トーンカーブ \( k > 1 \)」を適用し、残りの成分には何もしません。

[適用するトーンカーブ]

例えば、赤色(R成分)を強める変換をしてみましょう。ここで、R成分に \( k = 1.2 \) の折れ線型トーンカーブを適用します。

[変換結果]

赤色が強調された画像が得られましたね。

(2) 特定の色を弱める変換

今度は、特定の色を弱める変換を見てみましょう。

特定の色を弱める場合は、弱めたい色のトーンカーブに「折れ線型トーンカーブ \( k < 1 \)」を適用し、残りの成分には何もしません。

[適用するトーンカーブ]

例えば、青色(B成分)を弱める変換をしてみましょう。ここで、B成分に \( k = 0.8 \) の折れ線型トーンカーブを適用します。

[変換結果]

青色が弱まった画像が得られましたね。言い換えると、赤色と緑色の度合いが高い画像が生成できましたね。

(3) ソースコード

入力画像 input_img, 成分の倍率 k 、色 color を引数とすることで、特定の色を強めたり弱めたりすることができる関数を紹介します。

※ 少し関数が複雑なので、使用例を付けております。

[Python]

import numpy as np
import cv2

# color -> (0,1,2,3) が (青,緑,赤,全色[明るさ調整]) に対応
def polygonalTone(input_img,k,color):
    output_img = 1.0 * input_img # 1.0を掛けることでoutput_imgが255越えしても255でストップする
    if color == 3:
        output_img = np.dot(k,input_img)
    else:
        output_img[:,:,color] = np.dot(k,input_img[:,:,color])
    return output_img

## 使用例
#画像読み込み
input_color = cv2.imread(INPUT_PATH)

# (1) 赤を強める [R x 1.2]
output_color = polygonalTone(input_color,1.2,2)
cv2.imwrite(OUTPUT_PATH,output_color)

# (2) 青を弱める [B x 0.8]
output_color = polygonalTone(input_color,0.8,0)
cv2.imwrite(OUTPUT_PATH + "color_sky2.jpg",output_color)

[MATLAB]

% color -> (1,2,3,4) が (赤,緑,青,全色[明るさ調整]) に対応
function output_img = polygonalToneColor(input_img,k,color)
    output_img = input_img;
    if color == 4 
        output_img = input_img * k;
    else
        output_img(:,:,color) = input_img(:,:,color) * k;
    end
end

%% 使用例
% カラー画像読み込み
input_color = imread(INPUT_PATH);

%% 画像処理ここから
% (1) 赤を強める[R x 1.2]
output_color = polygonalToneColor(input_color,1.2,1);
imwrite(output_color,OUTPUT_PATH);

% (2) 青を弱める[B x 0.8]
output_color = polygonalToneColor(input_color,0.8,3);
imwrite(output_color,OUTPUT_PATH);

6. 実際にプログラムを動かして画像処理を体験しよう！

3～5章で各画像処理を行うための関数を説明してきましたが、やはり実際にプログラムを動かして画像処理を体験したいですよね。

そこで、こちらに「すぐに実行できる」ソースコードと実行方法を書いた説明を用意しました！　実際にプログラムを動かしてみたい方は是非ご覧ください！

7. 練習問題でおさらい！

それでは、ここまでの内容を練習問題で復習しましょう！

練習1. トーンカーブのおさらい [基本編]

練習1

つぎの(1)～(5)の変換が表すトーンカーブを、図1内の [トーンカーブの選択肢] から選び、①～⑥の番号で答えなさい。また、図2の「元画像」に対して(1)～(5)の変換を適用するとどのような画像が生成されるか。最も適切なものを図2内の [変換画像 (猫)] から選び、ア～カの記号で答えなさい。

(1) 画素値を2倍にする変換
(2) 画素値を1/2倍にする変換
(3) ネガポジ変換
(4) 2値化変換
(5) ソラリゼーション

[トーンカーブの選択肢]

[画像の選択肢]

練習2. トーンカーブのおさらい [応用編]

練習2

つぎの①, ②, ③ が示す変換を ①→②→③ の順に適用した。

① 画素値を2倍にする変換
② 画素値を1/2倍にする変換
③ ネガポジ変換

このとき、「入力画素値」と「③適用後の出力画素値」の関係を表すトーンカーブを図3を参考にしながら答えなさい。

練習3. カラー画像とトーンカーブ

練習3

つぎのカラー画像に対して、(1)変換1, (2)変換2, (3)変換3 を適用し、新たなカラー画像を作成した。このとき、(1)～(3)の変換で用いたR, G, Bトーンカーブの組み合わせとして正しいものを [R, G, Bトーンカーブの組み合わせ] 内の①～⑧から1つ選び、番号で答えなさい。

[R, G, Bトーンカーブの組み合わせ]

8. 練習問題の答え

解答1. トーンカーブのおさらい [基本編]

(1) 画素値を2倍にする変換

全体的に明るくなっている写真を選べばOK。
画素値を明るくすると、真っ白な画素（画素値255）が出てくるのも (エ) を選ぶ決め手かも。

(2) 画素値を1/2倍にする変換

全体的に暗くなっている写真を選べばOK。

(3) ネガポジ変換

白黒が完全に入れ替わっている（黒猫が白猫になっている）画像は (ウ) 以外にない。

(4) 2値化変換

(オ) 以外の画像には、「真っ黒」or「真っ白」ではない部分があるので2値化変換ではない。

(5) ソラリゼーション

画像の一部分だけがネガポジ変換されているのがポイント

[おまけ] 残りものの画像は…？

(1)～(5)で選ばれなかった選択肢は、「S字カーブの変換」に対応しています。

変換の前後でコントラストが高くなっている（暗い部分と明るい部分がはっきりしている）のが特徴です。

解答2. トーンカーブのおさらい [応用編]

[解答]

[変換過程]

元画像 → ①適用後

①適用後 → ②適用後

画素値を2倍にしてから1/2倍(0.5倍)に戻しても、画素値が255オーバーになった部分は元画像のようには戻らないのがポイント。

②適用後 → ③適用後(答え)

解答3. カラー画像とトーンカーブ

(1) 正解: ④

元画像に比べて、圧倒的に青色の成分が強くなっているのが決め手。

また、全体的に画像が明るくなったり暗くなったりしていないので、①や⑤のように全体の画素値を2倍(1/2倍)するトーンカーブではないのもポイント。

(2) 正解: ⑥

画像の赤部分がかなり消えていて、青と緑を中心とした画像になっているのが決め手。

また、(1)と同じく全体的に画像が明るくなったり暗くなったりしていないので、①や⑤のように全体の画素値を2倍(1/2倍)するトーンカーブではないのもポイント。

(3) 正解: ⑤

全体的に画像が暗くなっている点に着目。

また、(1)や(2)のように画像の色の度合いが変わっていないのもポイントの1つ。

9. さいごに

今回は、

• 画像処理の最も基本的な部分である「画素値を一定のルールに従っていじる」点の説明
• 画素値の変換で使う一定のルールを図でわかりやすく示した「トーンカーブ」について
• 代表的なトーンカーブの例
• カラー画像の画像処理の例

という点について説明し、最後に練習問題をおさらいしていきました。

次回は、まわりの画素にも着目した画像処理についてみていきましょう！

前回は「順序回路の設計で出てくる状態遷移図の状態数を最小化する」方法について説明しました。

うさぎでもわかる論理回路　順序回路の状態数最小化

※ この記事は、すでに「順序回路の設計をする際の状態遷移図・状態遷移表の書き方」を学んだ人向けの記事です。そのため、まだ

しかし、この方法は各状態における各入力ごとの状態遷移先と出力が決まっている場合にのみ使える最小化方法です。言い換えると、状態遷移先や出力が決まっていない（Don't Careが含まれている）状態遷移表は最小化することができません。

そこで今回は、「状態遷移先が出力が決まっていない、つまり遷移先や出力に Don't Careが含まれている」場合（不完全指定順序回路）でも最小化をする方法を勉強していきましょう。

1. 不完全指定順序回路とは

状態遷移表の遷移先（次状態）や出力に Don't Careが含まれているような順序回路のことを不完全指定順序回路と呼びます。

不完全指定順序回路には2種類あり、

• そもそも遷移先が Don't Careになっている場合
• 遷移先は決まっているが、出力が Don't Careになっている場合

があります。

(1) そもそも遷移先がDon't Careになっている場合

ある現状態から、ある入力を与えたときの次状態が定義されていない状態です。

次状態とそのときの出力の両方が同時に Don't Careになるのが特徴です。

上の例の場合、\( q_1 \) に対して \( x = 1 \) を入力した際の次状態と出力が X (Don't Care) になっていますね。

(2) 遷移先は決まっているが、出力が Don't Careになっている場合

ある現状態から、ある入力を与えたときの次状態は定義されていますが、出力が定義されていない状態です。

出力部分だけが Don't Careになるのが特徴です。

上の例の場合、\( q_1 \) に対して \( x = 1 \) を入力した際の次状態は \( q_0 \) と決まっていますが、出力が X (Don't Care) になっていますね。

2. 例題で流れを確認しよう

それでは、実際に不完全指定順序回路の状態最小化の流れを、例題で確認しましょう。

例題

次の状態遷移図で表されるを不完全指定順序回路の状態数が最小になるように（最小化）し、状態遷移図の形で答えなさい。

※ X は Don't Careを表す

Step1. 状態遷移表を作成する

まずは、状態遷移図を状態遷移表に落としこみましょう。

ここで、ある入力に対しての遷移先（矢印）が書かれていない場合がDon't Careになる点に要注意です。今回の場合は、

• \( q_2 \) のときに \( x = 0 \) を入力したとき
• \( q_4 \) のときに \( x = 1 \) を入力したとき

が存在しないので、この2つが「次状態・出力」ともにDon't Careとなります。

Step2. 両立性が成り立つ (ひとまとめに出来る可能性がある) 状態のペアを探す

前回の（Don't Careが含まれない）順序回路では、等価となる状態（ひとまとめにできる状態）の組み合わせをグループ分けすることで求めていきましたね。

しかし、Don't Careが含まれる場合は「単にグループ分けするだけ」では等価となる状態を見つけることができません^[1]イメージとしては、単独では Don't Careのおかげでひとまとめに出来ても、ひとまとめにしたペア同士を状態遷移表に適用する際に Don't … Continue reading。

そこで、Don't Careが含まれるような順序回路を最小化する際には、グループ化をする前に「ひとまとめにできる可能性がある状態のペア」を下の三角表に求めていきます。

ここで、「ひとまとめにできる可能性」のことを「両立性」と呼びましょう。

言い換えると、Step2では100%ひとまとめ出来ないペアを探していく作業をします。

Step2-1. 出力を確認し、ひとまとめ出来ないペアを探す

まずは、下のように「出力が異なる状態」を探すことでひとまとめに出来ないペアを探していきます^[2]出力が異なる状態は、100%ひとまとめにすることはできないため。。

ここで、Don't Careはワイルドカード (0, 1どちらでもOK）的な役割をすると考えてください。

Step2-2. 三角表からひとまとめに出来ないペアを探す

つぎに、三角表の×が付いていない（ひとまとめができる可能性がある）ペアに対し、「同じ入力を与えたときにひとまとめにできない（三角表で×が付いている）ペアに遷移する」ペアに×を付けていきます。

基本的なルールとしては

• ×が付いていない各ペアに対し、次状態の各入力ごとのペアに着目
• 着目した次状態のどれか1つの入力のペアでも「三角表に×が付いていれば」、現状態のペアに×を付ける
• ×が付いた場合、スタート地点（振り出し）に戻る
• 三角表の右下に到達したら終了

となります。

ただし、

• ペアのどちらか片方にでも X (Don't Care) が付いている場合
• ペアがともに同じ状態の場合

場合は、その入力のペアには「×」が付いていないとみなします。

★ 今回の状態遷移表 & 三角表に適用すると…？

適用の結果、下のように三角表が求まりました。

この「×」が付いていない部分が両立性が成り立つ（ひとまとめに出来る可能性がある）ペアです。

よって、状態群\[
\{ q_1, q_2 \}, \{ q_1, q_3 \}, \{ q_2 , q_3 \}, \{ q_2, q_4 \}
\]に両立性が成り立つ（ひとまとめに出来る可能性がある）ことがわかりました。

※ 両立性が成り立つ状態を \( \{ \ \ \ \} \) で表すことにします。例えば、\( a \), \( b \) に両立性が成り立つ場合は、\( \{ a,b \} \) と表記します。

Step3. 3状態以上の両立性が成立するか確認

つぎに「3状態以上に両立性が成立するか」を確認します。

ここで、3状態以上に両立性が成立するかの確認は次の通りです。

両立性が成立するかどうかは、下のように樹形図を書いて表現していくとわかりやすいです。

今回の場合、状態群 \( \{ q_1, q_2 \} \), \( \{ q_1, q_3 \} \), \( \{ q_2 , q_3 \} \) の両立性が成立することから、\( \{ q_1, q_2, q_3 \} \) の両立性が成り立つことが分かりますね。

Step4. 両立性から最小化できる状態群の組み合わせを決定する

つぎに、両立性が成り立つ状態（と単独の状態）から、なるべく少ない状態数で問題文の状態をすべて満足できるような組み合わせを考えます。

※ 組み合わせを考える際には、「両立性が成り立つ状態群（と単独の状態）」に含まれる「与えられた状態（今回の場合は \( q_0 \) ～ \( q_4 \)）」を〇で表した表を書くことをおすすめします。

Step4-1. 単独でしか満足できない状態 (必須状態) を探す

実際に表を見ると、\( q_0 \) はどの状態に対しても両立性が成り立たないので、\( q_0 \) 単品は確定で必要ですね。なので、これをグループ1としましょう。

Step4-2. 最小のグループ数で全状態を満足させる

なので、残りの \( q_1 \), \( q_2 \), \( q_3 \), \( q_4 \) をなるべく少ない状態数（グループ数）で満足できるようなペアを考えてみましょう。

ここでは、

1. 両立性が成立する状態群から1つ選択し、グループに加える
   （なるべく多くの状態がある状態群から選ぶ）
2. 加えたときに追加で必要な状態を「同じ入力であれば同じグループに遷移する」点で考える
   • 最小状態で出来そうなら完成
   • 最小状態で出来なさそうなら、1に戻り、他の状態群を選択する

まずは、3状態がまとまった状態群 \( \{ q_1, q_2, q_3 \} \) をグループ2に加えてみましょう。
※ なるべく多くの状態がまとまったものから順にグループだと仮定していきます。

ここで、X (Don't Care) はワイルドカード、つまりどのグループとして扱ってもよい状態だと思ってください。

ここでGroup2の色のペアを確認すると、\( x = 0 \), \( x = 1 \) のとき共に同じGroup2に遷移していることがわかりますね。

あとは、まだ追加していない \( q_4 \) をGroup3とすれば、どの状態も「同じ入力を与えたときに同じグループに遷移する」状態が作れますね。

（ここで、\( q_4 \) に \( x = 1 \) を入力したときの X (Don't Care) は、どのグループにしても状態数が変わらないのでそのままDon't Careとして扱います^[3]もちろん具体的にGroup1, 2, 3を設定してもOKです。ただし、順序実際に回路を設計する際に少し複雑になりますが…。。）

Step4-3. 各グループ内で代表状態を1つ選択し、まとめる

グループが確定したら、代表状態を1つ選択してまとめましょう。

ここで X (Don't Care) は、他のグループの出力に合うように設定してください^[4]0, 1どちらを入れても成立する場合はXのままでOKです。。

今回は、下のようにまとめてみましょう^[5]各グループごとに全く新しい名前（例：Group1を"1"、Group2を"2"、Group3を"3"とする）としてもOKです。。

• Group1の状態 → \( q_0 \) にまとめる
• Group2の状態 → \( q_1 \) にまとめる
• Group3の状態 → \( q_4 \) にまとめる

Step5. Step4で書いた状態遷移表を状態遷移図にする

あとは、状態遷移表を状態遷移図に落とし込めば完成です！

（ここで Don't Careがある場合には表記に気を付けましょう。今回の例の場合、\( q_4 \) から \( x = 1 \) を入力としたときの遷移が存在しない点に注意が必要です。

3. グループ分けの際の補足 [Step4-2]

例題のStep4-2で行った「状態郡を組み合わせたグループ分け」について、2点補足をしておきます。

[補足1] 状態が複数グループに属してもOK

与えられた状態をすべて満足するように状態群を選べていれば、状態が複数グループに属していてもOKです。

例えば、状態群から\[
\textcolor{red}{ \{ q_0 \} } , \textcolor{blue}{ \{ q_1, q_2, q_3 \} }, \textcolor{green}{ \{ q_2, q_4 \} }
\]と選択し、それぞれ

• \( q_0 \) → Group1
• \( q_1, q_2, q_3 \) → Group2
• \( q_2, q_4 \) → Group3

とした場合、\( q_2 \) がGroup2, 3両方に属しますが、全状態が1回以上出てきているのでOKです。

ただしこの場合、

• 2つ以上のグループに属する状態は、グループごとに現状態を記述する
• 次状態に出てくる状態が2つ以上のグループに属する場合、各状態ごとに都合のいい方を選択する

ことに注意してください。

あとは、Group2, 3両方に属する \( q_2 \) に対して都合のいい方を選んでから、代表状態を選び、まとめればOKです。

[補足2] グループ分けが1発でうまくいかない場合

両立性はあくまでも「1つにまとめられる可能性」なので、選んだ状態群によっては、1発でグループ分けがうまくいかないことがあります。

例えば今回の例題の場合、\( \{ q_0 \} \) に加えて、状態群から \( \{ q_1, q_3 \} \), \( \{ q_2, q_4 \} \) の合計3状態で最小化できそうかと思うかもしれません。

しかし、実際に\( \{ q_1, q_3 \} \) をグループに加えてみると、最低でも \( \{ q_1, q_2 \} \) および \( \{ q_2, q_4 \} \) を加える必要があることがわかります^[6]\( q_1, q_3 \) の入力 \( x = 1 \) に着目すると、\( (q_1, q_2) \) が出てくるため、最低でもこのペアは同じ状態に属せるように状態 \( \{ q_1, q_2 \} \) … Continue reading。

そのため、\( \{ q_0 \} \), \( \{ q_1, q_3 \} \), \( \{ q_2, q_4 \} \) を使った最小化は出来ない（最低でもこれら3つの状態に加えて1つ別の状態が必要）なことがわかります。

4. 練習問題にチャレンジ

それでは、不完全指定順序回路の最小化の練習を、例題より少し複雑な問題でしてみましょう。

練習問題

次の状態遷移表で表されるを不完全指定順序回路の状態数が最小になるように（最小化）し、状態遷移図の形で答えなさい。

※1 X は Don't Careを表す
※2 表の 00, 01, 10, 11は2変数の入力を表す

[解説]

今回は、最初から状態遷移表が与えられているので、Step1は不要です。

Step2. 両立性が成り立つペアを探す

Step2-1. 出力の組み合わせから両立性が成り立たないペアを見つける

まずは、出力に着目しながら両立性が成り立たないペアを見つけて行きましょう。

※ X (Don't Care) はワイルドカードなので、0, 1どちらか片方を入れて成り立てばOKです。

すると、三角表は下のようになります。

Step2-2. 三角表からひとまとめに出来ないペアを探す

つぎに、「次状態の入力と三角表」に着目しながら両立性が成り立たないペアを探しましょう。

具体的には、

• ×が付いていない各ペアに対し、次状態の各入力ごとのペアに着目
• 着目した次状態のどれか1つの入力のペアでも「三角表に×が付いていれば」、現状態のペアに×を付ける
• ×が付いた場合、スタート地点（振り出し）に戻る

を「三角表の右下」に到達するまで続けます。

※ スペースの関係上、X (Don't Care) とペアになっている部分には [Don't Care] の代わりに [wild] と表記しています。

すると、三角表は下のようになります。

つまり、×がついていない\[
\{ q_0 , q_1 \}, \{ q_0, q_3 \}, \{ q_1, q_4 \}, \{ q_2, q_3 \}, \{ q_2, q_4 \}, \{ q_3, q_4 \}
\]の状態郡が両立性を持つペアとなります。

Step3. 3状態以上の両立性が成立するか確認

つぎに、3状態以上の状態群でも両立性が成立するかどうかを樹形図を書くなどで確認しましょう。

今回は \( \{ q_2, q_3 \} \), \( \{ q_2, q_4 \} \), \( \{ q_3, q_4 \} \) に両立性が成立するので、\( \{ q_2, q_3, q_4 \} \) の3状態ある状態群に対して両立性が成立します。

Step4. 両立性から最小化できる状態群の組み合わせを決定する

Step4-1. 単独でしか満足できない状態 (必須状態) を探す

表を書くことでもわかるのですが、今回は \( q_0 \) ～ \( q_4 \) 単独でしか満足できない状態はありません。

そのため、\( q_0 \) ～ \( q_4 \) を最小の状態数で満足させることを Step4-2 で考えます。

Step4-2. 最小のグループ数で全状態を満足させる

まず真っ先に

• 3状態ある状態群 \( \{ q_2, q_3, q_4 \} \) をGroup1とする
• 残りの \( \{ q_0, q_1 \} \) がGroup2になってくれればいいな

が思いつくと思います。（この組み合わせなら2状態で表現できますし。）

なので、\( \{ q_2, q_3, q_4 \} \) をGroup1とし、各入力00, 01, 10, 11ごとの遷移先を確認しましょう。

すると、

• 00が入力のとき：Group1の状態から「\( q_4 \), \( q_1 \) に遷移する」
  → \( \{ q_0, q_1 \} \) を別グループ (Group2) として追加が必要
• 10が入力のとき：Group1の状態から「\( q_0 \), \( q_1 \) に遷移する」
  → \( \{ q_1, q_4 \} \) を別グループ (Group3) として追加が必要

となるため、最低でも3グループが必要となることがわかりますね。

さらに、Group2 \( \{ q_0, q_1 \} \) から各入力00, 01, 10, 11ごとの遷移先を確認します。

すると、入力10, 11のときに \( q_0 \), \( q_3 \) に遷移するので、 \( \{ q_0, q_3 \} \) も別グループ (Group4) として追加する必要があります。

この時点で4グループ出てきてしまっているため、いったん \( \{ q_2, q_3, q_4 \} \) をグループに加えた場合は保留します。

代わりに、今度は \( \{ q_0, q_1 \} \) をGroup1としてみましょう。

すると、入力10, 11のときに \( q_0 \), \( q_3 \) に遷移するので、 \( \{ q_0, q_3 \} \) を同じ状態にするためにGroup2に加えましょう。

今度は、\( \{ q_0, q_3 \} \)[Group2] の次状態に着目しましょう。

すると、入力00のときに \( q_2 \), \( q_4 \) に遷移するので、\( \{ q_2, q_4 \} \) を同じ状態にするためにGroup3に加えます。

さらに \( \{ q_2, q_4 \} \) [Group3] の次状態に着目しましょう。

すると、00, 01, 10, 11どの入力をしたときも必ず Group1, Group2, Group3 の組み合わせ（もしくはDon't Careが片方にでもある）状態となっていますね。

そのため、

• Group1: \( \{ q_0, q_1 \} \)
• Group2: \( \{ q_0, q_3 \} \)
• Group3: \( \{ q_2, q_4 \} \)

とした3状態に最小化が可能です。

Step4-3. 各グループ内で代表状態を1つ選択し、まとめる

あとは、下の表をグループごとにまとめればOKです。
（事前に同じグループの出力を一致させるために X に何を入れればよいかを小さく記入しています）

具体的には、

• Group1: \( \{ q_0, q_1 \} \) → 代表 \( q_0 \)
• Group2: \( \{ q_0, q_3 \} \) → 代表 \( q_3 \)
• Group3: \( \{ q_2, q_4 \} \) → 代表 \( q_4 \)

と代表を決め、出力部分の X (Don’t Care) の値を決定してから状態遷移表を作成すればOKです。

Step5. 状態遷移図に変換する

あとは、Step4-3で作った状態遷移表を状態遷移図に変換すればOKです。

5. さいごに

今回は順序回路の状態遷移図に X [Don't Care] が含まれる不完全指定順序回路の状態最小化についてみていきました。

通常の順路回路の状態最小化より難易度が少し高く、理解が難しい部分ですがこの記事を見て理解の助けになれば幸いです。

これにて、順序回路に関する記事は全て終了です！　今まで見てくださり、ありがとうございましたm(__)m

（工業大学生ももやまのうさぎ塾では、「うさぎでもわかる」をモットーに様々な大学数学系・情報系の科目を解説しています。なので、もし他の理系科目でわからないなと思うことがあれば、「(分野名) (単元名) うさぎ」などと是非調べてみてください。きっと、理解の助けになる私の記事が出てくるかなと思います。）

6. 参考文献

近畿大学 - 順序回路の状態数の最小化
[アクセス日: 2022/07/31]

https://www.info.kindai.ac.jp/LC/lecture/LogicCircuits12note.pdf