コンピューターの計算 https://ameblo.jp/i8am00/ プログラミングの学習過程における感想や不満を書きなぐることにより、学習意欲の維持と自己顕示欲の充足とを図ることを目的とする。 ja プログラミングinOCaml 練習問題3.5の答案と感想 練習問題3.5

　この問題は、練習問題3.4で定義したオブジェクトおよび擬似関数を用いて解く。それらの擬似関数などを以下に示す。

 

束縛

　順序対(var, val)で表す。ここで、varは変数、valは値である。

 

部分環境

　順序対(A, R)であり、[]による記法で表す。ここで、Aは同変数の束縛のクラス、RはA上の順序関係である。また、[]には宣言の新しい順に束縛が並ぶ。

例: x = 3, x =1の順で宣言がなされたときの変数xの部分環境
[(x, 1), (x, 3)]

 

環境(全体環境)

　部分環境の和クラスであり、[]と⊕とによる記法で表す。

例: 変数xと変数yとが宣言された環境
[(x, 1), (x, 3)]⊕[(y, 1)]

 

宣言関数𝔇

　環境Envと宣言による束縛のクラスとから新しい環境Env'を選ぶ。

Env' = 𝔇(Env, {(var₀, val₀), ..., (varₙ, valₙ)})

 

評価関数𝔈

　式exprを環境Envで評価する。

val = 𝔈(expr, Env)

 

 

　以下の答案では、本問の2種類の宣言のうち、xとyとを同時に宣言するものを同時宣言と呼び、xを宣言した後にyを宣言するものを逐次宣言と呼ぶ。また、初期の大域環境Envを空[]とする。

 

同時宣言

　同時宣言後の大域環境Envₚ'は、

Envₚ' = 𝔇(Env, {(x, 𝔈(e₁, Env)), (y, 𝔈(e₂, Env))})
= {(x, 𝔈(e₁, Env)), (y, 𝔈(e₂, Env))} ⇢ []
= [(x, 𝔈(e₁, Env))] ⊕ [(y, 𝔈(e₂, Env))]

となる。

 

逐次宣言

　xについての宣言後の大域環境Envₛ'は、

Envₛ' = 𝔇(Env, {(x, 𝔈(e₁, Env))})
= {(x, 𝔈(e₁, Env))} ⇢ []
= [(x, 𝔈(e₁, Env))]

となり、yについての宣言後の大域環境Envₛ''は、

Envₛ'' = 𝔇(Envₛ', {(y, 𝔈(e₂, Envₛ'))})
= 𝔇([(x, 𝔈(e₁, Env))], {(y, 𝔈(e₂, [(x, 𝔈(e₁, Env))]))})
= {(y, 𝔈(e₂, [(x, 𝔈(e₁, Env))]))} ⇢ [(x, 𝔈(e₁, Env))]
= [(x, 𝔈(e₁, Env))] ⊕ [(y, 𝔈(e₂, [(x, 𝔈(e₁, Env))]))]

となる。

 

　以上から相違点をまとめる。

答え:　同時宣言と逐次宣言とは、yに束縛される値が式e₂を評価したものである点は同じだが、その式e₂を評価する大域環境が異なる。
　より詳細には、同時宣言では初期の大域環境で式e₂が評価される。一方、逐次宣言では、変数xと式e₁の値との束縛が初期の大域環境に追加された大域環境で式e₂が評価される。

 

 

感想

正解

　どうにも正解の確信が持てずモヤモヤする。原因はlet定義にあるのだろう。

　いまさらだが、let定義は式ではない。式ではないのなら何なのだろう。テキストでは、OCamlのプログラムの実行とは、式を評価して値を求めることだ、との説明がなされていた。

　それならば式でないlet定義は、少なくとも"普通"のプログラムの実行ではなく、何か"特別"な動作なのだろうか。そういえば、let定義が対象とする大域環境も、OCamlでは明示的に扱えない。このあたりがモヤモヤの原因か。

　つまり、問題の2つのlet定義は違いがあるものの、その違いは外部には現れない。現れるのはプログラムが実行され、let定義されたyが評価されたときだが、そこまでは問題に含まれていない。なんのことはない、目に見える明確な違いを示してスッキリしたいのだが、それができないからモヤモヤしていただけか。

 

let定義

　そもそもlet定義は必要なのだろうか。変数の定義は、let式があればこと足りるように思える。なぜなら、let定義だけ行うプログラムというのはありえない。必ずlet定義した変数を評価するはずだ。ならば、その評価のときにlet式を使えばよいのだ。もっといえば、プログラムの全部を1つの大きなlet式で覆ってしまえばよい。

　計算という点、OCamlでいうところの式の評価という点からは、let定義は不要に思える。必要となるのは、対話式のインターフェイスなどでだろう。let定義は、プログラマの便宜を図るために、実用性の観点から導入された仕組みなのだろうか。

　また、式の評価(値)が文脈に左右されるのはどうにも気持ちが悪い。例えば、関数fを、

　let f x = (f x) + 1

と定義した場合、再定義の回数によって、

　f 0 = ?

が異なる。これでは、対話式でうっかりミスして再定義した場合には、原因不明のバグに悩まされることになる。せめて、大域環境をダンプできればチェックのしようもあるのだが。

　とはいえ、この問題を解くまでは、何の疑問もなく使ってきた。気にしなければ、便利な仕組みなのだが。

 

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743799130.html Fri, 20 May 2022 12:00:00 +0900 プログラミングinOCaml 練習問題3.4② ～③の答案 練習問題3.4

　②および③についても①と同様の解き方を用いる。

 

 

 

　まずは、①で定義したオブジェクトおよび擬似関数を示す。

束縛

　順序対(var, val)で表す。ここで、varは変数、valは値である。

 

部分環境

　順序対(A, R)であり、[]による記法で表す。ここで、Aは同変数の束縛のクラス、RはA上の順序関係である。また、[]には宣言の新しい順に束縛が並ぶ。

例: x = 3, x =1の順で宣言がなされたときの変数xの部分環境
[(x, 1), (x, 3)]

 

環境(全体環境)

　部分環境の和クラスであり、[]と⊕とによる記法で表す。

例: 変数xと変数yとが宣言された環境
[(x, 1), (x, 3)]⊕[(y, 1)]

 

部分環境関数ℭ

　変数varについての部分環境(A, R)を環境Envから抜き出す。

(A, R) = ℭ(Env, var)

 

参照関数ℜ

　環境Envにおける変数varの参照。

val = ℜ(Env, var)

 

宣言関数𝔇

　環境Envと宣言による束縛のクラスとから新しい環境Env'を選ぶ。

Env' = 𝔇(Env, {(var₀, val₀), ..., (varₙ, valₙ)})

 

評価関数𝔈

　式exprを環境Envで評価する。

val = 𝔈(expr, Env)
let式の書換え規則
𝔈(let var₀ = expr₀ and ... and varₙ = exprₙ in expr, Env)
= 𝔈(expr, 𝔇(Env, {(var₀, 𝔈(expr₀, Env)), ..., (varₙ, 𝔈(exprₙ, Env))})
関数の書換え規則
𝔈(f(x, y), Env) = f(𝔈(x, Env), 𝔈(y, Env))
変数の書換え規則
𝔈(var, Env) = ℜ (Env, var)
定数の書換え規則
𝔈(val, Env) = val

 

 

　次に、これらの定義を用いた練習問題3.4②, ③の答案を示す。

 

 

 

②

式の書換え

　初期の環境をEnv₀とする。②の式についての評価関数𝔈は、

𝔈(let x = 2 and y = 3 in (let y = x and x = y + 2 in x * y) + y, Env₀)

である。Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀)), (y, 𝔈(3, Env₀))})とおくと、let式の書換え規則により、

