<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Les | How's it work</title><link>https://hsiw.io/blog/ja/tags/les/</link><description>ものごとがどう動いているのかに興味があります。</description><generator>Hugo</generator><language>ja</language><lastBuildDate>Sat, 21 Nov 2026 00:00:00 +0900</lastBuildDate><atom:link href="https://hsiw.io/blog/ja/tags/les/index.xml" rel="self" type="application/rss+xml"/><item><title>Les の遅延評価を Lean で形式化してみる — 観測から実行可能モデル、そして証明へ</title><link>https://hsiw.io/blog/ja/posts/les-formalization/</link><pubDate>Sat, 21 Nov 2026 00:00:00 +0900</pubDate><guid>https://hsiw.io/blog/ja/posts/les-formalization/</guid><description>Go 製の遅延評価言語 Les を観測し、Lean の実行可能評価器を作り、35件の差分テストと Heap・メモ化・環境捕捉の証明まで進めた実験の中間報告。</description><content:encoded><![CDATA[<p>小さなプログラミング言語の実装を観察し、その振る舞いを Lean でモデル化して、性質を証明する実験を始めました。</p>
<p>対象は、usa さん（GitHub 等では unak さん）が Go で実装しているスクリプト言語 <a href="https://github.com/unak/les">Les</a> です。</p>
<p>この実験を進めているリポジトリは <a href="https://github.com/gotoken/les-spec">gotoken/les-spec</a> です。</p>
<p>ここでやろうとしているのは、Go で書かれた評価器を別の言語に移植することではありません。Les のプログラムを実際に動かして振る舞いを観測し、必要に応じて Go のコードも調べながら、その振る舞いを説明できる概念的なモデル（どんな情報を保持し、どんな規則で計算を進めるのか）を推定します。それを <a href="https://lean-lang.org/">Lean</a> という、プログラムを書くことも数学的な証明を検査することもできる言語で記述します。</p>
<p>目指すのは、個々のプログラムが期待どおりに動くことを確かめるだけでなく、<strong>モデルが満たすべき性質を数学的な命題として記述し、その仮定を満たすすべての場合について成り立つことを証明する</strong>ことです。対象となる入力や実行途中の状態は無限にあり得るので、これはテストとは異なる仕事です。</p>
<p>通常の Les CLI は、ソースコードを字句解析・構文解析して抽象構文木（AST）を作り、型推論と型検査を行った後、そのプログラムを Go の評価器で実行します。今回の形式化は、主としてこの最後の評価段階を対象にしています。</p>
<p>そこで、Lean の評価器に渡すのは Les のソースコードそのものではありません。Go 版の字句解析・構文解析・型推論を再利用する <code>lesdump</code> というツールが、プログラムの構造を表す AST と型解析結果を JSON に変換し、Lean 側で読み込んで評価します。元の Go CLI の実行結果は別に取得し、比較に使います。</p>
<p>2026年11月15日現在、Les の一部について実行可能な Lean 評価器を作り、Go 実装と35件のプログラムで観測結果が一致することを確認しました。さらに、遅延した計算が正常に終われば結果が保存され、同じ保存場所から再び値を求めても計算をやり直さないことなど、モデルの内部の性質を Lean で証明しました。その定理の仮定を満たす具体例も構成しました。</p>
<p>まだ Les 全体を形式化したわけではありません。また、Go 実装と Lean モデルが数学的に同値であると証明したわけでもありません。観測に基づいて仕様を推定すること、そのモデルを実行して元の処理系と比較すること、モデル自体の性質を証明することは、それぞれ区別して進めています。</p>
<p>この記事では、何を作ったのか、どう進めたのか、何が分かったのか、そして今後どこを目指すのかを整理します。</p>
<h2 id="1-les-はどんな言語か">1. Les はどんな言語か</h2>
<p>Les（Lazy Evaluation Script）は、Python に似たインデントベースの構文を持つ、Go で実装されたスクリプト言語です。</p>
<p>Ruby のような簡潔な記述、Go に影響を受けた型システム、型推論、構造的インターフェースなどを備えています。</p>
<p>そして、大きな特徴は<strong>変数や関数引数などが原則として要求時に評価される</strong>ことです。</p>
<p>例えば、次のプログラムを考えます。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">choose</span><span class="p">(</span><span class="n">first</span><span class="p">:</span> <span class="n">Int</span><span class="p">,</span> <span class="n">second</span><span class="p">:</span> <span class="n">Int</span><span class="p">):</span> <span class="n">Int</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">first</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">choose</span><span class="p">(</span><span class="mi">42</span><span class="p">,</span> <span class="mi">1</span> <span class="o">/</span> <span class="mi">0</span><span class="p">)</span>
</span></span></code></pre></div><p>このプログラムの出力は <code>42</code> です。</p>
<p>通常の先行評価（call-by-value）なら、関数の呼び出し前に <code>1 / 0</code> が評価され、ゼロ除算になります。しかし Les では使われない第2引数を評価しないため、エラーになりません。</p>
<p>明示的に評価を要求する <code>force</code> や後置の <code>!</code> も用意されています。</p>
<p>Les を手元にインストールしなくても、<a href="https://gotoken.github.io/les-playground/#ex=trace">Les Playground</a> でブラウザからサンプルを実行したり、自分でコードを書き換えて試したりできます。</p>
<p>遅延評価自体は、Haskell や R をはじめ、多くのプログラミング言語で研究・実装されてきました。Les が興味深いのは、遅延評価に加えて、再束縛と環境捕捉の振る舞いに特徴があることです。</p>
<h3 id="作成時に存在する変数を捕捉する">作成時に存在する変数を捕捉する</h3>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">b</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">10</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">b</span>
</span></span></code></pre></div><p>結果は <code>2</code> です。</p>
<p><code>b</code> の右辺はすぐには評価されません。しかし <code>b</code> を作成した時点で見えていた <code>a</code> の束縛を捕捉しているため、その後に <code>a</code> を再束縛しても <code>b</code> から見える参照先は変わりません。</p>
<h3 id="作成時に存在しない変数は後から見つける">作成時に存在しない変数は後から見つける</h3>
<p>一方、次のプログラムは異なる振る舞いをします。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">b</span><span class="p">:</span> <span class="n">Int</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">7</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">b</span>
</span></span></code></pre></div><p>結果は <code>8</code> です。</p>
<p><code>b</code> を作った時点では <code>a</code> が存在しないため、<code>a</code> は捕捉されません。<code>b</code> が実際に評価される時点で、生きたスコープから <code>a</code> を探し、そのときの束縛である <code>7</code> を参照します。</p>
<p>つまり、Les の遅延評価では次の二つが共存しています。</p>
<ul>
<li>Thunk 作成時に解決できた名前は、その時点の束縛を捕捉する。</li>
<li>作成時に解決できなかった名前は、後の評価時に解決する。</li>
</ul>
<p>これは単純な call-by-name や、通常の静的スコープを持つ call-by-need の説明だけでは捉えきれません。</p>
<p>さらに Les では、同じスコープに既存の名前を再束縛すると、右辺がその場で強制評価されます。初回束縛と再束縛で評価時期が異なるのです。</p>
<p>このような規則を個別に理解するだけでなく、互いに組み合わせても矛盾なく説明できるモデルを作ることが、今回の形式化の出発点でした。</p>
<h2 id="2-今回の実験で何を目指したのか">2. 今回の実験で何を目指したのか</h2>
<p>最初から Les 全体の仕様書を作ったり、Go 実装をすべて Lean に移植したりするつもりはありませんでした。</p>
<p>まず、次の三つを別々の目標として設定しました。</p>
<p><strong>第一は、観測可能な振る舞いの記録です。</strong></p>
<p>特定の Les プログラムを実行したとき、標準出力、標準エラー出力、終了コードが何になるのかを固定します。</p>
<p><strong>第二は、その振る舞いを説明する小さな実行可能モデルです。</strong></p>
<p>たとえば第1節の二つのプログラムでは、変数 <code>a</code> を後から束縛し直しているにもかかわらず、<code>b</code> が参照する値の決まり方が異なります。この違いを説明するには、変数名と値の対応だけでなく、いつ参照先を決め、何を保存するのかを考える必要があります。多数の観測例を矛盾なく説明できるように規則と状態の表現を組み立て、それを Lean で実行できるようにします。これが今回の意味論（semantics、プログラムが何を意味し、どう計算されるかを定める規則）のモデルです。Go の内部構造をそのままコピーする必要はありませんが、観測に反するモデルになっていないかは差分テストで調べます。</p>
<p><strong>第三は、モデルの性質の証明です。</strong></p>
<h3 id="一般的な性質を証明するとはどういうことか">「一般的な性質を証明する」とはどういうことか</h3>
<p>簡単な数学の例を考えてみます。自然数 <code>n</code> について、<code>n + 1 &gt; n</code> が成り立つことを確かめたいとします。<code>n = 0, 1, 2, ...</code> と値を代入していけば、いくらでも成功例を増やせます。しかし自然数は無限にあるので、有限回のテストによってすべてを調べ終えることはできません。一方、特定の値を代入せず、任意の自然数 <code>n</code> について成り立つ理由を示す数学的な証明なら、まだ試していない値も含めて扱えます。</p>
<p>今回の評価器で知りたいのも、これに似たことです。例えば、ある遅延された式を評価し、結果を保存したあとで再びその値を求めたとします。いくつかのプログラムを実行して同じ値が返ることを観察するのはテストです。しかし、式の種類、変数の束縛、保存場所、実行途中の状態などの組み合わせは膨大で、モデル上は無限にあり得ます。</p>
<p>そこで第4節で紹介する定理では、特定の式や値を選ぶ代わりに、それらを任意のものとして扱います。未評価の式が所定の場所に保存されており、その計算が正常に終了するという仮定のもとで、結果がその場所に保存されること、そしてその直後の状態から再び同じ場所の値を要求すると、同じ値が返り、実行状態も変わらないことを示します。このとき、Lean は命題だけでなく、それを導く数学的な証明も検査します。</p>
<p><strong>「一般的」とは、試したプログラムだけでなく、定理で定めた対象のうち仮定を満たすすべての場合を扱うという意味です。</strong> あらゆる Les プログラムで計算が成功することや、途中に別の操作を挟んでも常に同じ値になることまで示したわけではありません。</p>
<p>このテストと証明の違いは、P2 の終了後に知った Sam Xifaras 氏の <a href="https://samx.io/blog/topics/devlog/2026-09-26-ruby-lean.html">ruby-lean の記事の導入部</a> でも分かりやすく説明されています（第9節で両者を比較します）。</p>
<p>この三つは別々の仕事です。観測結果との一致はモデルの妥当性を支持しますが、Go 実装との同値性を証明するものではありません。モデルについての定理も、直ちに元の Go 実装についての定理になるわけではありません。</p>
<h2 id="3-p0p1観測から-lean-評価器を作る">3. P0〜P1：観測から Lean 評価器を作る</h2>
<h3 id="p0対象を固定して再現可能にする">P0：対象を固定して、再現可能にする</h3>
<p>最初に Les の対象コミットを固定しました。</p>
<p><code>aa78fdcfc76b156e6b5ab4735516fcefadce954b</code></p>
<p>このコミットから Go の CLI をビルドし、最小限のテストを実行しました。同時に Lean 4.25.0 と Lake のビルド環境を用意しました。</p>
<p>固定コミットを使うのは、実験中に upstream の実装が変化して、観測結果や証明対象がいつの間にか変わるのを避けるためです。</p>
<p>最初の5件のテストでは、<code>print</code>、<code>exit</code>、未使用引数の遅延評価、ゼロ除算などを確認しました。</p>
<p>ここで意外に重要だったのが、Go CLI と Go の評価器テストが同じ経路ではないことでした。固定コミットの CLI の <a href="https://github.com/unak/les/blob/aa78fdcfc76b156e6b5ab4735516fcefadce954b/cmd/les/main.go#L48-L98"><code>runPipeline</code></a> は、通常の実行を次の三段階に分けています。</p>
<ol>
<li><strong>字句解析・構文解析</strong>（<code>parser.ParseProgram</code>）：ソースコードを読み、AST を構築します。構文エラーがあればここで停止します。</li>
<li><strong>型推論・型検査</strong>（<code>InferProgram</code>）：プログラムの型を推論し、型の整合性を検査します。型エラーがあれば停止し、型警告は標準エラー出力に書き出します。</li>
<li><strong>評価</strong>（<code>EvalProgram</code>）：構文解析で得た AST と型推論器を使い、必要になった式を評価します。</li>
</ol>
<p>実際、CLI の <code>-c</code> オプションは第1段階まで、<code>-t</code> は第2段階までを実行するもので、いずれも評価は行いません。遅延評価という性質は第3段階の計算についてのものであり、実行前の構文解析や型検査まで遅延させるわけではありません。</p>
<p>したがって CLI の標準エラー出力には、評価器が返すエラーだけでなく、実行前の型警告なども含まれ得ます。そこで、評価器の振る舞いと型推論の警告を混同しないよう、テスト入力と期待値を整えました。</p>
<h3 id="p1go-cli-で何を観測しlesdump-で何を渡したのか">P1：Go CLI で何を観測し、<code>lesdump</code> で何を渡したのか</h3>
<p>ここは二つの仕事を区別する必要があります。</p>
<ul>
<li><strong>実行結果の観測</strong>：固定コミットからビルドした Go 製 Les CLI に <code>*.les</code> を渡し、stdout・stderr・終了コードを調べて <code>*.expect.json</code> に固定する。</li>
<li><strong>Lean に渡す入力の構築</strong>：Go 版の字句解析・構文解析・型解析を再利用した <code>lesdump</code> が、同じ <code>*.les</code> の抽象構文木（AST）と型解析結果を JSON で出力する。Lean はその JSON をデコードして、自分の評価規則で計算する。</li>
</ul>
<p>AST は、例えば <code>a + 1</code> を「加算という操作、その左側の変数名 <code>a</code>、右側の整数リテラル <code>1</code>」という木構造で表したものです。<code>a</code> が実際にいくつなのか、加算の結果がいくつなのかは AST を作る段階では決まりません。</p>
<p>つまり、<a href="https://github.com/gotoken/les-spec/blob/main/lesdump/main.go"><code>lesdump</code></a> は<strong>実行結果を採取するオラクルではなく、フロントエンド（評価に先立つ解析処理）を共有するための橋渡し</strong>です。対応する部分言語について Go CLI と同じ字句解析・構文解析・型推論の処理を再利用しますが、Go の評価器は呼び出しません。Lean 側も構文解析や型推論の正しさを独立に検証しているわけではなく、JSON を受け取って評価を行います。</p>
<p>実際のディレクトリは、例えば次の対応になっています。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/verification-pipeline-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/verification-pipeline-ja.svg" alt="同じ Les ソースを Go CLI と lesdump で処理し、Go の期待出力と Lean 評価器の出力を照合する。" loading="lazy" decoding="async"></a>
</figure>
<p>実際のコマンドは次のとおりです。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">bash scripts/bootstrap.sh
</span></span><span class="line"><span class="cl">.work/bin/lesdump difftest/corpus/snapshot-late-rebind.les &gt; /tmp/snapshot.json
</span></span><span class="line"><span class="cl">python3 difftest/run.py                <span class="c1"># 固定 Go CLI と *.expect.json の照合</span>
</span></span><span class="line"><span class="cl">python3 lesdump/test.py                <span class="c1"># AST JSON と golden の照合</span>
</span></span><span class="line"><span class="cl"><span class="nb">cd</span> lean
</span></span><span class="line"><span class="cl">lake build
</span></span><span class="line"><span class="cl">lake exe les-syntax-test ../lesdump/golden <span class="m">35</span>
</span></span><span class="line"><span class="cl">lake exe les-eval-test ../lesdump/golden ../difftest/corpus
</span></span></code></pre></div><p>Go の stdout・stderr・終了コードを採取する実装は <a href="https://github.com/gotoken/les-spec/blob/main/difftest/run.py"><code>difftest/run.py</code></a> にあります。環境固有のファイルパスを <code>&lt;CASE&gt;</code> に置き換える以外は、期待値を自動的に正解として更新しません。<code>lesdump</code> の JSON は <a href="https://github.com/gotoken/les-spec/blob/main/lesdump/test.py"><code>lesdump/test.py</code></a> によって、決定性や未対応構文を明示的に拒否することも検査します。</p>
<h3 id="先に用語を整理するthunkcellheapscopeenvmachine">先に用語を整理する：Thunk、Cell、Heap、Scope、Env、Machine</h3>
<p>ここからは Les のソースコードに現れない、<strong>評価器の内部構造を説明する用語</strong>が増えます。初めて読む人のために、由来を先に整理しておきます。</p>
<p>遅延評価の研究で使われる <strong>thunk（サンク）</strong> は、まだ計算していない式を「必要になったら計算するもの」として持っておく仕組みです。単なる式の保存ではなく、後でその式を評価するための環境も必要です。同じ計算結果を保存して二度目に再利用する方式を <strong>call-by-need</strong> と呼びます。</p>
<p><a href="https://github.com/unak/les/blob/aa78fdcfc76b156e6b5ab4735516fcefadce954b/pkg/eval/value.go">元の Go 実装の <code>Thunk</code></a> には、実際に <code>Expr</code>、<code>Env *Environment</code>、<code>Value</code>、<code>Evaluated</code>、<code>Evaluating</code> というフィールドがあります。<code>Environment</code> は <code>store map[string]Value</code> と <code>parent</code> を持ち、<a href="https://github.com/unak/les/blob/aa78fdcfc76b156e6b5ab4735516fcefadce954b/pkg/eval/capture.go"><code>captureEnv</code></a> は作成時に見えていた束縛をコピーしています。</p>
<p>一方、以下の <code>Cell</code> や <code>Machine</code> は、<strong>この実験の Lean 評価器で選んだ表現と名前</strong>です。Go の構造体を一対一で移植したわけではありません。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表（横スクロール可能）">
  <table>
    <thead>
      <tr>
        <th scope="col">用語</th>
        <th scope="col">何を指すか</th>
        <th scope="col">由来・今回の使い方</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><strong>Thunk</strong></td>
        <td>未評価の式と、後で評価するための情報</td>
        <td>遅延評価で一般的な語。Go の Les も <code>Thunk</code> と呼ぶ</td>
      </tr>
      <tr>
        <td><strong>Cell</strong></td>
        <td>評価済みの値、未評価の式、評価中の印のいずれかを入れる<strong>ひとつの保存場所</strong></td>
        <td>Lean モデルの <code>Cell</code>。Thunk だけでなく評価済みの値も入る</td>
      </tr>
      <tr>
        <td><strong>Heap</strong></td>
        <td>Cell をアドレスで管理する保存領域と、スコープの一覧</td>
        <td>Lean モデルの <code>Heap</code>。OS のヒープ領域そのものを指すのではない</td>
      </tr>
      <tr>
        <td><strong>Scope</strong></td>
        <td>現在の変数名から Cell アドレスへの対応と、親スコープ</td>
        <td>言語処理系で一般的なスコープ。Lean では <code>ScopeId</code> で参照する</td>
      </tr>
      <tr>
        <td><strong>Env</strong></td>
        <td>式を後で評価するとき、名前をどこから解決するかという<strong>参照環境</strong></td>
        <td>environment の略。Go の <code>Environment</code> に対応する問題を、Lean では <code>snap</code> と <code>scope</code> に分けて表現する</td>
      </tr>
      <tr>
        <td><strong>Machine</strong></td>
        <td>評価途中で変化する状態をまとめたもの</td>
        <td>抽象機械・評価器の状態という意味。今回は <code>Heap</code> と蓄積中の <code>stdout</code>。物理的なコンピューターではない</td>
      </tr>
    </tbody>
  </table>
