講義資料 - Toyama

2015 年度情報論理学講義資料 (1)
青戸等人
はじめに
1
次の 3 つの等式を満たす演算をもつ集合のことを群という．


 +(0, x) ≈ x

+(−(x), x) ≈ 0


+(+(x, y), z) ≈ +(x, +(y, z))
ここで， x, y, z は変数で， +, −, 0 は集合上の演算である． (本講義では， = の代わり
に ≈ を対象言語の等号に用いる． ) 通常， +, −, 0 は実数や整数の加算，符号反転，
零に使われることが多いが，群論では，これらに限定せず，一般に上の等式が満た
されるものすべてを対象にして，どんな性質が成立するかを調べる．
このような等式の公理からどのような等式が導かれるか，を考える枠組みが等式
論理 (equational logic) とよばれるものである．例えば，群の公理のモデルは” 群” と
よばれ，他にも束の公理のモデルは” 束” とよばれる．一般に，このような等式公理
のモデルは代数とよばれ，その数学理論がいろいろ詳しく調べられており，例えば
群や束であれば，群論や束論として知られている．
この講義では，等式理論にもとづく計算モデルである項書き換えシステムについ
て，いくつかのトピックスを取り上げ講義する．等式のみを対象にするということ
はとても限定的な気がするかもしれないが，項表現に変数束縛を導入するなどして，
ラムダ計算などを含むような，より表現力を高めた項書き換えシステムについての
研究も精力的に進められている．また，述語論理の自動証明などにおける等式特有
の取り扱いにおいても書き換えシステムの技術が応用されている．
また，表面的な内容だけでなく，細かい証明も触れてもらうし， SML#1 を用い
たプログラムを作成しながら，理解を深めてもらう．本文中のプログラムは， http:
//www.nue.riec.tohoku.ac.jp/user/aoto/15LogicG/ に置く 2． SML 言語につい
ては，いろいろな教科書があると思うが， [2], [3] だけ挙げておく．項書き換えシス
テムについては， (お話的な ) 解説は [4] にあるが，きちんとした教科書は日本語では
ない．英語では [1] はきちんとした内容で比較的読みやすいが，内容はだいぶ古く，
理論的な本を読み慣れていない人にはだいぶ難しい．
関数記号と変数
2
演算を表わす記号を関数記号 (function symbol ) とよぶ．関数記号は，それぞれ，引
数の個数が決まっているものとする．この数をアリティという．関数記号 f のアリ
SML#は東北大学電気通信研究所大堀研究室で開発されている SML 言語のコンパイラ
http://www.pllab.riec.tohoku.ac.jp/smlsharp/ja/
2
プログラムはこれを参考にせずに /使わずに書いても，まったく構わない．
1
1
ティを arity(f ) と記す．特に，アリティは 0 でもよいものとする．アリティが 0 の
関数記号とは，つまり，定数 (constant) のことになる．
等式公理を表わすためには，関数記号の他に，変数 (variable) が必要となる．ま
た，変数は (可算) 無限個あるものとする．従って，必要になるたびに，まだ使われ
ていない変数をいつでも用意できる．
また，同じ記号が関数記号かつ変数になることはないものとする．つまり，関数
記号の集合を F ，変数の集合を V とするとき， F ∩ V = ∅ が成立する．以下では，特
に断わらない限り，変数全体の集合を V と記し，関数記号全体の集合を F と表わす．
変数や関数記号をプログラムで扱うために，これらのデータ型を定義しよう．
まず，変数に関するデータ型や関数をおく Var ストラクチャを用意する．変数は
x1 や y2 のように，変数名と自然数のインデックスの対から構成されるものとする．
自然数のインデックスは変数を新しいものにするときに便利． Var.name は変数名の
部分を， Var.index はインデックスを取り出す．
1
2
3
4
5
6
7
(* var.sml *)
signature VAR =
sig
eqtype key
val name: key -> string
val index: key -> int
end
8
9
10
11
12
13
14
structure Var : VAR =
struct
type key = string * int
fun name (x,i) = x
fun index (x,i) = i
end
同様にして，関数記号に関するデータ型や関数をおく Fun ストラクチャを用意す
る．関数記号の場合は，関数名そのものを関数記号としよう．
1
2
3
4
5
(* fun.sml *)
signature FUN =
sig
eqtype key
end
6
7
8
9
10
structure Fun : FUN =
struct
type key = string
end
さて，変数や関数記号をプログラム上で入力するには，文字列から入力するのが
便利である．そこで， “変数 ⇄ 文字列”， “関数記号 ⇄ 文字列” という変換を行う
プログラムを用意しておく．
変数は， _[1-9][0-9]* (つまり，アンダースコア “_” に 1∼ 9 から始まる数字列
が続いたもの ) が末尾にあるとき，この部分を自然数のインデックスとして扱うこと
2
にする (ただし，その前の変数名の部分が空文字列のときは例外とする )．そのような
末尾がないときのインデックスは 0 と定める．関数記号では，文字列がそのまま関数
記号と対応する． toString 関数は，変数や関数記号を文字列へ変換し， fromString
関数は，文字列を変数や関数記号へ変換する．
1
2
3
4
5
6
7
(* var.sml *)
signature VAR =
sig
...
val toString: key -> string
val fromString: string -> key
end
8
9
10
11
12
13
14
structure Var : VAR =
struct
...
fun toString (x,i) = if i = 0 then x
else if Int.> (i, 0) then x ^ "_" ^ (Int.
toString i)
else raise Fail "Error: Var.toString: var index
out of range"
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
(* .+_[1-9][0-9]* となっていれば末尾を index とする *)
fun fromString str =
let val ss = Substring.full str
val (body,index) = Substring.splitr Char.isDigit ss
val isProperIndexing = Int.> (Substring.size body, 1)
andalso Substring.sub (body, Substring.
size body - 1) = #"_"
andalso not (Substring.isEmpty index)
andalso Substring.sub (index, 0) <> #"0"
in if isProperIndexing
then (Substring.string (Substring.trimr 1 body),
valOf (Int.fromString (Substring.string index)))
else (str,0)
end
end
(* fun.sml *)
signature FUN =
sig
...
val toString: key -> string
val fromString: string -> key
end
8
9
10
11
12
structure Fun : FUN =
struct
...
fun toString key = key
3
13
14
fun fromString str = str
end
最後に，以上のプログラムの実行例をいくつか示す．ソースファイルをインタ
プリタで扱うためには use ディレクティブを使う．いまは 2 つしかファイルがない
(var.sml， fun.sml) が，これから増えてくると何度もファイルをロードするのは大
変なので，必要なすべてのソースファイルを 1 度に読み込むために，以下の内容の
ファイル use.sml を用意しておく．
1
2
3
(* use.sml *)
_use "var.sml"
_use "fun.sml"
SML#では， use ディレクティブはインタプリタのトップ環境でしか使えないの
で，ファイルの中では代わりに _use を使う必要がある．
以下は， Unix 環境でインタプリタを動かした様子．
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
(* 実行例 *)
$ ls
(* シェル環境 *)
fun.sml use.sml var.sml
$ smlsharp
SML# version 1.2.0 (2012-11-14 18:25:26 JST) for x86-linux
# use "use.sml";
signature FUN =
...
...
...
# Var.fromString "x_12";
val it = ("x", 12) : string * int
# Var.fromString "x_012";
val it = ("x_012", 0) : string * int
# Var.fromString "_12";
val it = ("_12", 0) : string * int
# Fun.fromString "+";
val it = "+" : string
#
(* Ctrl-D で終了*)
$
(* シェル環境に戻った *)
演習 1 SML#コンパイラをインストールせよ．インタプリタで， val.sml, fun.sml
を読み込み，テストせよ．
3
項 (term)
等号はある対象とある対象の間に成立する関係である．この対象を表わす記号列を
項という．群の公理における等号の左辺や右辺は項である．
定義 2 (項) 項 (term) を以下のように帰納的に定義する．
(1) 変数は項である．
(2) f をアリティ n の関数記号， t1 , . . . , tn を項とするとき， f (t1 , . . . , tn ) は項である．
4
特に， (2) で， n = 0 のときは f と書く．
定義から明らかなように，項は変数全体の集合 V と関数記号全体の集合 F から
定まる．つまり， V と F は項集合のパラメータになっているから，項全体の集合を
T(F, V) と記すことにする．
例 3 (項の例) F = {+, −, 0} とすると， −(0) や +(0, x0 )， −(+(0, x0 )) は，項の例
である．
項に関するデータ型や関数をおく Term ストラクチャを用意しよう．
1
2
3
4
5
6
7
(* term.sml *)
signature TERM =
sig
type var_key = Var.key
type fun_key = Fun.key
datatype term = Var of var_key | Fun of fun_key * term list
end
8
9
10
11
12
13
structure Term : TERM =
struct
type var_key = Var.key
type fun_key = Fun.key
datatype term = Var of var_key | Fun of fun_key * term list
項を表わすデータ型 term としては，関数記号の下に，項のリストを持てるよう
にする．プログラム内では制約を受けないが，この項のリストの長さは， (暗黙的に )
関数記号のアリティと対応することと約束する．
演習 4 Term ストラクチャに，与えられた項が変数かを返す isVar:
および変数でないかを返す isFun: term -> bool を追加せよ．
term -> bool
演習 5 Term ストラクチャに， args x = [ ]， args f (t1 , . . . , tn ) = [t1 , . . . , tn ] となる
ような，与えられた項の引数を返す関数 args: term -> term list を追加せよ．
定義 6 (根記号) 項 t の根記号 root(t) を以下のように定める．
x (t = x ∈ V の場合)
root(t) =
f (t = f (t1 , . . . , tn ) の場合)
例 7 root(+(x, +(y, 0))) = +．
項 t から root(t) を計算する関数を書こう． root 関数を用意するためには，変数
と関数記号を一緒に扱う必要がある．そこで， F ∪ V を表わすためのデータ型とし
て， Symbol ストラクチャを用意し， symbol 型を定義しておく．
5
1
2
3
4
5
(* symbol.sml *)
signature SYMBOL =
sig
datatype symbol = V of Var.key | F of Fun.key
end
6
7
8
9
10
structure Symbol : SYMBOL =
struct
datatype symbol = V of Var.key | F of Fun.key
end
演習 8 Term ストラクチャに，与えられた項の根記号を返す関数 root:
Symbol.symbol を追加せよ．
term ->
定義 9 (項の変数集合) t を項とするとき， V(t) を以下のように定義する．
{x}
(t = x ∈ V の場合)
V(t) = S
1≤i≤n V(ti ) (t = f (t1 , . . . , tn ) の場合)
例 10 V(+(x, +(y, 0))) = {x, y}．
V(t) を計算する関数を書こう．このために，まず， ListUtil ストラクチャを用
意し，その中に，集合演算をリストを使って実現する関数を用意する． member x xs
は要素 x がリスト xs に含まれているかを判定する． add x xs は要素 x が xs に含ま
れていないときだけリストに x を追加する．つまり， xs に要素が 2 重に含まれてい
ないなら，追加した後も要素は 2 重に含まれない． union xs ys は， 2 つのリスト
xs と ys を，同じ要素が重複されないように結合する．
1
2
3
4
5
6
7
(* list_util.sml *)
signature LIST_UTIL =
sig
val member: ’’a -> ’’a list -> bool
val add: ’’a -> ’’a list -> ’’a list
val union: ’’a list * ’’a list -> ’’a list
end
8
9
10
11
12
structure ListUtil : LIST_UTIL =
struct
fun member x [] = false
| member x (y::ys) = x = y orelse member x ys
13
14
15
(* 集合としての演算 *)
fun add x ys = if member x ys then ys else x::ys
16
17
...
18
19
end
6
演習 11 ListUtil ストラクチャに，関数 union を補え．
演習 12 Term ストラクチャに， t から V(t) を返す関数 vars:
list を追加せよ．
term -> var key
最後に，変数や関数記号について行ったように， “項 ⇄ 文字列” の変換関数を用
意する．
まず，変数と関数記号を区別する必要があるが，文字列のうち，先頭に ?がつい
ているものを変数とし，そうでないものは関数記号とする．
1
2
3
4
5
6
7
(* symbol.sml *)
signature SYMBOL =
sig
...
val toString : symbol -> string
val fromString : string -> symbol
end
8
9
10
11
12
13
structure Symbol : SYMBOL =
struct
...
fun toString (V x) = "?" ^ (Var.toString x)
| toString (F f) = (Fun.toString f)
14
15
16
17
18
19
fun fromString str =
if String.isPrefix "?" str
then V (Var.fromString (String.substring (str, 1, (String.size
str) - 1)))
else F (Fun.fromString str)
end
文字列から項を得るには，字句解析・構文解析が必要になる．字句解析では， 3
つ特殊文字 “(”,“)”， “,” を切り出すとともに，これらの特殊文字と空白を区切りと
して得られる文字列の列に分解する．構文解析は，以下の項の構文にあっているか
をチェックする． fsym， vsym は，それぞれ関数記号となる文字列，変数となる文字
列を表わす．プログラムの詳細は省略する． lexical.sml には字句解析のツール，
parsing.sml には構文解析のツールが入っている．
1
2
3
4
1
2
3
4
5
6
term ::= fsym "(" termlist | atom
termlist ::= termseq ")"
termseq ::= term "," termseq | term
atom ::= fsym | vsym
signature TERM =
sig
...
val toString: term -> string
val fromString: string -> term
end
7
最後に，実行例を示す．
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
4
$ ls
fun.sml lexical.sml list_util.sml parsing.sml symbol.sml
sml use.sml var.sml
$ smlsharp
SML# version 1.2.0 (2012-11-14 18:25:26 JST) for x86-linux
# use "use.sml";
functor Lexical
...
...
# val t0 = Term.fromString "?x";
val t0 = _ : Term.term
# val t1 = Term.fromString "+(s(?x),?x)";
val t1 = _ : Term.term
# Term.toString t0;
val it = "?x" : string
# Term.toString t1;
val it = "+(s(?x),?x)" : string
# Term.isFun t0;
val it = false : bool
# Term.isFun t1;
val it = true : bool
# Symbol.toString (Term.root t0);
val it = "?x" : string
# Symbol.toString (Term.root t1);
val it = "+" : string
# List.map Term.toString (Term.args t1);
val it = ["s(?x)", "?x"] : string list
# List.map Var.toString (Term.vars t1);
val it = ["x"] : string list
#
(* Ctrl-D で終了 *)
$
(* シェル環境にもどった *)
term.
代入 (substitution)
変数は項で具体化される．これを行うのが代入．
定義 13 関数 σ : V → T(F, V) で，集合 {x | σ(x) 6= x} が有限であるものを代
入 (substitution) とよぶ．集合 {x | σ(x) 6= x} を代入 σ の定義域 (domain) とよび，
dom(σ) と記す．
dom(σ) = {x1 , . . . , xn } であるとき，特に， σ を {x1 := σ(x1 ), . . . , xn := σ(xn )}
のようにも書く．
例 14 σ = {x := 0, y := +(x, z)} は代入．このとき， σ(x) = 0， σ(y) = +(x, z) と
なる．また， w ∈
/ {x, y} である任意の変数 w については， σ(w) = w となる．
8
定義 15 代入 σ の準同型拡張とは，以下のように定義される関数 σ̂ : T(F, V) →
T(F, V) をいう．
σ(t)
t ∈ V のとき
σ̂(t) =
f (σ̂(t1 ), . . . , σ̂(tn )) t = f (t1 , . . . , tn ) のとき
代入 σ とその準同型拡張 σ̂ を同一視して， σ̂ と書くべきときも σ を用いる．
例 16 σ = {y := +(x, z)} とすると， σ(+(+(0, x), y)) = +(+(0, x), +(x, z)) となり，
σ(+(y, y)) = +(+(x, z), +(x, z)) となる．
このために代入を扱うために，連想リスト (association list) に関するプログラム
を用意する．
連想リストは， (key, value) なる対を要素にもつようなリストで，鍵 (key) から値
(value) への対応を保持しておくためのデータ構造である．単なる対のリストと異な
り， 1 つの鍵に対応する値は 1 つしか保持しないという制限がある．つまり，
条件：リスト中の任意の 2 つの異なる要素 (x, n) と (y, m) について， x 6= y となる
が成立するようにメンテナンスをする．なお，この条件は，
条件：リスト中の任意の要素 (x, n) と (y, m) について， x = y ならば n = m．
とも書ける．
まず， AssocList ストラクチャを用意し，その中に，連想リストを対のリストを
使って実現する関数を用意する． find k xs は k を鍵とする要素が連想リスト xs に
含まれているかを判定し， (k,v) が要素となっていれば SOME v を， k を鍵とする要
素がなければ NONE を返す．
add (k,v) xs は，連想リストに (k,v) を追加する．もし (k,v) がすでに要素と
なっていれば重複を避けるために実際には追加しないので， SOME xs を返す．もし
(k,w) で， w が v とは異なるような要素が xs に入っていたときには， (k,v) を付け
加えることは出来ない．このときは NONE を返す．最後に， k を鍵とするような要素
が xs に含まれていないときには， (k,v) をリストに追加して SOME ((k,v)::xs) を
返す．
1
2
3
4
5
6
(* assoc_list.sml *)
signature ASSOC_LIST =
sig
val find: ’’a -> (’’a * ’b) list -> ’b option
val add: (’’a * ’’b) -> (’’a * ’’b) list -> (’’a * ’’b) list
option
end
7
8
9
10
11
12
13
14
15
16
structure AssocList : ASSOC_LIST=
struct
fun find x [] = NONE
| find x ((k,v)::ys) = if x = k then SOME v else find x ys
fun add (k,v) ys = case find k ys of
SOME w => if v = w then SOME ys
else NONE
| NONE => SOME ((k,v)::ys)
end
9
最後に，代入に関する関数を置く Subst ストラクチャを用意する．ここでは， find
関数しか使っていないが， add 関数は後に用いる． apply 関数は，代入を項に適用
する関数である．
1
2
3
4
5
6
(* subst.sml *)
signature SUBST =
sig
type subst
val apply: subst -> Term.term -> Term.term
end
7
8
9
10
11
12
13
14
15
16
17
18
19
20
structure Subst: SUBST =
struct
local
structure AL = AssocList
structure L = List
structure T = Term
in
type subst = (Var.key * Term.term) list
fun apply sigma (T.Var x) = (case AL.find x sigma of
SOME t => t | NONE => T.Var x)
| apply sigma (T.Fun (f,ts)) = T.Fun (f, L.map (apply sigma) ts)
end (* of local *)
end
以下は代入の実行例．
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ ls
assoc_list.sml lexical.sml
parsing.sml symbol.sml use.sml
fun.sml
list_util.sml subst.sml
term.sml
var.sml
$ smlsharp
SML# version 1.2.0 (2012-11-14 18:25:26 JST) for x86-linux
# use "use.sml";
...
...
# val sigma = [(Var.fromString "x", Term.fromString "0"), (Var.
fromString "y", Term.fromString "+(?x,?y)")];
val sigma = [(("x", 0), _), (("y", 0), _)] : ((string * int) * Term.
term) list
# Subst.apply sigma (Term.fromString "+(s(?x),?y)");
val it = _ : Term.term
# Term.toString it;
val it = "+(s(0),+(?x,?y))" : string
#
(* Ctrl-D で終了*)
$
(* シェル環境に戻った *)
10
References
[1] F. Baader and T. Nipkow. Term Rewriting and All That. Cambridge University
Press, 1998.
[2] 大堀淳. プログラミング言語 Standard ML 入門. 共立出版株式会社, 2001.
[3] L. C. Paulson. ML for the Working Programmer, 2nd ed. Cambridge University
Press, 1996.
[4] 外山芳人. 項書き換えシステム入門 -完備化による定理自動証明-. http://www.
nue.riec.tohoku.ac.jp/lab-intro/TRS-intro/
11

Download Report