= 𝔈((let y = x and x = y + 2 in x * y) + y, Env₁)

関数の書き換え規則により、

= 𝔈(let y = x and x = y + 2 in x * y, Env₁) + 𝔈(y,Env₁)

Env₂ = 𝔇(Env₁, {(y, 𝔈(x, Env₁)), (x, 𝔈(y + 2, Env₁))})とおくと、let式の書換え規則により、

= 𝔈(x * y, Env₂) + 𝔈(y, Env₁)

関数の書き換え規則により、

= 𝔈(x, Env₂) * 𝔈(y, Env₂) + 𝔈(y, Env₁)

変数の書換え規則により、

= ℜ(x, Env₂) * ℜ(y, Env₂) + ℜ(y, Env₁)

となる。

 

環境の導出

Env₀

　Env₀は空とする。

Env₀ = []

 

Env₁
Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀)), (y, 𝔈(3, Env₀))})

であり、𝔈(2, Env₀) = 2と𝔈(3, Env₀) = 3より、

= {(x, 2), (y, 3)} ⇢ []
= [(x,2)] ⊕ [(y, 3)]

となる。

 

Env₂
Env₂ = 𝔇(Env₁, {(y, 𝔈(x, Env₁)), (x, 𝔈(y + 2, Env₁))})

であり、𝔈(x, Env₁) = ℜ(x, Env₁) = 2と𝔈(y + 2, Env₁) = ℜ(y, Env₁) + 2 = 5 より

= {(y, 2), (x, 5)} ⇢ [(x,2)] ⊕ [(y, 3)]
= [(x,5), (x,2)] ⊕ [(y, 2), (y, 3)]

となる。

 

評価結果の予想

　したがって、

ℜ(y, Env₁) = 3
ℜ(x, Env₂) = 5
ℜ(y, Env₂) = 2

である。

　よって、

𝔈(let x = 2 and y = 3 in (let y = x and x = y + 2 in x * y) + y, Env₀)
⋮
= ℜ(x, Env₂) * ℜ(y, Env₂) + ℜ(y, Env₁)
= 5 * 2 + 3
= 13

となる。

 

変数の参照と宣言との対応

let x = 2 and y = 3 in (let y = x and x = y + 2 in x * y) + y

における変数参照は、y = x and x = y + 2のxおよびyと、x * yのxおよびyと、yである。

 

y = x and x = y + 2
𝔈(let y = x and x = y + 2 in x * y, Env₁)

より、xおよびyの変数参照が対象とする束縛は環境Env₁に属し、その環境Env₁は、

Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀)), (y, 𝔈(3, Env₀))})

である。

　したがって、xについての束縛は宣言x = 2によるものであり、y + 2についての束縛は宣言y = 3によるものである。

 

x * y
𝔈(x * y, Env₂)

より、xおよびyの変数参照が対象とする束縛は環境Env₂に属し、その環境Env₂は、

Env₂ = 𝔇(Env₁, {(y, 𝔈(x, Env₁)), (x, 𝔈(y + 2, Env₁))})

である。

　したがって、xについての束縛は宣言x = y + 2によるものであり、yについての束縛は宣言y = xによるものである。

 

y
𝔈(y, Env₁)

より、yの変数参照に対応する宣言は、上述したy + 2での宣言と同じものである。

　したがって、yについての束縛は宣言y = 3によるものである。

 

 

まとめ

答え:　予想される評価結果は13である。
y = xにおけるxの参照は、宣言x = 2を指す。
x = y + 2におけるyの参照は、宣言y = 3を指す。
x * yにおけるxの参照は、宣言x = yを指す。
x * yにおけるyの参照は、宣言y = xを指す。
let ... yにおけるyの参照は、宣言y = 3を指す。
let x = 2 and y = 3 in (let y = x and x = y + 2 in x * y) + y

 

 

 

③

式の書換え

　初期の環境をEnv₀とする。③の式についての評価関数𝔈は、

𝔈(let x = 2 in let y = 3 in let y = x in let z = y + 2 in x * y * z, Env₀)

である。Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀))})とおくと、let式の書換え規則により、

= 𝔈(let y = 3 in let y = x in let z = y + 2 in x * y * z, Env₁)

Env₂ = 𝔇(Env₁, {(y, 𝔈(3, Env₁))}) とおくと、let式の書換え規則により、

= 𝔈(let y = x in let z = y + 2 in x * y * z, Env₂)

Env₃ = 𝔇(Env₂, {(y, 𝔈(x, Env₂))}) とおくと、let式の書換え規則により、

= 𝔈(let z = y + 2 in x * y * z, Env₃)

Env₄ = 𝔇(Env₃, {(z, 𝔈(y + 2, Env₃))}) とおくと、let式の書換え規則により、

= 𝔈(x * y * z, Env₄)

関数の書換え規則により、

= 𝔈(x, Env₄) * 𝔈(y, Env₄) * 𝔈(z, Env₄)

変数の書換え規則により、

= ℜ(x, Env₄) * ℜ(y, Env₄) * ℜ(z, Env₄)

となる。

 

環境の導出

Env₀

　Env₀は空とする。

Env₀ = []

 

Env₁
Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀))})

であり、𝔈(2, Env₀) = 2より、

= {(x, 2)} ⇢ []
= [(x, 2)]

となる。

 

Env₂
Env₂ = 𝔇(Env₁, {(y, 𝔈(3, Env₁))})

であり、𝔈(3, Env₁) = 3より、

= {(y, 3)} ⇢ [(x, 2)]
= [(x, 2)] ⊕ [(y, 3)]

となる。

 

Env₃
Env₃ = 𝔇(Env₂, {(y, 𝔈(x, Env₂))})

であり、𝔈(x, Env₂) = ℜ(x, Env₂) = 2より、

= {(y, 2)} ⇢ [(x, 2)] ⊕ [(y, 3)]
= [(x, 2)] ⊕ [(y, 2), (y, 3)]

となる。

 

Env₄
Env₄ = 𝔇(Env₃, {(z, 𝔈(y + 2, Env₃))})

であり、𝔈(y + 2, Env₃) = ℜ(y, Env₃) + 2 = 2 + 2 = 4より、

= {(z, 4)} ⇢ [(x, 2)] ⊕ [(y, 2), (y, 3)]
= [(x, 2)] ⊕ [(y, 2), (y, 3)] ⊕ [(z, 4)]

となる。

 

評価結果の予想

　したがって、

ℜ(x, Env₄) = 2
ℜ(y, Env₄) = 2
ℜ(z, Env₄) = 4

である。

　よって、

𝔈(let x = 2 in let y = 3 in let y = x in let z = y + 2 in x * y * z, Env₀)
⋮
= ℜ(x, Env₄) * ℜ(y, Env₄) * ℜ(z, Env₄)
= 2 * 2 * 4 = 16

となる。

 

変数の参照と宣言との対応

let x = 2 in let y = 3 in let y = x in let z = y + 2 in x * y * z

における変数参照は、y = xのxと、z = y + 2のyと、 x * y * zのx, y, およびzである。

 

y = x
𝔈(let y = x in let z = y + 2 in x * y * z, Env₂)

より、xの変数参照が対象とする束縛はEnv₂に属し、そのEnv₂は、

Env₂ = 𝔇(Env₁, {(y, 𝔈(3, Env₁))})

である。Env₂の宣言関数𝔇はxについての束縛を含まないので、Env₂におけるxの束縛のクラスはEnv₁のものと同一とである。そのEnv₁は、