</div>
<p>Go の <code>Environment</code> が値や Thunk への参照を持つのに対し、Lean では変数名を Cell の**アドレス（配列の添字）**へ対応させます。この間接参照が、再束縛で名前の行き先が変わっても、古い Thunk が元の Cell を使い続けられる仕組みです。</p>
<p>用語の意味を押さえたところで、実際のプログラムを動かし、どのアドレスが残るのかを見てみます。</p>
<h4 id="観測例1束縛を捕捉するe14">観測例1：束縛を捕捉する（E14）</h4>
<p>冒頭で示した <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/snapshot-late-rebind.les"><code>snapshot-late-rebind.les</code></a> は、次の4行です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">b</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">10</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">b</span>
</span></span></code></pre></div><p>固定 Go CLI の期待結果は、実際に <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/snapshot-late-rebind.expect.json"><code>snapshot-late-rebind.expect.json</code></a> にこう記録しています。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;stdout&#34;</span><span class="p">:</span> <span class="s2">&#34;2&#34;</span><span class="p">,</span> <span class="nt">&#34;stderr&#34;</span><span class="p">:</span> <span class="s2">&#34;&#34;</span><span class="p">,</span> <span class="nt">&#34;exit_code&#34;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="nt">&#34;rules&#34;</span><span class="p">:</span> <span class="p">[</span><span class="s2">&#34;E14&#34;</span><span class="p">]}</span>
</span></span></code></pre></div><p><code>lesdump</code> の <a href="https://github.com/gotoken/les-spec/blob/main/lesdump/golden/snapshot-late-rebind.json">golden JSON</a> では、第2文 <code>b = a + 1</code> は <code>VarDecl</code> で、右辺は <code>Binary</code> です。次はその文だけを抜き出したものです（<code>jq '.body[1]'</code> に相当）。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;kind&#34;</span><span class="p">:</span> <span class="s2">&#34;VarDecl&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;name&#34;</span><span class="p">:</span> <span class="s2">&#34;b&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;pos&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;col&#34;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="nt">&#34;line&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;type_annot&#34;</span><span class="p">:</span> <span class="s2">&#34;&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;value&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;kind&#34;</span><span class="p">:</span> <span class="s2">&#34;Binary&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;left&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;kind&#34;</span><span class="p">:</span> <span class="s2">&#34;Ident&#34;</span><span class="p">,</span> <span class="nt">&#34;name&#34;</span><span class="p">:</span> <span class="s2">&#34;a&#34;</span><span class="p">,</span> <span class="nt">&#34;pos&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;col&#34;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="nt">&#34;line&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">}},</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;op&#34;</span><span class="p">:</span> <span class="s2">&#34;+&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;pos&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;col&#34;</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="nt">&#34;line&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;right&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;kind&#34;</span><span class="p">:</span> <span class="s2">&#34;Int&#34;</span><span class="p">,</span> <span class="nt">&#34;pos&#34;</span><span class="p">:</span> <span class="p">{</span><span class="nt">&#34;col&#34;</span><span class="p">:</span> <span class="mi">9</span><span class="p">,</span> <span class="nt">&#34;line&#34;</span><span class="p">:</span> <span class="mi">2</span><span class="p">},</span> <span class="nt">&#34;value&#34;</span><span class="p">:</span> <span class="mi">1</span><span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>重要なのは、<strong>この JSON には「<code>a</code> の値は1」「<code>b</code> の値は2」という評価結果が入っていない</strong>ことです。<code>VarDecl</code>・<code>Binary</code>・<code>Ident</code> とソース位置だけを表しています。型解析の <code>analysis.status</code> はこのケースでは <code>ok</code> ですが、それも値を実行して得たものではありません。</p>
<p>出力が <code>2</code> になる理由は、<code>b</code> の Thunk を作るときに、その時点の <code>a</code> の<strong>値ではなく Cell アドレス</strong>を捕捉し、<code>a = 10</code> の再束縛後も古い Cell を参照するからです。この規則を Lean の評価器が実装し、P2c の証明がその参照関係の一部を保証します。</p>
<p>これを Lean の保存領域に置き換えて図示すると、<code>print b</code> の直前は概念的に次の状態です。<code>#0</code>・<code>#1</code> は組込み関数用の Cell なので、この例では <code>a</code> の最初の Cell は <code>#2</code> になります。矢印の数字は<strong>値ではなく、Cell 配列内のアドレス</strong>です。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/rebind-capture-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/rebind-capture-ja.svg" alt="現在の a は #4 の 10 を指すが、b の捕捉環境は古い a の #2 の 1 を指す。" loading="lazy" decoding="async"></a>
</figure>
<p>1行目の <code>a = 1</code> が <code>#2</code>、2行目の <code>b = a + 1</code> が <code>#3</code>、3行目の再束縛 <code>a = 10</code> が <code>#4</code> を作ります。<code>Heap.scopes[1]</code> にある名前 <code>a</code> の行き先は <code>#4</code> になりますが、<code>#3</code> に保存された <code>env_b.snap</code> は <code>#2</code> を指したままです。したがって <code>b</code> の評価では <code>1 + 1</code> が計算されます。</p>
<p>これは<strong>Go の内部メモリアドレスを観測した図ではなく</strong>、Go の出力を説明するために作った Lean の Heap モデルの図です。実際の Go はポインターと <code>Environment</code> を使い、Lean は整数のアドレスと配列を使っています。</p>
<h4 id="観測例2まだ束縛されていない名前を後から解決するe15">観測例2：まだ束縛されていない名前を後から解決する（E15）</h4>
<p>対照的な <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/forward-ref-rebound.les"><code>forward-ref-rebound.les</code></a> は次のとおりです。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">b</span><span class="p">:</span> <span class="n">Int</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="mi">7</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">b</span>
</span></span></code></pre></div><p>期待結果は <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/forward-ref-rebound.expect.json"><code>forward-ref-rebound.expect.json</code></a> の <code>{&quot;stdout&quot;: &quot;8&quot;, &quot;stderr&quot;: &quot;&quot;, &quot;exit_code&quot;: 0}</code> です。</p>
<p>AST の形は先ほどとほぼ同じで、<code>b</code> の右辺はやはり <code>Binary(Ident(&quot;a&quot;), &quot;+&quot;, Int(1))</code> です。しかし <code>b</code> の生成時には <code>a</code> の束縛が存在しません。したがって <code>a</code> はスナップショットへ入らず、<code>print b</code> が初めてその値を要求した時点で、現在のスコープの最新の <code>a = 7</code> を見つけます。</p>
<p>ここが、単に AST を作るだけでは分からない、<strong>実行時の環境捕捉・名前解決に関する意味論</strong>です。二つの例が同じ <code>Binary</code> の AST なのに <code>2</code> と <code>8</code> を返すことが、Heap と Env を Lean に用意する動機になりました。</p>
<p>ここでは <code>b</code> の Thunk を作ったときに <code>a</code> がまだないので、<code>env_b.snap</code> は空です。評価時は <code>env_b.scope = 1</code> をたどって現在の束縛を探します。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/forward-reference-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/forward-reference-ja.svg" alt="b の snap に a が存在しないため、scope 1 を検索して最新の a の #4 に到達する。" loading="lazy" decoding="async"></a>
</figure>
<p>先ほどの <code>2</code> と今回の <code>8</code> の違いは、<code>Binary</code> という構文の違いではなく、<strong>同じ名前 <code>a</code> を <code>Env.snap</code> から解決するか、後から生きた <code>Scope</code> で検索するか</strong>という違いになります。</p>
<h4 id="観測例3遅延評価の結果は共有されるe9">観測例3：遅延評価の結果は共有される（E9）</h4>
<p>メモ化を検査する <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/memo-binding.les"><code>memo-binding.les</code></a> は次のプログラムです。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">g</span><span class="p">():</span> <span class="n">Int</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="nb">print</span> <span class="s2">&#34;side;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="mi">1</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">x</span> <span class="o">=</span> <span class="n">g</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="s2">&#34;before;&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">x</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">x</span>
</span></span></code></pre></div><p>固定 Go CLI の期待値は以下です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;stdout&#34;</span><span class="p">:</span> <span class="s2">&#34;before;side;11&#34;</span><span class="p">,</span> <span class="nt">&#34;stderr&#34;</span><span class="p">:</span> <span class="s2">&#34;&#34;</span><span class="p">,</span> <span class="nt">&#34;exit_code&#34;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="nt">&#34;rules&#34;</span><span class="p">:</span> <span class="p">[</span><span class="s2">&#34;E9&#34;</span><span class="p">]}</span>
</span></span></code></pre></div><p><code>x = g()</code> の宣言時には <code>g</code> が呼ばれず、最初の <code>print x</code> で一度だけ <code>g</code> が評価されます。二度目の <code>print x</code> は共有された結果を再利用します。したがって <code>side;</code> は一度しか出ません。<code>lesdump</code> 側では <code>g</code> は <code>FuncDef</code>、<code>x = g()</code> は右辺に <code>Call</code> を持つ <code>VarDecl</code> として出力され、評価や副作用の回数は JSON には書かれません。</p>
<p>さらに失敗系の <a href="https://github.com/gotoken/les-spec/blob/main/difftest/corpus/blackhole.les"><code>blackhole.les</code></a> では、</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">x</span><span class="p">:</span> <span class="n">Int</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="s2">&#34;ok&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nb">print</span> <span class="n">x</span>
</span></span></code></pre></div><p>が stdout <code>ok</code> と終了コード1、stderr <code>Runtime Error: blackhole: circular reference detected in lazy thunk</code>（末尾改行付き）になります。後に Lean で導入する <code>Cell.blackhole</code> はこの観測を説明するための状態です。</p>
<h3 id="lean-側は何を比較するのか">Lean 側は何を比較するのか</h3>
<p>Lean のデコーダーは、<code>lesdump</code> の <code>{&quot;kind&quot;:&quot;Binary&quot;,…}</code> を <code>Expr.binary</code> に、<code>{&quot;kind&quot;:&quot;VarDecl&quot;,…}</code> を <code>Stmt.varDecl</code> に変換します。型解析が成功した <code>Program</code> だけを <code>CheckedProgram</code> にして実行します。ただし、Lean が Go の型推論の正しさを証明したわけではありません。</p>
<p><a href="https://github.com/gotoken/les-spec/blob/main/lean/Tests/Eval.lean"><code>lean/Tests/Eval.lean</code></a> の比較処理は、要点を抜き出すと次の形です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">verdictOf</span><span class="w"> </span><span class="o">(</span><span class="n">fuel</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Nat</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">src</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">String</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Except</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">Verdict</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="k">do</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">return</span><span class="w"> </span><span class="o">(</span><span class="n">run</span><span class="w"> </span><span class="n">fuel</span><span class="w"> </span><span class="o">(</span><span class="bp">←</span><span class="w"> </span><span class="n">progOf</span><span class="w"> </span><span class="n">src</span><span class="o">))</span><span class="bp">.</span><span class="n">verdict</span><span class="w">
</span></span></span></code></pre></div><p>テスト本体は各ケースについて <code>lesdump/golden/*.json</code> と <code>difftest/corpus/*.expect.json</code> を読み、<code>verdictOf</code> の返した <code>stdout</code>・<code>stderr</code>・<code>exitCode</code> と期待値を比較します。</p>
<p><code>UNSUPPORTED</code> や <code>OUT_OF_FUEL</code> は一致として数えません。現時点の35件はすべて <code>PASS</code> です。Lean の構文テストは JSON 35件のデコードと再エンコード等を、個別テスト41件は AST を直接組んだ評価を検査しています。</p>
<p>例えば個別テストでは、3回要求しても副作用が1回であることだけでなく、<strong>評価後に共有 Cell が本当に <code>.done</code> へ書き換わったこと</strong>を <code>runMachine</code> から取り出した Heap で確認しています。また <code>b</code> の <code>Env.snap</code> が再束縛前の <code>a</code> を指していることも Cell アドレスを比較して検査しています。</p>
<p>これらは「観測・実行テスト」です。次の P2 では、これと対応する Lean 評価器について、有限個のテストに依存しない性質を証明します。</p>
<h2 id="4-p2実際に何を-lean-で証明したのか">4. P2：実際に何を Lean で証明したのか</h2>
<p>P1 の35件は <code>stdout</code> などの<strong>観測結果の一致</strong>を調べます。P2 では、その比較に使っている<strong>同じ Lean 評価器</strong>を対象に、「どういう初期状態でも、この条件が成り立てば必ずこの結果になる」という定理を作りました。</p>
<p>中心となるのは、<a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/Memo.lean"><code>lean/Les/Proofs/Memo.lean</code></a> の <code>whnf_suspended_ok_memo</code> です。名前の <code>whnf</code> は <strong>weak head normal form（弱頭正規形）</strong> の略で、関数型言語の遅延評価で使われる用語です。このモデルでは「指定した Cell を、値が分かるところまで強制する処理」の名前として使っています。<code>whnf</code> は Lean の組込み関数でも Les の構文でもなく、<strong>今回の Lean 評価器で定義した関数</strong>です。定理の具体的な意味を読むために、まず Machine と Cell を確認します。</p>
<h3 id="41-評価器のデータ型名前ではなくアドレスを共有する">4.1 評価器のデータ型：名前ではなくアドレスを共有する</h3>
<p>ここで、先ほどの用語が Lean のどのデータ型に対応するかを図で確認します。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/machine-heap-env-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/machine-heap-env-ja.svg" alt="Machine は stdout と Heap を持つ。Heap は Scope と Cell の配列を持ち、Env は捕捉アドレスと検索開始 Scope を保持する。" loading="lazy" decoding="async"></a>
</figure>
<p><code>Machine</code> は「プログラム全文を保持したオブジェクト」ではなく、<strong>評価のあいだに更新される部分</strong>だけをまとめています。実行する式 <code>Expr</code>、その環境 <code>Env</code>、再帰の深さを制限する fuel は、<code>evalE</code>・<code>demand</code>・<code>whnf</code> などの関数の引数です。<code>Machine.stdout</code> は <code>print</code> による出力を、実際に端末へ書き込む代わりに文字列として保持します。だから例外が起きても、その時点までの出力を比較できます。</p>
<p>以下は実際の <a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Eval/Types.lean"><code>lean/Les/Eval/Types.lean</code></a> からの抜粋です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">abbrev</span><span class="w"> </span><span class="n">Addr</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">Nat</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">abbrev</span><span class="w"> </span><span class="n">ScopeId</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">Nat</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">structure</span><span class="w"> </span><span class="n">Env</span><span class="w"> </span><span class="kn">where</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">snap</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">List</span><span class="w"> </span><span class="o">(</span><span class="n">String</span><span class="w"> </span><span class="bp">×</span><span class="w"> </span><span class="n">Addr</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">scope</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">ScopeId</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">inductive</span><span class="w"> </span><span class="n">Cell</span><span class="w"> </span><span class="kn">where</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">done</span><span class="w"> </span><span class="o">(</span><span class="n">v</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Value</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">suspended</span><span class="w"> </span><span class="o">(</span><span class="n">e</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">env</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">blackhole</span><span class="w"> </span><span class="o">(</span><span class="n">e</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">structure</span><span class="w"> </span><span class="n">Scope</span><span class="w"> </span><span class="kn">where</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">vars</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">List</span><span class="w"> </span><span class="o">(</span><span class="n">String</span><span class="w"> </span><span class="bp">×</span><span class="w"> </span><span class="n">Addr</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">parent</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Option</span><span class="w"> </span><span class="n">ScopeId</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">structure</span><span class="w"> </span><span class="n">Heap</span><span class="w"> </span><span class="kn">where</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">cells</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Array</span><span class="w"> </span><span class="n">Cell</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">scopes</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Array</span><span class="w"> </span><span class="n">Scope</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">structure</span><span class="w"> </span><span class="n">Machine</span><span class="w"> </span><span class="kn">where</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Heap</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">stdout</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">String</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">abbrev</span><span class="w"> </span><span class="n">EvalM</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">ExceptT</span><span class="w"> </span><span class="n">Halt</span><span class="w"> </span><span class="o">(</span><span class="n">StateM</span><span class="w"> </span><span class="n">Machine</span><span class="o">)</span><span class="w">
</span></span></span></code></pre></div><p><code>Heap.cells</code> は Cell の配列で、<code>Addr</code> はその添字です。スコープの変数は値を直接持つのではなく Cell のアドレスを持っています。</p>
<p><code>Env.snap</code> は Thunk 作成時に解決できた名前とアドレスの組、<code>Env.scope</code> はまだ捕捉していない名前を探す生きたスコープの番号です。<code>Scope.vars</code> は現在の名前とアドレスの対応を持ち、<code>Scope.parent</code> は親スコープを参照します。<code>Env</code> が「式をどこから評価するか」を記録し、<code>Scope</code> が「その時点でどの名前がどの Cell に結び付いているか」を保持する、という役割分担です。</p>
<p><code>EvalM</code> も Lean の標準型そのものではなく、今回の評価器が付けた別名です。<strong>Machine の状態を読み書きし、途中でエラーや <code>exit</code> により停止する可能性がある計算</strong>を表します。<code>StateM Machine</code> が実行状態を扱い、<code>ExceptT Halt</code> が正常終了（<code>Except.ok</code>）と停止理由（<code>Except.error</code>）を扱います。</p>
<p><code>Cell</code> の3状態は、次の遷移を実装するためにあります。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/cell-states-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/cell-states-ja.svg" alt="最初の強制で suspended から blackhole に移り、demand の成功後に done になる。再入は循環参照エラーになり、done の再強制は値を返す。" loading="lazy" decoding="async"></a>
</figure>
<h3 id="evalewhnfdemand式アドレス値の違い"><code>evalE</code>・<code>whnf</code>・<code>demand</code>：式、アドレス、値の違い</h3>
<p>ここは Lean のコードを読むうえで重要です。評価器には、名前の似た3つの関数があります。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表（横スクロール可能）">
  <table>
    <thead>
      <tr>
        <th scope="col">関数</th>
        <th scope="col">名前の意味と役割</th>
        <th scope="col">入力から結果へ</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>evalE</code></td>
        <td><strong>evaluate expression</strong> の略。式を処理して、結果が入る Cell の<strong>アドレス</strong>を返す。識別子なら既存の Cell を返し、ここではまだ強制しない</td>
        <td><code>Expr → EvalM Addr</code>（fuel と Env は省略）</td>
      </tr>
      <tr>
        <td><code>whnf</code></td>
        <td><strong>weak head normal form</strong> の略。指定された Cell を要求時に強制し、値を返す。未評価ならその式を実行し、成功時に <code>done</code> としてメモ化する</td>
        <td><code>Addr → EvalM Value</code></td>
      </tr>
      <tr>
        <td><code>demand</code></td>
        <td>英語の <em>demand</em>（値を要求する）。<code>evalE</code> で得たアドレスを <code>whnf</code> に渡し、式の<strong>値</strong>を要求する。エラー時には式の位置情報も付ける</td>
        <td><code>Expr → EvalM Value</code></td>
      </tr>
    </tbody>
  </table>
</div>
<p>例えば <code>b = a + 1</code> の右辺を <code>evalE</code> に渡すのと <code>demand</code> に渡すのでは、結果の型と強制する範囲が違います。変数 <code>b</code> が未評価の Cell を指すとき、<code>evalE (Ident &quot;b&quot;)</code> に相当する処理はその<strong>アドレス</strong>を返し、<code>whnf</code> はアドレスの先にある式を評価して<strong>値</strong>を返します。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/evaluation-path-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/evaluation-path-ja.svg" alt="evalE は Expr から Addr を得て、whnf は Addr から Value を得る。demand はこの二つを合成する。" loading="lazy" decoding="async"></a>
</figure>
<p>WHNF を一般的な遅延評価の用語として言うと、式全体を完全に正規化するのではなく、<strong>外側の値が何なのかを判別できるところまで</strong>評価した状態です。例えば遅延リストなら、先頭の構成子が空リストか <code>cons</code> か分かれば、その要素や後続のリストは評価されていなくても WHNF に達しています。ただし、これは一般的な説明であり、<strong>現在の Les の Lean モデルにリストは実装していません</strong>。ここでの <code>whnf</code> は Cell を <code>Value</code> にする関数で、あらゆる入れ子の計算を再帰的に完全評価する「全正規化」の意味ではありません。</p>
<p>これらの関数には実際には先頭に <code>fuel : Nat</code> も渡します。<strong>fuel</strong> は自然数で与える再帰の制限で、ゼロなら <code>outOfFuel</code> になります。実行全体の命令数や計算量を数えるものではありません。</p>
<p>この遷移の中心になるのが <a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Eval/Eval.lean"><code>lean/Les/Eval/Eval.lean</code></a> の <code>whnf</code> です。以下は実際の定義です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">whnf</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Nat</span><span class="w"> </span><span class="bp">→</span><span class="w"> </span><span class="n">Addr</span><span class="w"> </span><span class="bp">→</span><span class="w"> </span><span class="n">EvalM</span><span class="w"> </span><span class="n">Value</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="mi">0</span><span class="o">,</span><span class="w"> </span><span class="bp">_</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">throw</span><span class="w"> </span><span class="bp">.</span><span class="n">outOfFuel</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="bp">+</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="k">do</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">match</span><span class="w"> </span><span class="o">(</span><span class="bp">←</span><span class="w"> </span><span class="n">getHeap</span><span class="o">)</span><span class="bp">.</span><span class="n">cell?</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="k">with</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="bp">|</span><span class="w"> </span><span class="n">none</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">throw</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">error</span><span class="w"> </span><span class="s2">&#34;internal: dangling address&#34;</span><span class="w"> </span><span class="bp">.</span><span class="n">absent</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="bp">|</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">pure</span><span class="w"> </span><span class="n">v</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="bp">|</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">blackhole</span><span class="w"> </span><span class="bp">_</span><span class="o">)</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="n">throw</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">error</span><span class="w"> </span><span class="s2">&#34;blackhole: circular reference detected in lazy thunk&#34;</span><span class="w"> </span><span class="bp">.</span><span class="n">absent</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="bp">|</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">suspended</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="o">)</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="k">do</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="n">modHeap</span><span class="w"> </span><span class="o">(</span><span class="bp">·.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">blackhole</span><span class="w"> </span><span class="n">e</span><span class="o">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="k">let</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="bp">←</span><span class="w"> </span><span class="n">demand</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="n">modHeap</span><span class="w"> </span><span class="o">(</span><span class="bp">·.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="n">pure</span><span class="w"> </span><span class="n">v</span><span class="w">
</span></span></span></code></pre></div><p><code>demand</code> は式を評価してから、その結果の Cell を <code>whnf</code> で強制する関数です。<code>EvalM</code> の順序が <code>ExceptT Halt (StateM Machine)</code> なので、途中でエラーが起きても、エラー前に書き込んだ stdout や Heap の状態は残ります。</p>
<p>先ほどの <code>memo-binding.les</code> で、最初の <code>print x</code> が副作用を生み、2度目は生まない理由を、このモデルでは<strong>同一アドレスの Cell が <code>suspended</code> から <code>done</code> へ変わるため</strong>と表現します。</p>
<h3 id="42-p2aheap-の局所操作">4.2 P2a：Heap の局所操作</h3>
<p>このモデルのために、まず <a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/Heap.lean"><code>Proofs/Heap.lean</code></a> で <code>alloc</code>、<code>setCell</code>、<code>bind</code> を調べました。例えば、次は実際の補題です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">theorem</span><span class="w"> </span><span class="n">Heap</span><span class="bp">.</span><span class="n">alloc_cell?_new</span><span class="w"> </span><span class="o">(</span><span class="n">h</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Heap</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">c</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Cell</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="o">(</span><span class="n">h</span><span class="bp">.</span><span class="n">alloc</span><span class="w"> </span><span class="n">c</span><span class="o">)</span><span class="bp">.</span><span class="m">1</span><span class="bp">.</span><span class="n">cell?</span><span class="w"> </span><span class="o">(</span><span class="n">h</span><span class="bp">.</span><span class="n">alloc</span><span class="w"> </span><span class="n">c</span><span class="o">)</span><span class="bp">.</span><span class="m">2</span><span class="w"> </span><span class="bp">=</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="n">c</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="k">by</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">simp</span><span class="w"> </span><span class="o">[</span><span class="n">Heap</span><span class="bp">.</span><span class="n">alloc</span><span class="o">,</span><span class="w"> </span><span class="n">Heap</span><span class="bp">.</span><span class="n">cell?</span><span class="o">]</span><span class="w">
</span></span></span></code></pre></div><p>「Cell を新しく割り当てたら、返されたアドレスには、その Cell が入っている」という、当たり前に思える性質です。ただし、ここを補題として確定しておけば、後で状態を変更する証明に引用できます。</p>
<p>反対に、<code>Heap.bind</code> は任意のアドレスを登録できるので、すべての Heap が自動的に整合的になるわけではありません。必要な仮定を明示することが、P2d の仕事につながりました。</p>
<h3 id="43-p2c2-と-8-の違いをアドレスで証明する">4.3 P2c：<code>2</code> と <code>8</code> の違いをアドレスで証明する</h3>
<p>P1 の <code>snapshot-late-rebind.les</code> は <code>2</code>、<code>forward-ref-rebound.les</code> は <code>8</code> でした。この差を生むのが、<a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Eval/Eval.lean"><code>Eval.lean</code></a> の名前解決と環境捕捉です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">lookupEnv</span><span class="w"> </span><span class="o">(</span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Heap</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">env</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">n</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">String</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Option</span><span class="w"> </span><span class="n">Addr</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">match</span><span class="w"> </span><span class="n">env</span><span class="bp">.</span><span class="n">snap</span><span class="bp">.</span><span class="n">find?</span><span class="w"> </span><span class="o">(</span><span class="bp">·.</span><span class="m">1</span><span class="w"> </span><span class="bp">==</span><span class="w"> </span><span class="n">n</span><span class="o">)</span><span class="w"> </span><span class="k">with</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">_</span><span class="o">,</span><span class="w"> </span><span class="n">a</span><span class="o">)</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="n">a</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">|</span><span class="w"> </span><span class="n">none</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">heap</span><span class="bp">.</span><span class="n">lookup</span><span class="w"> </span><span class="n">env</span><span class="bp">.</span><span class="n">scope</span><span class="w"> </span><span class="n">n</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">capture</span><span class="w"> </span><span class="o">(</span><span class="n">e</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">env</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">EvalM</span><span class="w"> </span><span class="n">Env</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="k">do</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">let</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="bp">←</span><span class="w"> </span><span class="n">getHeap</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">let</span><span class="w"> </span><span class="n">names</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="o">(</span><span class="n">exprNames</span><span class="w"> </span><span class="n">e</span><span class="o">)</span><span class="bp">.</span><span class="n">eraseDups</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">let</span><span class="w"> </span><span class="n">snap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">names</span><span class="bp">.</span><span class="n">filterMap</span><span class="w"> </span><span class="k">fun</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="o">(</span><span class="n">lookupEnv</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="n">env</span><span class="w"> </span><span class="n">n</span><span class="o">)</span><span class="bp">.</span><span class="n">map</span><span class="w"> </span><span class="o">(</span><span class="n">n</span><span class="o">,</span><span class="w"> </span><span class="bp">·</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">return</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">snap</span><span class="o">,</span><span class="w"> </span><span class="n">scope</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">env</span><span class="bp">.</span><span class="n">scope</span><span class="w"> </span><span class="o">}</span><span class="w">
</span></span></span></code></pre></div><p><code>capture</code> は式に現れる識別子について、解決できるものだけを <code>snap</code> に入れます。未束縛の名前は入りません。</p>
<p><a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/Capture.lean"><code>Proofs/Capture.lean</code></a> の <code>capture_preserves_under_bind</code> は、捕捉済みの名前について、後の <code>Heap.bind</code> でも<strong>同じアドレスを返し、その再束縛操作は元の Cell の中身を変更しない</strong>ことを示します。<code>capture_unbound_lookup</code> と <code>forward_ref_rebound</code> は、捕捉されなかった名前の検索が後の再束縛を見られることを、条件付きで示します。</p>
<p>つまり、テストで観測した <code>2</code> と <code>8</code> に対応する<strong>名前解決の部品</strong>は Lean で証明済みです。ただし、これらの補題だけで「任意の Les のソースを実行すると必ず <code>2</code> になる」というプログラム全体の定理になるわけではありません。</p>
<h3 id="44-p2dcell-を消さないことから元のアドレスが残ることへ">4.4 P2d：Cell を消さないことから、元のアドレスが残ることへ</h3>
<p>初回強制で必要なのは、<code>demand</code> の実行が終わったあとも、元の Thunk のアドレスが有効であることです。</p>
<p>ここでは一見遠回りに見える性質を証明しました。</p>
<p><a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/Monotone.lean"><code>Proofs/Monotone.lean</code></a> にある定義は次のとおりです。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">Machine</span><span class="bp">.</span><span class="n">CellsMono</span><span class="w"> </span><span class="o">(</span><span class="n">m</span><span class="w"> </span><span class="n">m&#39;</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Machine</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">Prop</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">m</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">cells</span><span class="bp">.</span><span class="n">size</span><span class="w"> </span><span class="bp">≤</span><span class="w"> </span><span class="n">m&#39;</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">cells</span><span class="bp">.</span><span class="n">size</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">Mono</span><span class="w"> </span><span class="o">{</span><span class="n">α</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">Type</span><span class="o">}</span><span class="w"> </span><span class="o">(</span><span class="n">x</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">EvalM</span><span class="w"> </span><span class="n">α</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="kt">Prop</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="bp">∀</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Machine</span><span class="o">,</span><span class="w"> </span><span class="n">m</span><span class="bp">.</span><span class="n">CellsMono</span><span class="w"> </span><span class="o">((</span><span class="n">x</span><span class="bp">.</span><span class="n">run</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="w"> </span><span class="n">m</span><span class="o">)</span><span class="bp">.</span><span class="m">2</span><span class="w">
</span></span></span></code></pre></div><p><code>Mono</code> は数学の <strong>monotone（単調）</strong> に由来する、今回定義した命題の名前です。Lean の組込みの検証コマンドではありません。<code>Mono x</code> は、どんな開始 Machine で <code>x</code> を実行しても、<strong>最終 Machine の Cell 配列が短くならない</strong>という意味です。成功時だけでなく、例外で終わる場合も含めます。中間状態のすべてについて述べた定理ではありません。</p>
<p>それを実際の相互再帰評価器について示したのが <a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/MonotoneEval.lean"><code>Proofs/MonotoneEval.lean</code></a> の次の定理です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">theorem</span><span class="w"> </span><span class="n">demand_mono</span><span class="w"> </span><span class="o">(</span><span class="n">fuel</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Nat</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">e</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">env</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">Mono</span><span class="w"> </span><span class="o">(</span><span class="n">demand</span><span class="w"> </span><span class="n">fuel</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="o">)</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="o">(</span><span class="n">monoAt</span><span class="w"> </span><span class="n">fuel</span><span class="o">)</span><span class="bp">.</span><span class="m">2</span><span class="bp">.</span><span class="m">2</span><span class="bp">.</span><span class="m">1</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="w">
</span></span></span></code></pre></div><p><code>monoAt</code> は <code>evalE</code>、<code>whnf</code>、<code>demand</code>、関数呼び出し、引数準備、文実行など相互再帰する<strong>11個の関数</strong>の <code>Mono</code> をまとめた命題です。これを fuel に関する帰納法で証明しています。</p>
<p>Cell が配列から消えなければ、開始時に有効だった添字は終了時にも有効です。そこから <code>demand_validAddr</code> を導き、以前は別途必要だった <code>hvalid</code>（実行後もアドレスが有効という仮定）を削除しました。</p>
<p>ここで大切なのは、<strong>配列の長さが減らないことは、各 Cell の中身が変わらないことではない</strong>という点です。<code>suspended</code> を <code>blackhole</code> や <code>done</code> に更新することは認めています。</p>
<h3 id="45-最終的な定理whnf_suspended_ok_memop2d-5">4.5 最終的な定理：<code>whnf_suspended_ok_memo</code>（P2d-5）</h3>
<p>以上を組み合わせて得られた定理が、<a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/Memo.lean"><code>Memo.lean</code> の <code>whnf_suspended_ok_memo</code></a> です。次は実際の<strong>定理文と証明全文</strong>です。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">theorem</span><span class="w"> </span><span class="n">whnf_suspended_ok_memo</span><span class="w"> </span><span class="o">(</span><span class="n">n</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Nat</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">a</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Addr</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">e</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">env</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">m</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Machine</span><span class="o">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="o">(</span><span class="n">v</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Value</span><span class="o">)</span><span class="w"> </span><span class="o">(</span><span class="n">h</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">m</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">cell?</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="bp">=</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">suspended</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="o">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="o">(</span><span class="n">hd</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="o">((</span><span class="n">demand</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="w"> </span><span class="o">(</span><span class="n">m</span><span class="bp">.</span><span class="n">blackholed</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">e</span><span class="o">)</span><span class="w"> </span><span class="bp">=</span><span class="w"> </span><span class="o">(</span><span class="n">Except</span><span class="bp">.</span><span class="n">ok</span><span class="w"> </span><span class="n">v</span><span class="o">,</span><span class="w"> </span><span class="n">m₂</span><span class="o">))</span><span class="w"> </span><span class="o">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="o">((</span><span class="n">whnf</span><span class="w"> </span><span class="o">(</span><span class="n">n</span><span class="w"> </span><span class="bp">+</span><span class="w"> </span><span class="mi">1</span><span class="o">)</span><span class="w"> </span><span class="n">a</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="o">(</span><span class="n">Except</span><span class="bp">.</span><span class="n">ok</span><span class="w"> </span><span class="n">v</span><span class="o">,</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="k">with</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">m₂</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="o">})</span><span class="w"> </span><span class="bp">∧</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="o">({</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="k">with</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">m₂</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="o">})</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">cell?</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="bp">=</span><span class="w"> </span><span class="n">some</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="bp">∧</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="bp">∀</span><span class="w"> </span><span class="n">k</span><span class="o">,</span><span class="w"> </span><span class="o">((</span><span class="n">whnf</span><span class="w"> </span><span class="o">(</span><span class="n">k</span><span class="w"> </span><span class="bp">+</span><span class="w"> </span><span class="mi">1</span><span class="o">)</span><span class="w"> </span><span class="n">a</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="o">)</span><span class="bp">.</span><span class="n">run</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="k">with</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">m₂</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="o">}</span><span class="w"> </span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="o">(</span><span class="n">Except</span><span class="bp">.</span><span class="n">ok</span><span class="w"> </span><span class="n">v</span><span class="o">,</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="k">with</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">m₂</span><span class="bp">.</span><span class="n">heap</span><span class="bp">.</span><span class="n">setCell</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">(</span><span class="bp">.</span><span class="n">done</span><span class="w"> </span><span class="n">v</span><span class="o">)</span><span class="w"> </span><span class="o">})</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="k">by</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">have</span><span class="w"> </span><span class="n">h1</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">whnf_suspended_ok</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="n">h</span><span class="w"> </span><span class="n">hd</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="k">have</span><span class="w"> </span><span class="n">h2</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">whnf_suspended_ok_cell_valid</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">e</span><span class="w"> </span><span class="n">env</span><span class="w"> </span><span class="n">m</span><span class="w"> </span><span class="n">m₂</span><span class="w"> </span><span class="bp">_</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="n">h</span><span class="w"> </span><span class="n">hd</span><span class="w"> </span><span class="n">h1</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="n">exact</span><span class="w"> </span><span class="bp">⟨</span><span class="n">h1</span><span class="o">,</span><span class="w"> </span><span class="n">h2</span><span class="o">,</span><span class="w"> </span><span class="k">fun</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="bp">=&gt;</span><span class="w"> </span><span class="n">whnf_done</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="bp">_</span><span class="w"> </span><span class="n">h2</span><span class="bp">⟩</span><span class="w">
</span></span></span></code></pre></div><h4 id="定理文を読むための-lean-の記法">定理文を読むための Lean の記法</h4>
<p>定理の中の <code>((demand n e env).run).run m</code> は、<code>demand</code> を実行状態 <code>m</code> から実行し、<strong>結果と実行後の状態の組</strong>を得る式です。<code>run</code> が二度あるのは、<code>EvalM</code> が <code>ExceptT</code> と <code>StateM</code> という二つの層で構成されており、それぞれを取り出すためです。値と状態を区別すると、結果の型は概ね次のとおりです。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="n">Except</span><span class="w"> </span><span class="n">Halt</span><span class="w"> </span><span class="n">Value</span><span class="w"> </span><span class="bp">×</span><span class="w"> </span><span class="n">Machine</span><span class="w">
</span></span></span></code></pre></div><p><code>Except.ok v</code> は正常終了して値 <code>v</code> を得たこと、<code>Except.error h</code> は停止理由 <code>h</code> を得たことです。<code>(結果, m₂)</code> のように Machine が組の第2成分に残るため、エラー終了時の Heap や stdout も検査できます。</p>
<p>また、Lean の定理の読み方には、次の記号だけ押さえておけば十分です。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表（横スクロール可能）">
  <table>
    <thead>
      <tr>
        <th scope="col">記法</th>
        <th scope="col">この定理での読み方</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><code>theorem 名前 (引数) : 命題 := by ...</code></td>
        <td>命題を宣言し、<code>by</code> 以下で証明する</td>
      </tr>
      <tr>
        <td><code>h : ...</code>、<code>hd : ...</code></td>
        <td><strong>仮定</strong>に名前を付けている。任意に成り立つと宣言したわけではない</td>
      </tr>
      <tr>
        <td><code>∧</code></td>
        <td>「かつ」。ここでは結論が3つある</td>
      </tr>
      <tr>
        <td><code>∀ k</code></td>
        <td>「すべての自然数 <code>k</code> について」</td>
      </tr>
      <tr>
        <td><code>{ m₂ with heap := ... }</code></td>
        <td>Machine <code>m₂</code> の <code>heap</code> フィールドだけを更新したもの</td>
      </tr>
      <tr>
        <td><code>h1</code>・<code>h2</code>、<code>exact</code></td>
        <td>既に証明した補題を結合し、要求された結論を渡す</td>
      </tr>
    </tbody>
  </table>
</div>
<p>この <code>run.run</code> や <code>∀</code> は<strong>Lean の表記</strong>です。それに対して <code>whnf</code>、<code>demand</code>、<code>Mono</code> は、この記事の対象である <strong>les-spec が定義した名前</strong>です。両者を区別して読むと、定理の意味を追いやすくなります。</p>
<p>Lean の記法に慣れていなければ、二つの仮定と三つの結論に分けると読みやすくなります。</p>
<p><strong>仮定</strong></p>
<ol>
<li><code>h</code>：最初の Machine <code>m</code> のアドレス <code>a</code> に、未評価の式 <code>e</code> と環境 <code>env</code> が入っている。</li>
<li><code>hd</code>：その Cell を <code>blackhole</code> にした状態で <code>demand n e env</code> を実行したところ、値 <code>v</code> を返して正常終了し、Machine <code>m₂</code> になった。</li>
</ol>
<p>ここで <code>m₃</code> を「<code>m₂</code> のアドレス <code>a</code> の Cell を <code>done v</code> に書き換えた Machine」と呼ぶことにします。</p>
<p><strong>結論</strong></p>
<ol>
<li>最初の <code>whnf (n+1) a</code> は <code>ok v</code> を返し、最終状態は <code>m₃</code> である。</li>
<li><code>m₃</code> のアドレス <code>a</code> には、本当に <code>done v</code> が入っている。</li>
<li>以後の <code>whnf (k+1) a</code> は<strong>どんな <code>k : Nat</code> についても</strong> <code>ok v</code> を返し、<code>m₃</code> を変更しない。</li>
</ol>
<p>これは、<code>memo-binding.les</code> の「<code>g()</code> を最初の要求で実行し、後から同じ <code>x</code> を要求しても副作用を繰り返さない」という観測を支える、<strong>Cell レベルの一般的性質</strong>です。</p>
<p>特に2番目は重要です。単に「強制したら同じ値が返った」というだけでなく、<strong>共有されたアドレスにメモ化された値が残る</strong>ことを保証しています。3番目は Machine 全体の等式なので、再強制で stdout も変わりません。</p>
<p>ただし、この定理は <strong><code>hd</code>、すなわち <code>demand</code> が正常終了することを仮定</strong>しています。自己参照のブラックホールやゼロ除算のような失敗時のメモ化は含みません。また、任意の Les プログラムから <code>x</code> への参照が必ず同じ Cell を指すという性質まで、この一つの定理が保証するわけではありません。その部分は評価器の実装と個別の共有テストで検査しています。</p>
<h3 id="46-定理の仮定を満たす実例も-lean-で構成した">4.6 定理の仮定を満たす実例も Lean で構成した</h3>
<p>定理に <code>hd</code> という条件を置くだけでは、「実際には誰も満たさない条件なのではないか」という疑問が残ります。</p>
<p>そこで <a href="https://github.com/gotoken/les-spec/blob/main/lean/Les/Proofs/NonVacuity.lean"><code>Proofs/NonVacuity.lean</code></a> では、実際の評価器が使う <code>Heap.initial</code> に未評価 Cell を一つ割り当てた具体例を用意しました。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-lean" data-lang="lean"><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">memoWitnessExpr</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Expr</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="bp">.</span><span class="n">int</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">line</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="mi">1</span><span class="o">,</span><span class="w"> </span><span class="n">col</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="o">}</span><span class="w"> </span><span class="mi">42</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">memoWitnessEnv</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Env</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="o">{</span><span class="w"> </span><span class="n">snap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="o">[],</span><span class="w"> </span><span class="n">scope</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="n">globalScope</span><span class="w"> </span><span class="o">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">memoWitnessCell</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Cell</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="bp">.</span><span class="n">suspended</span><span class="w"> </span><span class="n">memoWitnessExpr</span><span class="w"> </span><span class="n">memoWitnessEnv</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">memoWitnessMachine</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Machine</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="o">{</span><span class="w"> </span><span class="n">heap</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="o">(</span><span class="n">Heap</span><span class="bp">.</span><span class="n">initial</span><span class="bp">.</span><span class="n">alloc</span><span class="w"> </span><span class="n">memoWitnessCell</span><span class="o">)</span><span class="bp">.</span><span class="m">1</span><span class="o">,</span><span class="w"> </span><span class="n">stdout</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="s2">&#34;&#34;</span><span class="w"> </span><span class="o">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="kn">def</span><span class="w"> </span><span class="n">memoWitnessAddr</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Addr</span><span class="w"> </span><span class="o">:</span><span class="bp">=</span><span class="w"> </span><span class="o">(</span><span class="n">Heap</span><span class="bp">.</span><span class="n">initial</span><span class="bp">.</span><span class="n">alloc</span><span class="w"> </span><span class="n">memoWitnessCell</span><span class="o">)</span><span class="bp">.</span><span class="m">2</span><span class="w">
</span></span></span></code></pre></div><p>証明 <code>memoWitness_suspended</code> は、そのアドレスの Cell が未評価であることを示します。<code>memoWitness_demand_ok</code> は、その Cell を <code>blackhole</code> にした状態から <code>demand 2</code> を実行すると <code>ok (.int 42)</code> になることを示します。<code>memoWitness_structWF</code> は、初期 Heap が定義済みの構造的整合性を満たすことを示します。</p>
<p>この三つを使い、<code>whnf_suspended_ok_memo_nonvacuous</code> は、<strong><code>whnf_suspended_ok_memo</code> の2つの仮定が同時に成立する Machine・式・環境が少なくとも一組ある</strong>ことを証明しています。<code>memoWitness_integrated</code> は、そこへ統合定理を適用して3つの結論を導く例です。</p>
<p>つまり関係は、次のようになります。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/observation-to-proof-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/observation-to-proof-ja.svg" alt="Go の観測、lesdump AST、Lean 評価器、35件の比較テストと補題、条件付きメモ化定理、非空虚性の具体例。" loading="lazy" decoding="async"></a>
</figure>
<p>図のテストと証明は、<strong>同じ Lean 評価器を対象にしている一方で、論理的に同じ主張ではありません</strong>。Go との35件の一致から定理を導いたわけではなく、Lean の定理から Go の実装全体の正しさを導いたわけでもありません。</p>
<h3 id="47-どのように検証したか">4.7 どのように検証したか</h3>
<p>定理は <code>#print axioms</code> でも確認しています。修正後の <a href="https://github.com/gotoken/les-spec/actions/runs/43715508019">PR #22 の CI</a> では、Lean 4.25.0 の <code>lake build</code> が成功し、<code>whnf_suspended_ok_memo_nonvacuous</code> と <code>memoWitness_integrated</code> の依存公理は <code>propext</code> と <code>Quot.sound</code> のみで、<code>sorryAx</code> はありませんでした。コーパス35件の比較もすべて PASS でした。</p>
<p>実は非空虚性の最初の実装では、<code>memoWitness_demand_ok</code> を単に <code>rfl</code> で示そうとしてコンパイルが失敗しました。その後、整数リテラルの評価が <code>done</code> Cell を割り当てることを確かめ、<code>whnf_done</code> を使って成功を証明する補題 <code>demand_int_ok</code> へ修正しています。</p>
<p>この失敗も含めて、<strong>実行結果を合わせる作業と、Lean カーネルが受け付ける証明を作る作業は別物</strong>であることが分かりました。現在は PR の段階で Lean のビルドと評価器のコーパステストを行う GitHub Actions も用意しています。</p>
<h2 id="5-lean-を使って何がうれしかったのか">5. Lean を使って何がうれしかったのか</h2>
<p>この実験で得られたものは、単なる別言語での再実装だけではありません。</p>
<p>まず、<strong>意味論上の前提条件を明確にできました。</strong></p>
<p>たとえば <code>Heap.bind</code> は、無効な Cell アドレスも引数として受け取れます。したがって、Heap の整合性が無条件で保存されるとは言えません。</p>
<p>証明を進めることで、どの操作にどの条件が必要なのかが明確になりました。実際に、無効なアドレスを束縛すると整合性が壊れる反例も記録しています。</p>
<p>次に、<strong>具体的なテスト結果と一般的な性質を区別できました。</strong></p>
<p>「このプログラムを実行すると同じ値になる」というのはテストです。</p>
<p>「任意の Machine について、評価済み Cell を再び強制しても値と状態が変わらない」というのは定理です。</p>
<p>今回の Lean による証明は後者です。対象となる Lean モデルについて、その定理の仮定を満たすすべての状態を扱います。</p>
<p>もう一つは、<strong>形式化そのものを小さく進められること</strong>です。</p>
<p>最初から言語全体の完全な意味論を設計する必要はありませんでした。観測し、必要なデータ型を用意し、小さな評価器を作り、そこで証明できる性質を増やしていく、という方法でも成果を積み上げられました。</p>
<h2 id="6-実際にどうやって作業したか">6. 実際にどうやって作業したか</h2>
<p>このプロジェクトでは、AI に実装と証明を支援させています。</p>
<p>主な実装と Lean の証明作業は Claude Sonnet 5.5 に担当させ、仕様の切り分けと設計、Pull Request のレビューについては別のモデルも使いました。GitHub 上では Codex によるレビューも利用しています。</p>
<p>重要視したのは、長い指示で一度にすべてを完成させることではなく、作業単位を小さくし、それぞれに停止条件を設けることです。</p>
<p>基本的なサイクルは次のとおりです。</p>
<ol>
<li>Go CLI で観測し、期待値と根拠を記録する。</li>
<li>必要な場合だけ Go の実装を調べ、Lean のモデルを設計する。</li>
<li>一つの機能、あるいは一組の定理を実装する。</li>
<li><code>lake build</code>、差分テスト、個別テストを実行する。</li>
<li>証明できた性質と未証明の性質を記録する。</li>
<li>PR を作成し、レビュー後に次へ進む。</li>
</ol>
<p>難しい意味論の解釈で詰まった場合だけ、より高コストなモデルへ相談する方針も設けました。ここまでの後半工程では、そのための <code>semantics-opus</code> を利用せずに進められています。</p>
<p>ただし、モデルのトークン使用量は十分に計測できておらず、<strong>この方法が人手の開発や別の AI 構成より安価である、という結論はまだ出せません。</strong></p>
<p>今回確認できたのは、AI の支援を受けながら、Lean のコンパイラに検査される証明を段階的に構築できたということです。</p>
<h2 id="7-まだ証明していないこと">7. まだ証明していないこと</h2>
<p>ここまでの成果には、明確な限界があります。</p>
<p>第一に、<strong>Go の Les 実装全体と Lean モデルの同値性は証明していません。</strong></p>
<p>Go CLI と Lean の観測結果が35件で一致していることと、Lean モデルのいくつかの性質が証明されていることは別の事実です。</p>
<p>第二に、<strong>Les の全機能は対象にしていません。</strong></p>
<p>Lean モデルが扱うのは、現時点では9種類の構文ノードからなる小さな部分言語です。元の Les が持つ構造体、パターンマッチ、複雑な型システムなどは対象外です。</p>
<p>第三に、<strong>型安全性は証明していません。</strong></p>
<p>現在の Lean 評価器は、Go 側の型解析が成功したことを示す <code>CheckedProgram</code> を入力として受け取ります。これは Lean が独立に型検査の正しさを証明したという意味ではありません。</p>
<p>第四に、<strong>Heap の完全な整合性もまだ証明していません。</strong></p>
<p>スコープの基本的な参照関係は検査していますが、Thunk の環境内に保存されたアドレスや、クロージャが保持するスコープなど、Cell の内部に含まれる参照までは対象にしていません。</p>
<p>こうした未証明の性質を明示的に残していることも、今回の実験では重要だと考えています。</p>
<h2 id="8-これから何を目指すのか">8. これから何を目指すのか</h2>
<p>現時点では、次の順序を考えています。</p>
<h3 id="近い目標p2-の成果を参照点として確定する">近い目標：P2 の成果を参照点として確定する</h3>
<p>初回強制の成功、Cell 数の単調性、メモ化、再強制の安定性は、P2d-5 の <code>whnf_suspended_ok_memo</code> に統合しました。具体的な証人も用意し、<a href="https://github.com/gotoken/les-spec/blob/main/docs/proof-coverage.ja.md">証明範囲の一覧</a> に観測・実行照合・定理の違いを記録しています。</p>
<p>次は、失敗した <code>demand</code> の後に残る Heap と blackhole の状態、Cell 内部の参照関係を含む整合性など、まだ条件付きでしか扱えていない部分を検討します。ただし、新機能の追加と同時にすべてを証明するわけではなく、必要な不変条件を選んで進めます。</p>
<h3 id="中期目標対象となる言語機能を広げる">中期目標：対象となる言語機能を広げる</h3>
<p>P3 では、<code>if</code>、Tuple、Dict、パターンマッチなど、Les の機能を一つずつ追加することを検討しています。順序は固定せず、Go 実装での観測可能性と既存の証明への影響を調べて選びます。</p>
<p>機能を増やすたびに、Go で観測し、意味論を整理し、Lean に実装し、必要な性質を証明するというサイクルを繰り返します。</p>
<p>一度に言語全体を移植するのではなく、各段階で動作する成果を維持したいと思っています。</p>
<h3 id="長期目標実装と形式モデルの関係を強くする">長期目標：実装と形式モデルの関係を強くする</h3>
<p>もっと先には、Go 実装と Lean モデルの関係を、現在の有限個の差分テストより強く説明できるようにしたいと考えています。</p>
<p>そのためには、対象部分言語の範囲を明確にしたうえで、より網羅的なテスト生成や、実装と仕様の対応関係の検討が必要になるでしょう。</p>
<p>Go 実装そのものの意味論的な正しさを形式的に証明するのは、さらに大きな課題です。</p>
<p>そこをいきなり最終目標とするのではなく、観測可能な仕様が蓄積され、Lean のモデルが検査可能な参照モデルとして役立つところをまず目指します。</p>
<h2 id="9-p2-完了後に知った-ruby-lean-先行例との答え合わせ">9. P2 完了後に知った <code>ruby-lean</code> ——先行例との答え合わせ</h2>
<p>P2 の証明を一区切りにした <strong>2026年11月</strong>、Sam Xifaras 氏が同年9月26日に公開した <a href="https://samx.io/blog/topics/devlog/2026-09-26-ruby-lean.html">「ruby-lean: A Ruby semantics with a type soundness proof」</a> の存在を知りました。<a href="https://samx.io/blog/topics/devlog/2026-09-26-ruby-lean-technical-appendix.html">技術付録</a> と <a href="https://github.com/sam-xif/ruby-lean">ソースコード</a> も公開されています。</p>
<p>記事自体は本実験を始めるより先に公開されていますが、<strong>私がこの仕事を知ったのは P2 を終えた後</strong>です。したがって、P0〜P2 の設計や実装が <code>ruby-lean</code> を参考にして行われたわけではありません。以下は事後的な答え合わせと、今後の選択肢の検討です。</p>
<h3 id="同じ方法を異なる言語と異なる定理へ適用している">同じ方法を、異なる言語と異なる定理へ適用している</h3>
<p><code>ruby-lean</code> は Ruby を Lean 4 で実行できるモデルにし、実際の CRuby との比較を行い、さらに Sorbet を参考にした<strong>限定的な型判定とその健全性</strong>を証明しています。こちらの <code>les-spec</code> は、Go 製の Les の一部を Lean で評価できるようにし、<strong>共有 Thunk のメモ化、環境捕捉、アドレスの有効性</strong>などを証明しました。</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表（横スクロール可能）">
  <table>
    <thead>
      <tr>
        <th scope="col">観点</th>
        <th scope="col"><code>les-spec</code>（P2 完了時点）</th>
        <th scope="col"><code>ruby-lean</code>（2026年9月の報告）</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>元の処理系と対象</td>
        <td>Go 製 Les。遅延評価、再束縛、捕捉、前方参照に注目</td>
        <td>CRuby。メソッド呼び出し、クラス、動的な変更なども扱う</td>
      </tr>
      <tr>
        <td>Lean への入力</td>
        <td>Go のパーサーと型解析を通した <code>lesdump</code> の JSON AST</td>
        <td>Ruby の表層構文をより小さなコア言語へ変換する <strong>desugaring</strong></td>
      </tr>
      <tr>
        <td>評価器</td>
        <td><code>evalE</code>・<code>whnf</code>・<code>demand</code> の fuel 付き再帰関数。<code>Machine</code> は Heap と stdout を保持</td>
        <td><strong>CESK 抽象機械</strong>。制御、環境、ストア、継続を明示して遷移する</td>
      </tr>
      <tr>
        <td>差分検査</td>
        <td>固定 Go CLI と35件の stdout・stderr・終了コードを比較</td>
        <td>CRuby の <code>bootstraptest</code> と生成テスト等を使用。技術付録では意味論について <strong>995/1,309件</strong>の bootstraptest 適合を報告</td>
      </tr>
      <tr>
        <td>証明の中心</td>
        <td><strong>成功した</strong>初回強制のメモ化と再強制の安定性など、評価器内部の性質</td>
        <td><strong>型検証器が受理したプログラム</strong>について、定義された種類の型関連エラーに陥らないこと</td>
      </tr>
    </tbody>
  </table>
</div>
<p>最後の行は成果の優劣を表していません。<strong>証明したい性質が違います</strong>。<code>ruby-lean</code> の結果は Ruby や Sorbet の全機能の健全性を保証するものではなく、<code>les-spec</code> の結果も Go と Lean の一般的な同値性を保証するものではありません。</p>
<h3 id="答え合わせ-1実行可能な意味論と実装への適合性は別問題">答え合わせ 1：実行可能な意味論と、実装への適合性は別問題</h3>
<p>まず確かめられたのは、<strong>Lean が定理を検証できること</strong>と、<strong>Lean の評価器が元の言語を正しくモデル化していること</strong>を分離する方針の妥当性です。</p>
<p>Xifaras 氏は、<code>ruby-lean</code> が大規模な差分テストに合格している一方で、Ruby の <code>to_str</code> を用いた暗黙の文字列変換について、CRuby との未解消の不一致を具体例とともに公表しています。モデルに対する定理の存在だけでは、そのモデルが元の処理系の全挙動を表す保証にはなりません。</p>
<p>こちらでも、<code>whnf_suspended_ok_memo</code> が証明しているのは、<strong>Lean の <code>whnf</code> による成功時の Cell の更新と再強制</strong>です。Go の Les がすべての入力でそれと同じ振る舞いをすることまでは証明していません。35件の一致を「意味論的同値性」と呼ばなかったことは、この先行例に照らしても重要です。</p>
<p>さらに、<code>ruby-lean</code> の技術付録では、既存の適合性テスト（Tier 0）、生成したテスト（Tier 1）、<strong>途中に <code>print</code> を挿入して副作用の発生順序を調べるテスト</strong>（Tier 1.5）、AI に生成させた複雑なテスト（Tier 3）を区別しています。Les の場合も、<code>E9</code> の共有 Thunk、<code>E14/E15</code> の束縛、<code>E17/E19</code> の評価順序を、単なる最終値だけでなく副作用の出現箇所によって区別するテストを増やせそうです。</p>
<h3 id="答え合わせ-2同じ-machine-でも評価器の構造は異なる">答え合わせ 2：同じ <code>Machine</code> でも評価器の構造は異なる</h3>
<p><code>ruby-lean</code> の評価器は <strong>CESK</strong>（<em>control, environment, store, continuation</em>）を採用しています。次に実行することを表す <code>ctl</code> と、残りの計算を保持する継続スタック <code>kont</code> が、<code>Machine</code> に含まれています。</p>
<p>これに対して、<code>les-spec</code> の <code>Machine</code> は <code>Heap</code> と <code>stdout</code> を保持します。どの式を次に評価するかは、<code>evalE</code>、<code>whnf</code>、<code>demand</code> の<strong>再帰呼び出し</strong>として表れ、明示的な <code>kont</code> スタックを持っていません。</p>

<figure class="shot">
  <a href="https://hsiw.io/blog/ja/posts/les-formalization/machine-comparison-ja.svg" data-lightbox><img src="https://hsiw.io/blog/ja/posts/les-formalization/machine-comparison-ja.svg" alt="les-spec の fuel 付き評価関数と Heap・stdout を持つ Machine、および ruby-lean の ctl・kont・stack・heap・out を持つ Machine の対照。" loading="lazy" decoding="async"></a>
</figure>
<p>また、同じ <code>Heap</code> という名前でも、<code>les-spec</code> では <strong>Thunk の状態を表す Cell の配列</strong>を管理し、<code>ruby-lean</code> では <strong>Ruby のオブジェクトを格納する配列</strong>が中心です。用語が似ていても、一対一に同じモデルではありません。</p>
<p>この違いから、現在の Les モデルをすぐ CESK へ書き換える必要はありません。しかし、将来 <code>return</code> / <code>break</code>、例外、I/O、評価の中断と再開などを拡張した場合、<strong>継続を明示することが証明を簡単にするか</strong>は比較する余地があります。技術付録では継続スタックの分解に関する補題が証明の助けになったことも述べられています。</p>
<h3 id="答え合わせ-3テスト件数の増加だけではなく証明を維持する進め方">答え合わせ 3：テスト件数の増加だけではなく、証明を維持する進め方</h3>
<p>もう一つ共通していたのは、AI に大きな仕様を一度に実装させるのではなく、<strong>小さな達成条件を積み重ねる</strong>という方針です。</p>
<p>Xifaras 氏はこれを <strong>ratchet（ラチェット、一方向へ進める仕組み）</strong> と呼びます。特に型の判定規則を追加するときは、個別のテストが通るだけでなく、<strong>追加した規則の証明義務を満たし、全体の型健全性の定理も維持する</strong>ことを完了条件にしています。</p>
<p><code>les-spec</code> でも観測、モデル、証明を小さな PR に分けました。しかし、P2d-5 の非空虚性を示す <code>NonVacuity.lean</code> が最初の <code>lake build</code> で失敗したように、分割だけでは不十分です。その後に <code>lake build</code> と既存のコーパステストを GitHub Actions に追加しました。ここは、先行例の方法と自分たちの失敗経験が符合するところです。</p>
<h3 id="今後の追加プランとして検討できること">今後の追加プランとして検討できること</h3>
<p><strong>1. 差分テストを複数の方法で増やす。</strong> 手作りの35件に加え、型検査を通る Les プログラムの生成、観測可能な副作用の挿入、既存の Thunk 共有・環境捕捉の例の組合せなどを検討します。単にテスト数を増やすより、<strong>どの評価規則を区別できるか</strong>を指標にする方が、この題材には合っています。生成テストに対する Go と Lean の一致は引き続き観測であり、証明ではありません。</p>
<p><strong>2. P3 の機能追加でも既存の定理を維持する。</strong> <code>if</code>、Tuple、Dict などを増やすときには、Go のオラクルと Lean の結果が一致することに加え、<code>demand_mono</code>、アドレス有効性、メモ化の証明を維持することを完了条件にします。追加した評価規則で新しい前提が必要なら、その理由と適用範囲を明示します。先行例のラチェットを、<strong>実行コーパスと証明の二つの軸</strong>に適用する案です。</p>
<p><strong>3. コア言語への変換が必要かを検討する。</strong> <code>ruby-lean</code> は表層 Ruby の構文を小さなコアへ変換しています。Les も対応構文が増えたとき、表層構文をそのまま一つずつ Lean に追加するより、小さなコアへ変換した方が証明を短くできるかもしれません。一方で、その <strong>desugaring 自体が元のプログラムの挙動を変えないか</strong>を新たに検証する必要があります。<code>lesdump</code> の現状を直ちに置き換える計画ではありません。</p>
<p><strong>4. 型については「推論器全体の移植」以外も候補にする。</strong> 今の <code>CheckedProgram</code> は Go 側の型解析の成功を信頼しています。<code>ruby-lean</code> は、型導出の候補を<strong>信頼しない生成器</strong>が作り、Lean の検証器がそれを検査する方法を選びました。これは将来 Les の型を検証する際の選択肢になります。ただし、遅延評価、再束縛、前方参照を持つ Les では、まず<strong>どのエラーを排除することが型安全性なのか</strong>を定義しなければなりません。これは現行の P3 に追加すると決めた作業ではなく、長期的な検討事項です。</p>
<p>先行例を後から知ったことで、P2 の仕事をやり直す必要が生じたわけではありません。むしろ、<strong>実装の観測と形式的証明を分けて進める方向性</strong>を別の実践と照合できました。一方、CESK や型健全性の大きな証明は、その目的が必要になってから採否を決めるべきであり、方法だけをそのまま移すものではないと考えています。</p>
<p>この節は、<a href="https://samx.io/blog/topics/devlog/2026-09-26-ruby-lean.html">本文</a>、<a href="https://samx.io/blog/topics/devlog/2026-09-26-ruby-lean-technical-appendix.html">技術付録</a>、<a href="https://github.com/sam-xif/ruby-lean"><code>ruby-lean</code> の公開コード</a> に基づく比較です。上記の追加プランは<strong>候補</strong>であり、実装済みの成果ではありません。</p>
<h2 id="10-おわりに">10. おわりに</h2>
<p>今回 Les を題材にしてみて、言語処理系の形式化は、最初から巨大な仕様書を作らなくても始められることが分かりました。</p>
<p>Les は比較的小さな実装でありながら、遅延評価、メモ化、クロージャ、環境捕捉、前方参照、再束縛など、意味論的に興味深い要素を持っています。</p>
<p>特に、作成時に存在した名前は捕捉し、未束縛だった名前は後から解決するという仕組みは、どのような環境モデルが必要かを考えるよい題材になりました。</p>
<p>そして、Go 実装の観測から構築した Lean モデルについて、実際に一般的な性質を証明するところまで進められました。</p>
<p>まだ小さな部分言語に限った成果ですが、ここから先も観測と証明を少しずつ積み重ねていく予定です。</p>
<p>最後に、Les を公開してくださった usa さんに感謝します。また、本稿を読んでくださったことにも、この場を借りてお礼を申し上げます。</p>
<h3 id="関連リポジトリ">関連リポジトリ</h3>
<ul>
<li><a href="https://github.com/unak/les">unak/les</a> — 形式化の対象となる Go 製言語</li>
<li><a href="https://github.com/gotoken/les-spec">gotoken/les-spec</a> — 今回の実験</li>
<li><a href="https://github.com/gotoken/les-spec/blob/main/docs/evaluator-design.ja.md">評価器の設計メモ</a> — E1〜E22 の規則と根拠</li>
<li><a href="https://github.com/gotoken/les-spec/tree/main/difftest/corpus">差分テストのコーパス</a> — 観測に使ったプログラムと期待結果</li>
<li><a href="https://github.com/gotoken/les-spec/tree/main/lean/Les/Proofs">Lean の証明</a> — Heap、メモ化、環境捕捉、単調性などの証明</li>
</ul>
]]></content:encoded></item></channel></rss>