Env₁ = 𝔇(Env₀, {(x, 𝔈(2, Env₀))})

であるので、xについての束縛は宣言x = 2によるものである。

 

z = y + 2
𝔈(let z = y + 2 in x * y * z, Env₃)

より、yの変数参照が対象とする束縛はEnv₃に属し、そのEnv₃は、

Env₃ = 𝔇(Env₂, {(y, 𝔈(x, Env₂))})

であるので、yについての束縛は宣言y = xによるものである。

 

x * y * zのx
𝔈(x * y * z, Env₄)

より、xの変数参照が対象とする束縛はEnv₄に属し、そのEnv₄は、

Env₄ = 𝔇(Env₃, {(z, 𝔈(y + 2, Env₃))})

であるが、Env₄の宣言関数𝔇はxの束縛を含まず、さらに、Env₃についても、

Env₃ = 𝔇(Env₂, {(y, 𝔈(x, Env₂))})

より、Env₃の宣言関数𝔇はxの束縛を含まない。これより、Env₄およびEnv₃におけるxの束縛のクラスはEnv₂のもの同一となる。

　したがって、x * y * zにおけるxの変数参照に対応する宣言は、上述したy = xでの宣言と同じとなる。よって、xについての束縛は宣言x = 2によるものである。

 

x * y * zのy

　Env₄の宣言関数𝔇はyの束縛を含まないので、yの束縛のクラスはEnv₃のものと同一である。

　したがって、上述したように、yについての束縛は宣言y = xによるものである。

 

x * y * zのz
Env₄ = 𝔇(Env₃, {(z, 𝔈(y + 2, Env₃))})

より、zについての束縛は宣言z = y + 2によるものである。

 

まとめ

答え:　予想される評価結果は16である。
y = xにおけるxの参照は、宣言x = 2を指す。
z = y + 2におけるyの参照は、宣言y = xを指す。
x * y * zにおけるxの参照は、宣言x = 2を指す。
x * y * zにおけるyの参照は、宣言y = xを指す。
x * y * zにおけるzの参照は、宣言z = y + 2を指す。
let x = 2 in let y = 3 in let y = x in let z = y + 2 in x * y * z

 

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743798239.html Fri, 20 May 2022 12:00:00 +0900 プログラミングinOCaml 練習問題3.4①の答案 練習問題3.4

　本問では、OCamlによる式の評価結果を予想しなければならない。その予想を合理的に行うためには、評価の手順を形式的に記述していく必要があるだろう。

　本問を解くにあたり重要となるのは、式の評価そのものではなく、式に含まれるlet式による変数の宣言や、その変数の参照である。

　そこで、let式に関連するオブジェクトとして束縛や環境などを定義し、それにより変数の宣言、参照などを擬似的な関数として表現することを考える。

 

 

束縛

　束縛は、変数varと値valとの順序対(var, val)とする。束縛の全体クラス（以下、束縛クラス𝔅という）は、変数の全体クラス𝖀と値の全体クラス𝖁との直積になる。

 

環境

　テキストでは、すべての束縛を1つにまとめて環境としていたが、この答案では、変数ごとに環境(部分環境)を定め、その部分環境を集めて全体の環境(全体環境)を定めることにする。

 
変数ごとの部分環境

　部分環境は、同じ変数の束縛を集め、その集まりを宣言の新しい順番に並べて定められる。例えば、変数xについての宣言が、順に、

let x = 1
let x = 5
let x = 2

とされた場合、変数xについての部分環境を、

[(x, 2), (x, 5), (x, 1)]

と定める。このような定義が可能である根拠について述べる。

　変数の宣言がなされると、その宣言での変数と値とで束縛が定まる。なされたすべて宣言に対し、宣言ごとに束縛が一意的に定まるので、それらの束縛からなるクラスが、束縛クラス𝔅の部分クラスとしてとれる。

　その部分クラスのさらなる部分クラスとして、宣言された変数aに対し、同じ変数aを持つ束縛のクラス(同変数クラスと呼ぶ)Aがとれる(つまり、はじめの部分クラスは宣言された全ての変数の束縛を含み、同変数クラスは変数aの束縛のみを含む)。

　また、その同変数クラスAの冪クラスの部分クラスで、同変数クラスAを線形順序づけ、かつその順序づけが、新しい宣言の束縛ほど小さくなるような順序づけである順序関係Rがとれる。

　それら同変数クラスAと順序関係Rとの順序対(A, R)により変数aの部分環境が定められる。

　さらに、部分環境の略記のために、同変数クラスAの要素を順序関係Rの昇べき順に並べた記法[]を導入する。例えば、束縛a, b, cを要素とする同変数クラスAと順序関係Rとが、

A = {a, b, c}
R = {(c, a), (c, b), (b, a)}

であるとき、[]による記法は、

[c, b, a]

となる。この記法では、[]における最も左側の要素が、最も新しい宣言による束縛であり、変数参照される束縛になる。

　また、部分環境では、変数参照による値が一意的に定まるが、これは、順序関係Rが同変数クラスAを整列順序づけることと同値である。

 

全体環境

　全体環境は、すべての変数についての部分環境の集まり、つまり順序対(A, R)の和クラスとなる。

　全体環境の略記として、部分環境の要素を合わせる記法⊕を導入する。例えば、変数xの部分環境と変数yの部分環境とを集めた全体環境は、

[(x, 1), (x, 3)...]⊕[(y, 1)]

と表される。以下、全体環境を単に環境という。

 

 

　以上のオブジェクトを用いて、変数の参照、宣言と式の評価とを擬似的な関数として定義する。擬似的というのはOCamlの関数ではないという意味である。

 

部分環境の取出し関数

　環境Envから変数varの部分環境(A, R)を取り出す関数ℭを、

ℭ = {((Env, var), (A, R)) |
   A ⊂ {var} × 𝖁
   ∧ ((A ≠ ∅ ∧ R ⊂ 𝒫(A) ∧ (A, R) ⊂ Env)
      ∨ (A = ∅ ∧ (A, R) = (∅, ∅))}

と定義する。関数ℭは、引数として環境Envと変数varとを受け取り、部分環境をなす順序対(A, R)を値に返す。

(A, R) = ℭ(Env, var)

 

参照関数

　変数参照を擬似的な関数ℜとする。この参照関数ℜは、引数として環境Envと変数varとを受け取り、そのvarに束縛された値valを返す。

val = ℜ (Env, var)

より詳細には、参照関数ℜは、

ℜ = {((Env, var), val) |
   (A, R) = ℭ(Env, var)
   ∧ (var, val) ∈ A
   ∧ ∀a((a ∈ A ∧ a ≠ (var, val)) → (var, val) R a)}

で定義される。

 

宣言関数

　変数の宣言を擬似的な関数𝔇とする。この宣言関数𝔇は、引数として環境Envと束縛のクラスBとを受け取り、値として新たな環境Env'を返す。

Env' = 𝔇(Env, B)

　宣言var₀ = val₀ and ... and  varₙ = valₙにより束縛のクラスB = {(var₀, val₀), ..., (varₙ, valₙ)}が定まるとき、宣言関数𝔇を、

Env' = {(var₀, val₀), ..., (varₙ, valₙ)} ⇢ Env

とも表すことにする。

　宣言関数𝔇の詳細な定義は、

𝔇 = {((Env, B), Env') |
   (var, val) ∈ B
   ∧ (A, R) = ℭ(Env, var)
   ∧ A' = {(var, val)} ∪ A
   ∧ R' =  {(x, y) | x = (var, val) ∧ y ∈ A} ∪ R
   ∧ Env' = {(A', R')} ∪ Env}

である。

 

評価関数

　式の評価を擬似的な関数𝔈とする。この評価関数𝔈は、式exprと環境Envとを引数として受け取り、値valを返す。

val = 𝔈(expr, Env)

この評価関数𝔈の性質を考える。

 

let式の書換え規則

　let式は、inの前での変数宣言による新たな環境で、inの後の式を評価する。つまり、let式を含む評価関数𝔈は、宣言関数𝔇と評価関数𝔈とにより、let式を含まない式に書換えられる。

𝔈(let var₀ = expr₀ and ... and varₙ = exprₙ in expr, Env)
= 𝔈(expr, 𝔇(Env, {(var₀, 𝔈(expr₀, Env)), ..., (varₙ, 𝔈(exprₙ, Env))})

 

関数の書換え規則

　OCamlは、静的有効範囲を採っているので関数(四則演算など)の動作は、呼び出し時の環境によらない。

　これによれば、関数の値は、実引数ごとに独立に値を求め、その値を仮引数に置き換えることでも求めることができる。

　例えば、expr = f(x, y)とすると、

𝔈(expr, Env)
= 𝔈(f(x, y), Env)
= f(𝔈(x, Env), 𝔈(y, Env))

となる。

 

変数の書換え規則

　式exprが変数varのみからなる場合、評価関数𝔈の値は参照関数ℜの値に等しい。

𝔈(var, Env) = ℜ (Env, var)

 

変数のない式

　式が変数を含まない場合、変数参照が不要なので環境に関係なく式を評価した値が決まる。だが、その式を評価して値を求める手順は、OCamlでの計算そのものになる。これを記述することは、例えば、式"1+1"を評価して値2を導く手順を記述することは、今の実力を考えると不可能である。

　なので、評価結果を合理的に予想することは諦め、常識に頼り予想する。つまり、式"1+1"について、算数では値が2になるので、OCamlでの評価結果も(理由は一切わからないが)2であると期待する。

 

定数の書換え規則

　ただし、変数を含まない式が定数である場合には、評価関数𝔈の値は、その定数となる。

𝔈(val, Env) = val

 

　以上の準備をもとに問題①を解く。

①

式の書換え

　OCamlによるlet式の処理を、評価関数𝔈における式の書換えとして模倣していく。書換えは、評価関数𝔈の式がlet式を含まなくなるまで行う。

　初期の環境をEnv₀とすると、問題の式の評価関数𝔈は、

𝔈(let x = 1 in let x = 3 in let x = x + 2 in x * x, Env₀)

となる。

 　この式を、let式の書換え規則により書換えると、

= 𝔈(let x = 3 in let x = x + 2 in x * x, 𝔇(Env₀, {(x, 𝔈(1, Env₀))}))

となる。

　ここで、Env₁ = 𝔇(Env₀, {(x, 𝔈(1, Env₀))})とおくと、

= 𝔈(let x = 3 in let x = x + 2 in x * x, Env₁)

となる。

以下同様に、let式の書換え規則により、

= 𝔈(let x = x + 2 in x * x, 𝔇(Env₁, {(x, 𝔈(3, Env₁))}))

Env₂ = 𝔇(Env₁, {(x, 𝔈(3, Env₁))})とおき、

= 𝔈(let x = x + 2 in x * x, Env₂)

let式の書換え規則により、

= 𝔈(x * x, 𝔇(Env₂, {(x, 𝔈(x + 2, Env₂))}))

Env₃ = 𝔇(Env₂, {(x, 𝔈(x + 2, Env₂))})とおき、

= 𝔈(x * x, Env₃)

関数の書換え規則により、

= 𝔈(x, Env₃) * 𝔈(x, Env₃)

変数の書換え規則により、

= ℜ(Env₃, x) * ℜ(Env₃, x)

　以上から、問題式の評価結果を予想するためには、環境Env₃においてxに束縛された値ℜ(Env₃, x)を求めればよいことがわかる。

 

環境の導出

　環境Env₀から環境Env₃まで順に導いていく。

 

Env₀

　初期環境Env₀は空とする。

Env₀ = []

 

Env₁

　上述したようにEnv₁は、

Env₁ = 𝔇(Env₀, {(x, 𝔈(1, Env₀))})

である。右辺における𝔈(1, Env₀)は、評価対象の式が定数1である。そこで、定数の書換え規則により、

𝔈(1, Env₀) = 1

となる。これによりEnv₁は、

Env₁
= 𝔇(Env₀, {(x, 1)})
= {(x, 1)} ⇢ []
= [(x, 1)]

となる。

 

Env₂

同様に、

Env₂ = 𝔇(Env₁, {(x, 𝔈(3, Env₁))})

は、

𝔈(3, Env₁) = 3

により、

Env₂ = {(x, 3)} ⇢ [(x, 1)] = [(x, 3), (x, 1)]

となる。

 

Env₃
Env₃ = 𝔇(Env₂, {(x, 𝔈(x + 2, Env₂))})

について、右辺における𝔈(x + 2, Env₂)は、関数の置換え規則により、

𝔈(x + 2, Env₂)
= 𝔈(x, Env₂) + 𝔈(2, Env₂)

となり、前者は変数の置換え規則により、後者は定数の書き換え規則により

= ℜ(Env₂, x) + 2

となる。

　ℜ(Env₂, x)は、Env₂ = [(x, 3), (x, 1)]のうち最も左側の要素(x, 3)においてxに束縛された値なので、ℜ(Env₂, x) = 3であり、

= 3 + 2
= 5

となる。これより、

Env₃ = {(x, 5)} ⇢ [(x,3), (x, 1)] = [(x, 5), (x, 3), (x, 1)]

となる。

したがって、

ℜ(Env₃, x) = 5

である。

 

評価結果の予想

よって、

𝔈(let x = 1 in let x = 3 in let x = x + 2 in x * x, Env₀)
⋮
= ℜ(Env₃, x) * ℜ(Env₃, x)
= 5 * 5

となり、5 * 5について、常識により、

= 25

となる。

 

変数の参照と宣言との対応

　問題の式において、変数参照がなされている部分式は、x + 2とx * xとの2つである。

let x = 1 in let x = 3 in let x = x + 2 in x * x

 

x + 2

　x + 2について、その評価関数𝔈(x + 2, Env₂)によれば、xはEnv₂における束縛を参照している。そのEnv₂で変数参照の対象となる束縛は、

Env₂ = 𝔇(Env₁, {(x, 𝔈(3, Env₁))})

より、x = 3の宣言によりなされたものである。

 

x * x

　x * xについて、評価関数𝔈(x * x, Env₃)によれば、xはEnv₃における束縛を参照し、その参照の対象となる束縛は、

Env₃ = 𝔇(Env₂, {(x, 𝔈(x + 2, Env₂))})

より、x = x + 2の宣言によりなされたものである。

 

まとめ

答え: 予想される評価結果は、25である。
x + 2におけるxの参照は、宣言x = 3を指す。
x * xにおけるxの参照は、宣言x = x + 2を指す。

 

　OCamlによる式の評価を形式的に表したかったのだが上手くいかなかった。OCamlがどのような原理で計算をしているのか根本的なところが抜けているので解答になっていない。

　また、環境による変数の宣言・参照についても、機械的に処理できるように表現したつもりだったが、独りよがりでややこしくなっただけだ。がんばるバカほど始末に負えないものはない、という典型のようだ。

 

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743795840.html Fri, 20 May 2022 12:00:00 +0900 プログラミングinOCaml 練習問題3.3の答案 練習問題3.3

　この問題も練習問題3.2と同様に真理値表を作って解く、と言いたいがHTMLで表を打ち込むのは大変に手間がかかる。

　そこで、オッカムの論理学大全に載っている方法を使う。構文論的な解法になるが、健全性が成り立つので問題ないだろう。

 

連言

連言について、

P ∧ Q
 ⇔ ¬ (¬ P) ∧ ¬ (¬ Q)
 ⇔ ¬ ((¬ P) ∨ (¬ Q))

が成り立つ。

　したがって、b1 && b2を書き直すと、

答え:　not ((not b1)  || (not b2))

となる。

 

選言

選言について、

P ∨ Q
⇔ ¬ (¬ P) ∨ ¬ (¬ Q)
⇔ ¬ ((¬ P) ∧ (¬ Q))

が成り立つ。

　したがって、b1 || b2を書き直すと、

答え:　not ((not b1) && (not b2))

となる。

 

　ド・モルガンではなくオッカムを出すところと、論理学大全といいながら論理記号をラテン語で書けない中途半端なところとが、意識高い系らしく書けたと思う。

 

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743795357.html Fri, 20 May 2022 12:00:00 +0900 プログラミングinOCaml 練習問題3.2の後半の答案と感想 練習問題3.2

||の書き直し

　||の書き直しは、&&の書き直しと同じ手順で行う。

 

メタ変数のif式

　はじめに、if式の条件部分、then節およびelse節の式を変数A, BおよびCに置き換えて式をたてる。

if A then B else C

 

書き直しの条件

　次に、A, B, Cを決定する際に考慮すべき点をリストにする。

  • if式を評価した値は、b1 || b2を評価した値と同じである。
  • A, B, Cには{true, false, b1, b2}の要素が入る。
  • b1 || b2は、b1が先に評価され、その値がtrueの場合、b2の評価は行われず、式全体の値はtrueとなる。
  • b1, b2は、値を持たない場合がある。

 

(true|false)が条件の式

　次に、Aに入る式がtrueまたはfalseではないことを確認する。Aにtrueを代入したif式は、

if true then B else C

となり、これの真理値表は、

truefalseb1b2b1 || b2if true then B else C
T*F*T*T*T*[B]
T*F*T*F*T*[B]
T*F*T*UT*[B]
T*F*F*T*T*[B]
T*F*F*F*F*[B]
T*F*F*UU[B]
T*F*UT*U[B]
T*F*UF*U[B]
T*F*UUU[B]

となる。この表から、true, false, b1およびb2のいずれも、b1 || b2と値が異なる割り当てが存在することが分かる。

　したがって、Aにtrueが入ることはない。また同様の理由からAにfalseが入ることもない。

なお、表における記号の意味は以下の通りである。

  • U: 式が値を持たない状態を示す。
  • T*: 式が値を持ち、その値が真である状態を示す。
  • F*: 式が値を持ち、その値が偽である状態を示す。
  • [B]: Bを評価した値。
  • [C]: Cを評価した値。

 

b1が条件の式

　次に、Aにb1を代入したif式においてBおよびCに入る式を求める。対象となるif式は、

if b1 then B else C

である。これに対する真理値表は、

truefalseb1b2b1 || b2if b1 then B else C
T*F*T*T*T*[B]
T*F*T*F*T*[B]
T*F*T*UT*[B]
T*F*F*T*T*[C]
T*F*F*F*F*[C]
T*F*F*UU[C]
T*F*UT*UU
T*F*UF*UU
T*F*UUUU

となる。表から分かるように、Bがtrueまたはb1のとき、[B]がb1 || b2の値と等しくなり、Cがb2のとき、[C]がb1 || b2の値と等しくなる。また、b1 || b2が値を持たないとき、そのときに限り、if式は値を持たない。

　したがって、b1をAに入れた場合、b1 || b2を書き直したif式は、

if b1 then (true | b1) else b2

となる。

 

b2が条件の式

　次に、Aにb2を代入した式

if b2 then B else C

について、BおよびCに入る式を求める。その真理値表は、

truefalseb1b2b1 || b2if b2 then B else C
T*F*T*T*T*[B]
T*F*F*T*T*[B]
T*F*UT*U[B]
T*F*T*F*T*[C]
T*F*F*F*F*[C]
T*F*UF*U[C]
T*F*T*UT*U
T*F*F*UUU
T*F*UUUU

となる。表から分かるように、Bには{true, false, b1, b2}のいずれの要素も入らない。

　より詳細には、真理値表の1-3行におけるb1 || b2の値に対し、trueおよびb2は3行での値が一致せず、falseは1-3行での値が一致せず、b1は2行での値が一致していない。

　さらに、BおよびCにいずれの式を代入するかに拘らず、if式の値がb1 || b2の値と一致しない割り当てが存在する。すなわち、7行では、b2の値がUであるためにif式の値もUになってしまう。そのため、if式の値がb1 || b2の値T*に一致することはありえない。

　したがって、Aにb2が入ることはない。

 

まとめ

以上から、Aにはb1のみが入ることになる。よって、

答え:
 if b1 then true else b2
または、
 if b1 then b1 else b2

である。

 

ifの使用回数

　上述の答えは、ifの使用回数を1度に制限したものであった。制限しない場合の答えとしては、以下のものが考えられる。

　答えの式についての生成規則を、

expr ::= if b1 then true else b2
 | if b1 then b1 else b2
 | if expr then (true|expr) else (false|expr)
 | if true then expr else (true|false|expr)
 | if false then (true|false|expr) else expr

とすれば、生成されるif式は、また答えとなる。

 

蛇足

　真理値表の扱いにも慣れたので、他の論理演算子について定義してみる。対象は、排他的選言と、シェファストロークとする。

　真理値表は、

truefalseb1b2b1 ⊻ b2b1 | b2
TFTTFF
TFTFTT
TFFTTT
TFFFFT

となる。

　この表で、問題となるのは1,2行であろう。1, 2行におけるb1 ⊻ b2およびb1 | b2の値は、true, false, b1, b2のいずれの値とも一致していない。

　ここで、b1 ⊻ b2およびb1 | b2の値が、b2の値の否定となっていることに注目する。そのb2の否定は、もう1つif式を使えば容易に定義できる。

　したがって、if式は、

b1 ⊻ b2 ⇔ if b1 then (if b2 then false else true) else b2
b1 | b2 ⇔ if b1 then (if b2 then false else true) else true
not b2 ⇔ if b2 then false else true

となる。

　排他的選言もシェファストロークも1つのif式では表すことができない。1つのif式と{true, false, b1, b2}のみによる書き直しは表現的適格性を欠いているのだろう。

 

練習問題3.2の感想

　本問は、問題が前提としている式の範囲でずいぶんと悩んだ。より詳しくは、範囲のなかに例外が発生する式を含めるべきか否かについてだ。含めることにすると、論理演算子や書き直したif式が可換でなくなり、どうにも気持ちがわるい。

　例外という言葉の響きからは、例外が発生するような式は、OCamlにおける正当な式ではない、という印象を受ける。

　そこで、当初の答案では、式の範囲を限定して、

なお、論理演算子の引数は、評価の際にエラーが発生しない式とする。

や、"同じ意味"の判断をメタではなくOCamlで行うことにして、

ただし、同じ意味の書き直しとは、
(b1 && b2) = (if ... then ... else ...)
を評価した値が任意のb1, b2についてtrueになることをいう。

などの、なお書き、ただし書きを付けることにしていた。

　だが、常識的に考えて、なお書きやただし書きを付けたものは、もはや答案でもなんでもない。問題が上手く解けないからといって、問題を変更しているようなものだ。

　なので、結局は例外発生の式も含めて式の範囲を広く取るようにした。

　感想というよりも言い訳になってしまった。やはり、いまでも、どこか納得がいってない部分があるのだろう。

 

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743655448.html Thu, 19 May 2022 20:20:16 +0900 プログラミングinOCaml 練習問題3.2の前半の答案 練習問題3.2

式の意味？

　またもや題意がつかめない。本問は、論理演算子の式を"同じ意味"になるように書き直せ、というものだ。だが、式の意味とは何だろう。これまでのところ、式の"評価"や"値"については説明があったが、"意味"についてはなかったように思う。

　もしかすると、"意味"は、式に掛かるのではないのかもしれない。例えば、掛け算の式を足し算の式に書き換える場合、"同じ意味"になるようにとは言わないだろう。とすれば、"同じ意味"は論理演算子に掛かっていることになる。

 

論理演算子の意味

　そこで、論理演算子について本文を読み直してみたところ、&&は"かつの意味"であるとの記述があった。なんのことはない、"意味"はコンピュータ用語ではなく日常語だったのだ。

　ならば、論理演算子の式の意味とは、引数にbool型の式を割り当てて評価したときの値のことになる。例えば、A && Bという式の場合、割り当てをA=true, B=falseとすると、式の意味はfalseになるということだろう。

 

題意

 　以上から、本問の題意は、真理値を返すif式であって、任意の割り当て対して論理演算子の式の値と同じ値を返すif式を作れ、というものになる。

 

&&の書き直し

　if式の条件, then節およびelse節を変数A, B, Cにして式をたてると、

if A then B else C

となる。さて、このif式のA, B, Cに何を入れればよいだろうか。その際、考慮すべき点は、

  • if式を評価して得られる値は、b1 && b2を評価して得られる値と同じでなければならない。
  • A, B, Cには、{b1, b2, true, false}のうちのいずれかが入る。

である。

 

場合分けしないif式

　直感的に考えて条件のAにtrueやfalseが入ることはない。まずは、これを確かめる。Aにtrueを代入するとif式は、

if true then B else C ⇔ B

となる。このif式の値は、割り当てによらず、Bの値(これを[B]と表す)と同じになる。真理値表で表すと、

true  false  b1  b2  b1&&b2  if true then B else C
TFTTT[B]
TFTFF[B]
TFFTF[B]
TFFFF[B]

となる。

　この場合、Bに{b1, b2, true, false}のうちのいずれかを入れたとしても、[B]がb1 && b2の値と等しくならない割り当てが存在する。

　真理値表でいえば、b1, b2, true, falseのどの列においても、少なくとも一つの行でb1 && b2と真理値が一致しない。

　したがって、Aにtrueが入ることはない。

 

　同様に、falseがAに入ることもない。つまり、Aにfalseを代入したif式は、

if false then B else C ⇔ C

となり、その値が常に[C]となってしまう。

 

b1が条件のif式

　以上からAにはb1かb2が入ることになる。 ここでは、Aにb1を代入した場合を考える。その場合if式は、

if b1 then B else C

となる。このif式の値は、b1が真のときに[B]、b1が偽のときに[C]である。真理値表は、

true  false  b1  b2  b1&&b2  if b1 then B else C
TFTTT[B]
TFTFF[B]
TFFTF[C]
TFFFF[C]

となる。

 

Bの式

　次に、Bに入る式を考える。Bに注目して真理値表を見ると、1, 2行でif式の値が[B]となっている。つまり、Bに入る式の値が、1, 2行におけるif式の値となる。そのif式の値は、b1 && b2の真理値と一致しなければならない。

　したがって、Bに代入する式は、1, 2行での値がb1 && b2の真理値と同じであるものを選べばよいことになる。

　各行ごとに条件に合う式を選んでいく。

　1行目のb1 && b2の真理値はTである。{b1, b2,true,false}のなかで1行目がTになるのはtrueとb1とb2である。

　2行目のb1 && b2の真理値はFである。{b1, b2,true,false}のなかで2行目がFになるのはfalseとb2である。

　1, 2行の両方が一致するのはb2のみである。したがって、Bにはb2が入ることになる。

これによりif式は、

if b1 then b2 else C

となる。その真理値表は、

true  false  b1  b2  b1&&b2  if b1 then b2 else C
TFTTTT
TFTFFF
TFFTF[C]
TFFFF[C]

となる。

 

Cの式

　残ったCについても、Bのときと同様にして入る式を考える。真理値表でCに注目すると、if式の値が[C]となるのは3,4行であり、その3,4行でのb1 && b2の真理値はいずれもFになっている。

　したがって、Cには3, 4行でFとなる式、b1かfalseが入る。これによりif式は、

if b1 then b2 else false

または

if b1 then b2 else b1

となり、真理値表は、

true  false  b1  b2  b1&&b2  if b1 then b2 else (false|b1)
TFTTTT
TFTFFF
TFFTFF
TFFFFF

となる。

　この真理値表では、確かにb1 && b2の列とif式の列とにおける真理値が、すべての行において一致している。

 

&&の特別ルール

　ところで、条件Aの式に戻ると、Aにb1を代入したのは任意であった。なので普通に考えれば、b1とb2とを入れ替えたif式も"同じ意味"の式になるだろう。

　しかし、OCamlの論理演算子&&には気になるルールがある。それは、b1 && b2の値は、b1の値がfalseの場合、b2の値に拘らずfalseになるというものだ。

　これによれば、

b1 && b2　⇔ if b2 then b1 else false

が成り立たない場合があるのではないだろうか。例えば、

b1: false
b2: int_of_string "0xg" = 16

とする。この場合、論理演算子&&の式は、

# false && int_of_string "0xg" = 16;;
- : bool = false

となり、その値はfalseである。これに対して、if式は、

# if int_of_string "0xg" = 16 then false else false;;
Exception: Failure "int_of_string".

となり、値がない。

　このように、b1とb2とを入れ替えたif式(b2が条件のif式)は、b2の評価において例外が発生する場合、&&の式と同じ意味にならない。

 

宇宙

　さて、上述のような例外が起きる式は、本問を解くにあたり、&&の引数として考慮に入れるべきものなのだろうか。

　ここでは、例外が実行時のエラーであることを理由に、例外が起きる式も引数にしたいと思う。

　より詳細には、本文2.1.3に説明があるように、OCaml(コンパイラ)にとって、実行前の型検査(当然、構文検査も)をパスできた式は、"よい式"なのだ。つまりコンパイラが保証を与えるのは型付けエラーが発生しないことまでで、実行時の例外が発生しないことについては保証がない。

　このような発生しないことが保証されてないエラーは、発生するものとして扱うのが妥当だろう。OCamlの世界ではコンパイラ様が絶対で、そのコンパイラ様がOKを出したのだから、それに従うべきなのだ。

　以上から、&&の引数の式には、例外が発生する式も含むとして、その書き直しを行うことにする。

 

やり直し

　書き直しは、これまでの真理値表をつかった手順をベースにし、さらに、A, B, Cに入る式を決めるにあたって、

  • 論理演算子&&の第1引数についての特別ルール。
  • 引数の式b1, b2は、値を持たない場合がある。

も考慮する。

 

状態表

　この方針をもとに真理値表を作り直す。新しい真理値表では、式の値が存在しない状態をUで表すことにする。さらに、式の値が存在し、その値がTである状態をT*で表し、式の値が存在し、その値がFである状態をF*で表す。

　わざわざ記号をT*, F*に変更するは、これまでのT, FがOCamlでの値を表していたのに対し、T*, F*はメタから見た式の状態を表すからである。

 

b1が条件のif式

　まず、b1を条件としたif式

if b1 then b2 else (false|b1)

について確認する。このif式の真理値表は、

true  false  b1  b2  b1&&b2  if b1 then b2 else (false|b1)
T*F*T*T*T*T*
T*F*T*F*F*F*
T*F*T*U U U 
T*F*F*T*F*F*
T*F*F*F*F*F*
T*F*F*U F*F*
T*F*U T*U U 
T*F*U F*U U 
T*F*U U U U 

である。このif式は、b1, b2の評価の順序がb1 && b2と同じなので、すべての割り当てにおいてb1 && b2と同じ値(状態)をとることになる。

　よって、このif式は、例外の発生を考慮したとしても、b1 && b2を同じ意味で書き直したものといえる。

 

b2が条件のif式

　次に、b2を条件としたif式

if b2 then B else C

について書き直しを試みる。真理値表は、

  true  false  b1  b2  b1&&b2  if b2 then B else C
1T*F*T*T*T*[B]
2T*F*T*F*F*[C]
3T*F*T*U U U 
4T*F*F*T*F*[B]
5T*F*F*F*F*[C]
6T*F*F*U F*U 
7T*F*U T*U [B]
8T*F*U F*U [C]
9T*F*U U U U 

である。

　Bについては、1, 4, 7行のb1 && b2の値とb1の値とが同じなので、b1を入れることができる。

　Cについては、2, 5行ではb1 && b2の値とfalseおよびb2の値とが一致するものの、8行ではb1 && b2の値Uは、falseおよびb2のいずれの値とも一致していない。したがって、Cに入る式は存在しない。

　さらに、6行については、B, Cになにを代入したとしても、if式の値Uが、b1 && b2の値F*と一致することはない。これは、b2の値がUならばif式は必ずUになるからであり、条件Aにb2を代入する限りどうしようもない。

　よって、このif式は、b1 && b2を書き直したものではない。

 

まとめ

　以上、b1 && b2を同じ意味のif式に書き直すには、条件をb1にしなければならないことが確かめられた。

答え:
　if b1 then b2 else false
または、
　if b1 then b2 else b1

 

ifの使用回数

　なお、ifの使用回数を1度に限定しない場合の答えとして、例えば、以下のものがある。

　式fₘを、

f₁: 上述の答えの式のいずれか。
fₙ₊₁: if true then fₙ else false
(fₙは答えのif式であってifの使用回数がn度のもの。)

と定義する。

　このとき、fₘ(m ∈ ω∖{0})は、答えである。

 

 

 

上記は、プログラミングinOCaml,五十嵐淳についての感想および練習問題の答案である。著作権を侵害してしまうことがないように問題文は載せていない。ただし、問題文中において、ごく短い文であって、ありふれた表現であり、それのみでは問題としての意味をなさないようなもの(例えば、"- - 1"など)は、著作物にあたらないと判断し、記述している。

]]> https://ameblo.jp/i8am00/entry-12743655187.html Thu, 19 May 2022 20:18:48 +0900 プログラミングinOCaml 練習問題3.1の感想 正解を確かめたい

　練習問題3.1を解いた後で、正解もOCamlで確かめようとしたところ困ったことになった。つまり、

  • 何をもって正解とするのか？
  • その判断をOCamlだけで行えるのか？

が分からないのである。この疑問を解決するには、どう考えればよいのだろう。

 

　1つには、外延を用いることが考えられる。この場合は、"正しい"外延と同じ外延を持つものが正解となる。それでは、OCamlの関数の外延はどのように求めればよいのだろうか。

 

　これを求めることは、現実的には相当に困難だと思われる。なぜなら、関数から外延を求める手続きがあったとすると、この手続きはまた関数となり、これが循環を引き起こすように思えるからだ。

 

　例えば、外延を求める汎用的な関数があったとする。その場合、汎用関数の外延には、すべての関数(についての順序対)が含まれるので、汎用関数自体も含まれることになり循環してしまう。

 

　また、汎用的な関数ではなく、関数ごとに外延関数があったとする。その外延関数が求めた外延は、はたして正しいだろうか。それを確かめるには、その外延関数の外延を求める別の外延関数が必要になる。そして、その別の外延関数が正しいかどうかは、さらに別の外延関数が必要になり、循環してしまう。

 

諦める

　興味はつきないものの、これは俺の能力を完全に越えた話題だろう。考察らしきことをしたいならば、プログラムの意図する動作(つまり"正解")や同一性などの概念を、単純化、抽象化して問題を絞り込む必要がありそうだ。そうでなければ、延々と"～とは何か"が続く似非哲学に陥ってしまう。もっとも、意識高い系としては、そちらが本線ではあるが。

　畢竟(使ってみたかった)、プログラミングには、これぞ正答と呼べるものはないのではなかろうか。

]]> https://ameblo.jp/i8am00/entry-12743654552.html Thu, 19 May 2022 20:15:11 +0900 プログラミングinOCaml　3.3の感想と練習問題3.1の答案 本文の感想

この節は、内容に比して説明が多いせいかスムーズに理解できた。他の説明もこのぐらいだとありがたいのだが、それだと厚さが倍以上になってしまうだろう。想定される読者(大学生)より劣るのだから難しく感じるのはしかたがない、とは僻みがすぎるだろうか。

環境

環境のしくみは、紙に書いて計算する場合に似ているので理解しやすい。環境を長いスクロールのように、上から下に向かって書き込むものと考えるとしっくりくる。本文中でも、スタックは上に積まれず下に延びる。

有効範囲

有効範囲は、静的有効範囲のほうがOCamlにとって自然なのではないか。OCamlの変数は名前が付けられた値に過ぎない。なので関数定義に含まれる変数(仮引数ではない)をそのまま値に置き換えても、定義の内容が変わらないことが期待される。この期待に静的有効範囲はマッチしていると思う。

それに対して、動的有効範囲は、OCamlの変数の扱い方と相容れない気がする。動的有効範囲は、例えば、具体的な値が束縛されてない変数、いわゆる自由変数を使って関数を定義できるような言語にこそあうのではないか。

練習問題3.1

①

手を使った場合にどのような解き方になるのか考える。ナイーブに考えると、その解き方は、「ドルにレートを掛けて、その積を四捨五入して円を求める」になるだろう。

ここで、四捨五入には、積と0.5との和を小数点以下で切り捨てるという手順が考えられる。また、レートは、問題文で指定された114.32に固定されているとする。

これでドルが円に換算される。ただし、OCamlには型があることを考慮しなければならない。つまり、換算した円は、そのままではfloat型データになるので、int型データへの変換が必要となる。以上を整理すると、

  • レートを表す変数rateを114.32として定義する。
  • 四捨五入の関数roundを定義する。その本体は、引数と0.5との和を小数点以下で切り捨てるものなる。なお、切り捨てには関数floorを使う。
  • ドルとrateの積にroundを適用して円に換算し、その結果をint_of_floatで変換する。

になる。これをOCamlで表すと、

let dollar_to_yen x = let rate = 114.32 in let round y = floor (y +. 0.5) in int_of_float (round (x *. rate))

この答えは、レートごとに関数を定義しなければならないのでいまひとつである。こういうときに、動的有効範囲が役に立つのだろう。動的有効範囲ならば、rateを大域環境で定義するだけで、レート変動に応じて円換算できる。

②

考え方は、①と同じである。

let yen_to_dollar x = let dollars_to_cents_rate = 100.0 in let dollars_to_cents y = y *. dollars_to_cents_rate in let cents_to_dollars y = y /. dollars_to_cents_rate in let round y = cents_to_dollars (floor ((dollars_to_cents y) +. 0.5)) in let usd_to_jpy_rate = 114.32 in round ((float_of_int x) /. usd_to_jpy_rate)

1ドルが何セントなのか分からなかった。大学生には常識なのだろうか。とりあえず、何セントでもいいように解いた。

調べると、"セント"はそのまま100の意味だった。Decemberが12月になるような言語なのに意外にまともだった。

③

①のdollar_to_yenが大域環境に定義されていることを前提として解くことにする。

その場合、ドルと、そのドルをdollar_to_yenで換算した円とを文字列に変換し、それら文字列と、問題文で指定された横文字とを連結すればよい。

let dollar_to_yen x = (string_of_float x) ^ " dollars are " ^ (string_of_int (dollar_to_yen x)) ^ " yen."

大域環境にある①のdollar_to_yenを使って③のdollar_to_yenを再定義した。再定義は、環境についての理解を確かめる意味もあって、あえて行った。決して、関数名を考えるのが面倒くさかったからではない。

④

char型データのクラスは、lexical orderで順序づけられており、[0, 255]への同型写像int_of_charが存在する。これより、'a'からn番目の小文字cについて、

int_of_char c = int_of_char 'a' + n

となる。同様に'A'からn番目の大文字Cについて、

int_of_char C = int_of_char 'A' + n

となる。これらの式より

int_of_char C = int_of_char 'A' + int_of_char c - int_of_char 'a'

が成り立つ。ここで、int_of_charは同型写像なので逆写像が存在する。その逆写像はchar_of_intである。そのchar_of_intにより、上式の等号の両辺をchar型に変換すると、

C = char_of_int (int_of_char 'A' + int_of_char c - int_of_char 'a')

となる。したがって、小文字cを大文字Cに変換する関数uppercaseは、

let uppercase c = char_of_int (int_of_char 'A' + int_of_char c - int_of_char 'a')

となる。このuppercaseを用いてcapitalizeを定義する。具体的には、文字cが小文字以外のときと、小文字のときとで場合分けし、小文字以外のときはそのままcを、小文字のときはuppercase cの値を返す。

let capitalize c = let uppercase d = char_of_int (int_of_char 'A' + int_of_char d - int_of_char 'a') in if c < 'a' || 'z' < c then c else uppercase c
]]> https://ameblo.jp/i8am00/entry-12569950354.html Mon, 03 Feb 2020 00:00:00 +0900 プログラミングinOCaml　3.2の感想 本文の感想

if式への違和感

やはり、3.1で疑問がなかったのは理解が浅かったからだ。さっそくif式でつまづいた。条件が偽のときにも式が必要なところが分からない。

 

場合分けとして考えれば、真と偽との両方に式が必要になるのは当然なのだが。

 

しかし、函数を定義するだけならば、then節だけでも十分に思われる。else節がなければ定義域が制限される、というのではだめなのだろうか。例えば、if式を、条件が0以上の整数、かつthen節のみを持つとした場合には、その定義域が自然数に制限された函数が定義される、とはできないのだろうか。

 

これができないのは、おそらく、型の部分（上記の例では自然数）からなる型(部分型とでもいうべきものか)を定義できないからだろう。

 

この部分型が定義できないというのは、OCamlが静的型付き言語であることが理由だろう。静的型付き言語はその名前の通り静的に（つまりプログラムの実行前に）型検査を行う。

一方、部分型を定義するには、型の部分を特定する必要があり、その特定には一般に式の評価が必要となる。上述の例でいえば、自然数を特定するには、0以上の整数ならば真、という式の評価が必要となる。

ところが、この式の評価というのはプログラムの実行である。つまり、静的型付け言語では、プログラムの実行前に行うべき部分型の型検査において、プログラムの実行が必要になってしまう。したがって、静的型付け言語では、部分型の定義（正確にはプログラムの実行を必要とする定義）ができない。

型を部分に分けられないなら、全体で函数を定義せざるをえない。よって、OCamlのif式では、else節を省略することができないことになる。

 

つまづいた原因は、if式への理解不足というよりも、型についての勘違いだった。静的型というのは、その実現に困難さがあるものの、安全性の高い記述を可能とするものであり、関数の引数などにまつわる問題をほぼ排除できると、なんとなく思い込んでいた。だが、それほどではないのかもしれない。

関数とは何か？

結局のところ、OCamlの関数は数学の函数とは違うものであり、同じものだとの思い込みが理解を妨げているようだ。型は集合ではないし、関数fの型int->intは、dom(f)=int、rang(f)⊆intを表しているのではない。ZFの函数などとは切り離してOCamlの関数を理解する必要がある。

 

ならばOCamlにおける関数をどのようにとらえればよいだろうか。現段階の理解では、

引数から値を求めるための手続きであって、引数と値の型を属性として持つもの
となるだろうか。曖昧だがしかたがない。まだまだ3章の序盤だ、要約どおりじっくり進めるしかない。

真理値

さて、真偽値である。truth valueの訳なら真理値であるが、真理の値ではまるで宗教である。これを対し、真偽値なら真か偽かの値というのが字面をみるだけでわかるので優れた用語といえる。

 

しかし、ジャーゴンを使い人を煙に巻いてこその意識高い系なので、あえて真理値を使いたい。もっとも、boolean valueなので真理値とは違うかもしれない。

正しい論理記号

その他は、真理関数の連言が&&なのはともかく、選言が||なのは憶えにくい。あえてストロークを使う意味がわからない。とはいえ、歴史的に見ても論理記号の書き方は定まったものがないので慣れるしかない。

感想の感想

明らかに、うんちくを披露したいだけの後半が蛇足だ。しかし、このような関連性の低い話題に話を持ってくのが意識高い系であり、その自然さと強引さが腕の見せ所である。

解答

設問なし。

]]> https://ameblo.jp/i8am00/entry-12567992748.html Sat, 25 Jan 2020 17:54:10 +0900 プログラミングinOCaml　3.1の感想 本文の感想

アブストラクトの最後の行を読んでビビっていたが、この節はなんとかついていけそうだ。もっとも、分かってないからこそ疑問が生じていない可能性もあるが。

 

ところで函数といえば、中学のとき、f(x) = x + 1と、そのxをzで置き換えたf(z) = z + 1とがなぜ等しいのか理解できなかった。

 

今の知識で説明すると、ZFでの函数の存在を示す置換公理図式においては上式のxやzはダミー変数になるので、これらを置き換えても式の意味は同じである。したがって、函数の外延は同じものであり、同じ外延を持つものは同じオブジェクトである、ということになるだろう。

 

この説明を中学生のときの自分にしても通用しない。なぜなら、中学で習った函数とはxからf(x)の値を計算するための方法のことだった。そのため、f(x)とf(z)とが等しいというためには、すべての実数x, zについてx=zならばf(x)=f(z)が成り立つことを示さなければならない。

これには、実数がどのようなオブジェクトであるのかと、その実数が群の公理のモデルであることを示す必要があるのだが、ZFで実数を定義する時点で函数の定義も変わってしまう。

何が言いたいのかというと、中学での定義のように、xにy(=f(x))を対応させる方法が関数である、とした場合、f(x)とf(z)とが等しいことは示せないのではないだろうか。

 

本文3.1の定義を読むと、OCamlにおける関数は、ZFのそれよりは、中学のときの計算手順に近い感じがする。

そうすると、OCamlでは、f(x)とf(z)とは等しいと判断できないのだろうか。上の式のように、オブジェクトが有限のときに限れば原理的には可能であるが。

解答

設問なし。

]]> https://ameblo.jp/i8am00/entry-12525826792.html Fri, 20 Sep 2019 00:00:00 +0900