はじめに

みなさん、こんにちは。PLaMo事後学習チームの今村です。我々は本日、国産生成AI基盤モデルPLaMoTMの新たなフラグシップモデルPLaMo 3.0 Prime β版をリリースしました。現在、無償利用を前提にモニター企業様を募集中です。ぜひこちらからご応募ください。

PLaMo 3.0 Prime β版は、我々がこれからも開発を継続していくPLaMo 3.x Prime系統初のフラグシップモデルです。PLaMo 2.x Prime系統の開発までで培ったノウハウを集約して、アーキテクチャを一新し事前学習からゼロベースで再構築しました。学習データ・学習パイプラインに関する様々な工夫とともに事後学習を施したモデルです。また、フルスクラッチモデルとしては日本国内初のReasoning対応モデルとなります。このブログではPLaMo 3.0 Prime β版がPLaMo 2.x Prime系統に比べて何がどのように進化したのか、また既存のモデルと比べて定量的・定性的にどのような性能を発揮するのか、を簡単にご紹介します。

なお本モデルはβ版としての提供となります。今後モニター企業様らのフィードバックも踏まえながら、更なる性能向上と安定化を進めてまいります。

TL;DR

• YaRNを用いた継続事前学習により、長いコンテキスト長(~64Kトークン)でも高い性能を発揮します。
• 推論モデルの採用と学習データの拡充によって様々な領域のタスク性能が大幅に向上しました。

何が変わったか

コンテキスト長の拡張

大規模言語モデルの入出力として「どの程度の長さ(コンテキスト長)の文章を扱うことができるのか」は、実務に生成AIを利用しようと考えたとき非常に重要なファクターとなります。最も単純には非常に長いコンテキスト長での学習を事前学習段階から実施することが考えらます。しかし大規模な計算資源を長期間にわたって必要とする事前学習において、十分に長いコンテキスト長で学習を行うことは現実的ではありません。そこで近年は事前学習後にモデルに工夫を行って比較的小規模な追加の事前学習(継続事前学習と呼びます)を行うことで、後からコンテキスト長を拡張する研究が多くなされています。我々はその中でもRoPEの回転周波数に工夫を施す代表的な手法であるYaRNを採用し、コンテキスト長を64K(=65,536)トークン(出力側は最大20Kトークン)まで伸ばすことに成功しました。PLaMo 2.2 Primeでは32Kトークン(出力側は最大4Kトークン)だったのでコンテキスト長としては2倍になっています。ただし、 オープンウェイトモデルの中で最先端のDeepSeek V3.2の164KやGLM-5の205K、またクローズドなフロンティアモデルであるGPT-5.2の400K, Gemini 3.1 Pro Previewの1Mなどとはまだギャップがあるため、今後もコンテキスト長の拡張に挑戦していきます。

推論モデル (Reasoning Model) の採用

推論モデルとは、最終的な出力を生成する前に複雑な問題を小さなステップに分割して段階的に解き進めたり、探索的な試行錯誤や推敲の繰り返しによる改善をしたりするように訓練された大規模言語モデルです。PLaMo 3 Prime β版はこの推論モデルを採用することで、推論能力をはじめ、様々な領域のタスク性能が大幅に向上しました。

推論モデルの学習を達成するため、DeepSeek-R1やそれに追随するオープンな推論モデルの構築手法を参考にしつつ、これまでのPLaMo 2.x Prime系統の事後学習データ・パイプラインを全面的に見直しました。最終的な学習パイプラインとしては、教師ありファインチューニング(Supervised Fine-Tuning, SFT)、直接選好最適化(Direct Preference Optimization, DPO)、強化学習(Reinforcement Learning, RL)を実施しました。SFTとDPOについてはこれまでも採用してきましたが、最終的な回答部分だけでなく思考過程についても損失計算を行うように変更を加えました。RLについては今回初めて採用し、学習を安定させる工夫などを組み込みました。学習のどの段階でも性能向上が確認できました。

学習データセットの構築に際してはまず、これまでPLaMo 2.x Prime系統の事後学習で使っていたデータセットに加え、新たにオープンなデータセットを収集したほか、独自データを大幅に拡充しました。日本語の指示追従性能を向上させるための独自ベンチマークJFBenchに基づくデータ、ツールの利用を適切に行えるようにするためのデータ、長コンテキストにおける一貫性のある質問応答のためのデータ、医療分野における知識を補強するためのデータ、その他STEM分野やRAG性能向上のためのデータなどです。SFTおよびDPO向けデータセットは、各指示に対して思考過程と回答を大規模に生成しました。RLでは各ドメインごとに、参照回答との比較や表層的な特徴などから適切な報酬を算出する関数を実装しました。

ベンチマーク結果

PLaMo 3.0 Prime β版をPLaMo 2.2 Prime, Qwen3-235B-A22B-Thinking-2507, gpt-oss-120b (reasoning effortを中くらいの”medium”に設定したもの)と比較します。MXFP4 量子化済みモデルが配布されている gpt-oss-120b 以外のモデルは量子化前のモデルでの評価となっています。実際に提供される PLaMo 3.0 Prime β版ではデプロイ先ハードウェアに合わせた最適化を行っているため一部挙動や性能が異なる場合があります。

比較するベンチマークは、我々が性能向上を狙ってトラックしてきた英語や日本語における指示追従性能(IFBench/JFBench)、ツール使用性能(BFCL)、長コンテキストにおける質問応答性能(LongBench v2)、医療分野における質問応答性能(MedRECT, 医師国家試験)を中心に、その他重要と考えられる英語や日本語の対話能力(MT-bench, Japanese MT-bench)、日本の法令に関する質問応答性能(lawqa_jp)、STEM分野における性能(AIME 2024, GPQA-Diamond)です。ベンチマークの評価方法の詳細については、Appendixをご確認ください。

図1に11個のベンチマークそれぞれに対する評価結果を示します。ほとんどすべてのベンチマークにおいて、PLaMo 3.0 Prime β版はPLaMo 2.2 Primeよりも改善しています。特に数学的推論能力を測るAIME 2024は飛躍的に進化しており、これはReasoning能力を獲得した結果であると考えています。

PLaMo 3.0 Prime β版とQwen3-235B-A22B-Thinking-2507, gpt-oss-120bを比較すると、多くのベンチマークで彼らと同等程度の性能を発揮していると言えます。特に英語や日本語の指示追従性を測るIFBench/JFBenchでは両モデルよりも高いスコアをマークしており、これは指示追従性を改善するための様々なデータセットを拡充してきた成果であると考えています。また、日本語における対話能力を測るJapanese MTBenchでもPLaMo 3.0 Prime β版はQwen3-235B-A22B-Thinking-2507, gpt-oss-120bと同等以上のスコアをマークしており、このベンチマークに関しては上限に近い性能を達成したのではないかと考えています。一方で、ツール使用性能を測るBFCLの複数ターンで複数ツールから選択するケースや数学的推論能力を測るAIME 2024 (これはアメリカの数学オリンピック国内予選の問題です)、STEM分野の知識を測るGPQA-Diamond (これは生物・物理・化学の専門家レベルの多肢選択問題です)では大きく劣っており、今後は積極的に改善を進めていく予定です。

実際の出力例

PLaMo 3.0 Prime β版は入力に対して思考過程も含めて出力を生成する能力を獲得しています。例えば以下のようないわゆる川渡りパズル問題を入力として与えてみます。

お釈迦様が蛇、蟇、蜘蛛を連れて川岸にやってきました。 
こちらの川岸には小さな筏と櫂があります。
お釈迦様は筏に乗れば向こう岸まで漕いでいくことができますが、蛇、蟇、蜘蛛は自ら筏を漕ぐことができま
せん。 
筏はとても小さく、お釈迦様の片手は櫂で塞がりますから、お釈迦様と一緒に筏で渡れる生き物は一度に一匹
までのようです。
いずれかの同じ岸に蛇と蟇とを残すと、お釈迦様がいない隙に蛇は蟇を食べてしまいます。 
また、いずれかの同じ岸に蟇と蜘蛛とを残すと、お釈迦様がいない隙に蟇は蜘蛛を食べてしまいます。 
お釈迦様は三匹の生き物いずれが欠けても悲しまれます。
どのようにすればお釈迦様と三匹の生き物は無事に
向こう岸に渡ることができるでしょうか。

この問題に対して、PLaMo 2.2 Primeは以下のような出力を返しました。

この問題を解くためには、お釈迦様がいない間に蛇が蟇を食べたり、蟇が蜘蛛を食べたりすることのないよう
に注意しながら、三匹の生き物を無事に向こう岸に渡す必要があります。以下にその方法の一例を示します。

1. **最初の移動**: お釈迦様が単独で向こう岸に渡ります。
   - こちら側: 蛇、蟇、蜘蛛
   - 向こう側: お釈迦様

2. **二回目の移動**: お釈迦様が蛇を連れてこちら側に戻ります。
   - こちら側: 蛇、お釈迦様
   - 向こう側: （無人）

3. **三回目の移動**: お釈迦様が蟇を連れて向こう岸に渡ります。
   - こちら側: 蛇
   - 向こう側: お釈迦様、蟇

4. **四回目の移動**: お釈迦様が単独でこちら側に戻ります。
   - こちら側: お釈迦様、蛇
   - 向こう側: 蟇

5. **五回目の移動**: お釈迦様が蜘蛛を連れて向こう岸に渡ります。
   - こちら側: 蛇
   - 向こう側: お釈迦様、蟇、蜘蛛

6. **六回目の移動**: お釈迦様が蛇を連れてこちら側に戻ります。
   - こちら側: 蛇、お釈迦様
   - 向こう側: 蟇、蜘蛛

この方法では、蛇と蟇、蟇と蜘蛛が同じ岸に残らないように注意しながら、お釈迦様と三匹の生き物を無事に
向こう岸に渡すことができます。
この方法以外にも、別の順序で移動させる方法も考えられますが、基本的な考え方は同じです。重要なのは、
蛇と蟇、蟇と蜘蛛が同じ岸に残らないように、お釈迦様が単独で戻るタイミングを適切に選ぶことです。

1回目の移動で「こちら側」にお釈迦様がいなくなってしまうので蟇が蛇に食べられるか、蜘蛛が蟇に食べられてしまいますね。PLaMo 2.2 Primeは状況の整理と論理的な思考能力に問題があることがわかります。

一方で、PLaMo 3.0 Prime β版にこの問題を与えると以下のような出力を返しました。

**解き方のポイント**

- 「蛇–蟇」「蟇–蜘蛛」だけが **危険な組み合わせ** です。  
  つまり、**仏様がいない岸** に **蟇 と 蜘蛛 が同時にいる** ことは許されません。  
  蛇 と 蜘蛛 が一緒にいることは問題ありません。

- 船は **仏様＋１匹** しか乗れません。  
  したがって仏様は常に「危険な組み合わせができていないか」だけをチェックすれば、  
  その都度どちら側に残すかを決めればよいことになります。

- まず絶対に **仏様が岸に取り残されて蟇と蜘蛛が一緒になる** 動きはできません。  
  それを避ける最初の一手は **仏様＋蟇** を渡すことです。  
  （このとき左岸に残るのは蛇と蜘蛛だけで、危険はありません。）

以下に、**確実に全員が向こう岸へ渡る手順** を示します。  
各手番の左から右への移動と、**移動する前の状態** を併せて書くと分かりやすいです。

---

## 手順

| 手番 | 移動する組（左 → 右） | 移動後の左岸 | 移動後の右岸 | 危険チェック |
|------|----------------------|-------------|-------------|--------------|
| 0 (初期) | – | 仏・蛇・蟇・蜘蛛 | （空） | 問題なし |
| 1 | **仏＋蟇** | 蛇・蜘蛛 | 仏・蟇 | 左岸は蛇と蜘蛛だけ → OK |
| 2 | **仏** （単独で戻る） | 仏・蛇・蜘蛛 | 蟇 | 右岸は蟇だけ → OK |
| 3 | **仏＋蜘蛛** | 蛇 | 仏・蟇・蜘蛛 | 右岸は仏がいるので蟇と蜘蛛が一緒でも安全 |
| 4 | **仏＋蟇** （左へ戻す） | 仏・蟇・蛇 | 蜘蛛 | 左岸は仏がいるので蟇と蛇が一緒でも OK |
| 5 | **仏＋蛇** | 蟇 | 仏・蜘蛛・蛇 | 右岸は仏がいるので問題なし |
| 6 | **仏＋蟇** | （空） | 仏・蟇・蜘蛛・蛇 | すべて向こう岸へ。条件を満たす |

---

## なぜこの手順が成り立つか

1. **最初の一手は必ず「仏＋蟇」**  
   - もし最初に「仏＋蛇」や「仏＋蜘蛛」を渡すと、仏様が戻って左岸に **蟇＋蜘蛛** が残り、危険が生じま
     す。  
   - 「仏＋蟇」なら左岸に残るのは **蛇と蜘蛛** だけで安全です。

2. **仏様が右岸にいる間は蟇と蜘蛛が同時に右岸にいても OK**（仏様がいる＝危険が回避される）  
   - したがって、3手目で **仏＋蜘蛛** を渡しても、右岸は「仏・蟇・蜘蛛」で問題ありません。

3. **左岸に蟇と蜘蛛だけが残る瞬間は必ず仏様が右岸にいる**  
   - 手順4で **仏＋蟇** を左へ戻すと、左岸は「仏・蟇・蛇」になり、蟇と蜘蛛は別岸です。  
   - 手順5で **仏＋蛇** を渡すと、左岸は **蟇だけ**、右岸は「仏・蜘蛛・蛇」になるので、危険な組み合わせ
     はありません。

5. **最後に全員が右岸に集まれば、**  
   - 右岸は「仏・蟇・蜘蛛・蛇」すべてが同時にいるので、**仏様がいる限り** 「蟇と蜘蛛」同時にいることは
     許容されます。  

このように、**途中で仏様がいない岸に「蟇＋蜘蛛」だけが残らない** ことを常に確認すれば、必ず解くこと
ができます。

---

### まとめ

> **答え**  
> 1. 仏様＋蟇 が渡る  
> 2. 仏様が単独で戻る  
> 3. 仏様＋蜘蛛 が渡る  
> 4. 仏様＋蟇 が左へ戻る  
> 5. 仏様＋蛇 が渡る  
> 6. 仏様＋蟇 が渡る  

この手順で、**蛇・蟇・蜘蛛のいずれも欠けることなく、全員が無事に向こう岸へ渡ります**。  

（他にも同等の手順はありますが、上記が最もシンプルで分かりやすい解法です。）

「手順」のセクションで説明されている手続きは妥当で、「なぜこの手順が成り立つか」のセクションではその理由が明快に説明されています。素晴らしいですね！PLaMo 3.0 Prime β版は、この問題を正しく解いています。

ちなみに、この出力を得るためにPLaMo 3.0 Prime β版が行った思考過程をAppendixに示します。思考過程から明らかなようにPLaMo 3.0 Prime β版における思考は主に英語で行われます。これは学習データによる影響です。今後の正式版リリースに向けて思考を日本語で行うよう再訓練を施すことを検討しています。思考過程を日本語にすることでトークン数を大幅に節約できたり、英語と日本語を行き来することによる表現のブレを少なくすることが可能であると考えています。

おわりに

国産生成AI基盤モデルPLaMo 3.0 Prime β版は無償利用を前提に現在モニター企業様を募集中です。ぜひこちらからご応募ください。

PLaMo 3.0 Prime β版の開発では、PFNが保有する大規模な計算基盤を大いに活用しました。また学習データの生成には利用可能であることを個別に確認した我々のライブラリ・ソリューションのデータを適切に利用しています。我々は引き続きチップ、インフラ、基盤モデル、ライブラリ、そしてソリューションまでを一気通貫で開発・提供するPFNの垂直統合の強みを活かしてPLaMoの開発を熱烈に行っていきます。

PLaMoの開発は今回紹介した改善以外にも多岐にわたります。今後は、より長いコンテキスト長への対応、より高度なReasoning能力の獲得、実務と密接に関わった様々な領域のタスクにおける性能向上を目指します。我々はこれらの課題に情熱をもって挑戦していく仲間を募集しています。これらの仕事に興味がある方はぜひご応募よろしくお願いします。

• 大規模言語モデル 事前学習エンジニア: https://open.talentio.com/r/1/c/preferred/pages/118886 
• 大規模言語モデル 事後学習エンジニア: https://open.talentio.com/r/1/c/preferred/pages/102815 
• 大規模言語モデル VLMエンジニア: https://open.talentio.com/r/1/c/preferred/pages/118552 
• 大規模言語モデル 推論基盤エンジニア: https://open.talentio.com/r/1/c/preferred/pages/119173 
• 基盤モデルサービス開発エンジニア: https://open.talentio.com/r/1/c/preferred/pages/88373 

謝辞

PLaMo 3.0 Prime β版の開発では、これまで蓄積してきた独自データセットに加え、国立研究開発法人情報通信研究機構(NICT：エヌアイシーティー)が整備する日本語関連データセットを学習に活用しました。また、経済産業省と国立研究開発法人新エネルギー・産業技術総合開発機構(NEDO)が推進する生成AI基盤モデル開発プロジェクトGENIAC第3期の一部開発成果を事後学習に活用しています。関係機関の皆様のご支援に感謝申し上げます。

Appendix: 評価の詳細

Model Evaluation Parameters

全てのモデルはH100GPU上でvLLMを用いて推論しました。評価をなるべくフェアに行うため、PLaMo 3.0 Prime β版、Qwen3-235B-A22B-Thinking-2507、gpt-oss-120bはmax_model_lenを65,536に設定し、処理できるコンテキスト長が小さいPLaMo 2.2 Primeは32,768に設定しました。max_reasoning_tokensはPLaMo 3.0 Prime β版は12,288、Qwen3-235B-A22B-Thinking-2507、gpt-oss-120bはともに32,768に設定しました。

IFBench

HuggingFaceの公式データセットを対象に公式リポジトリをベースとした社内実装を用いて評価を行いました。5回の評価を実行しその平均値を報告しています。

JFBench 

公式リポジトリではなく社内で保持している開発版のリポジトリを用いて評価を行いました。近いうちに公式リポジトリに変更をアップストリームする予定です。制約数1,2,4,8でシード値42に対してそれぞれ200件ランダムに生成した評価用データをベンチマーク対象としています。

BFCL

BFCL v4の公式リポジトリを社内開発用にフォークしたものを用いて評価を行いました。

LongBench v2

HuggingFaceの公式データセットを対象に公式リポジトリをベースとした社内実装を用いて評価を行いました。

MedRECT

公式リポジトリを用いて評価を行いました。日本語のデータセットを評価対象としています。

医師国家試験

2024年度および2025年度の医師国家試験の問題をベンチマーク対象としています。以下のような独自の生成プロンプトに基づいて回答を生成し評価を行いました。モデルの出力はルールベースの処理を用いて回答抽出しています。

   prompt = (
        "以下の日本の医師国家試験問題に答えてください。\n\n"
        f"問題文: {question}\n\n"
        "選択肢:\n"
        f"{choices_text}\n\n"
        "回答形式:\n"
        "- 「どれか。」で終わる選択問題で数が明記されていない場合は、五者択一を意味するので選択肢を必ず"
        "1つだけ選び小文字のアルファベットで答えてください。（単数選択）\n"
        "- 「2つ選べ」「3つ選べ」などと書いてある場合に限り、指定された数だけの複数選択肢を選び、カンマ"
        "区切り（例: a, b）で答えてください。（複数選択）\n\n"
        "answer: [解答(単数/複数)]\n"
    )

lawqa_jp

公式リポジトリを用いて評価を行いました。各設問ごとにselection.jsonのsamplesを読んでコンテキストをプロンプトに付加して評価しています。

MTBench

公式リポジトリをフォークした社内開発版のリポジトリを用いて評価を行いました。5回の評価を実行しその平均値を報告しています。生成結果を評価するジャッジモデルにはgpt-4o (version: 2024-11-20)を利用しています。またReference Answerとしては公式リポジトリのものを利用しています。

Japanese MTBench

公式リポジトリをフォークした社内開発版のリポジトリを用いて評価を行いました。5回の評価を実行しその平均値を報告しています。生成結果を評価するジャッジモデルにはgpt-4oを利用しています。またReference AnswerとしてはSwallowプロジェクトによるものを利用しています。

AIME 2024

Lighteval経由で評価を行いました。一問あたり64サンプルを生成してpass@1を計算し、全ての設問で平均を計算しました。few-shot数(例示数)は0です。

GPQA-Diamond

Lighteval経由で評価を行いました。一問あたり4サンプルを生成してpass@1を計算し、全ての設問で平均を計算しました。few-shot数(例示数)は0です。

Appendix: 川渡り問題の思考過程

We need to solve classic river crossing puzzle with constraints: Buddha cannot be left with snake and 
frog together on same side (without him), nor frog and spider together on same side (without him). Boat 
can carry Buddha + one animal at a time. Need sequence.

We can treat Buddha as "I". Animals: snake (S), frog (F), spider (P). Forbidden pairs when Buddha 
absent: S+F, F+P.

Goal: move all to other side.

We need to find steps.

Classic solution: Use interleaving moves to keep safe combos.

One approach: Move frog first? But if Buddha leaves frog alone on original side with either snake or 
spider? Actually initial side has all three. If Buddha takes snake across, leaves frog and spider 
together; that's forbidden (frog would eat spider) because Buddha absent. So can't leave frog and spider 
together. So cannot take snake first or spider first? Let's test:

Start: all on left.

If Buddha takes snake across, left side has frog and spider -> forbidden. So not allowed.

If Buddha takes frog across, left side snake and spider -> allowed (snake doesn't eat spider). So okay.

If Buddha takes spider across, left side snake and frog -> forbidden (snake eats frog). Not allowed.

Thus first move must be Buddha + frog.

After crossing, left side: snake, spider. Right side: Buddha, frog.

Now we need to get snake and spider across without leaving unsafe combos.

Buddha can go back alone or with one animal.

If Buddha returns alone, left side still has snake and spider (safe). Right side has frog alone (safe). 
Then Buddha can take snake across? Let's see: If Buddha takes snake across, left side will have spider 
alone (safe). Right side will have Buddha, frog, snake. But then snake and frog together on right side 
with Buddha present, okay. After dropping snake, Buddha could go back with frog? Wait we need to get 
spider across later. But we cannot leave frog with snake on right side without Buddha? Actually after 
we bring snake across, we can leave Buddha and snake on right, frog alone on right? Wait scenario:

State A: Left: snake, spider. Right: Buddha, frog.

Buddha returns alone to left: Left: Buddha, snake, spider. Right: frog.

Now Buddha takes snake across: left: spider. right: Buddha, frog, snake. That's okay because frog and 
snake together but Buddha present. Then Buddha returns alone? He could go back alone to fetch spider. 
If Buddha returns alone, left: snake. Right: Buddha, frog, spider. That's okay (frog and spider together? 
Actually they are together on right with Buddha present; safe). Wait but frog and spider together without 
Buddha would be disaster, but Buddha is there, so fine.

Now Buddha takes spider across: left empty, right: Buddha, frog, snake, spider. All done. However need 
to check intermediate step when Buddha left frog alone on right after he returned alone? In step after 
first crossing of snake, we left Buddha on right with frog and snake, then we go back alone leaving 
frog and snake together without Buddha. That's a problem because frog and snake alone would cause frog 
to eat snake. So we cannot leave them unattended. So need to avoid that.

Thus we need to ensure when Buddha leaves a side, the animals left are safe.

Thus we need a different sequence.

Classic solution for 3 animals with constraints similar to "wolf, goat, cabbage" but with different pairs. 
Here constraints are: snake (predator of frog), frog (predator of spider). So it's like predator chain.

We can treat frog as middle predator.

Goal: avoid leaving predator with prey.

Standard solution: Use frog as shuttle? Let's attempt.

Step1: B+F cross (as earlier). Left: snake, spider (safe). Right: B, F.

Step2: B returns alone. Left: B, snake, spider. Right: F.

Now we need to move snake, but cannot leave snake with frog on right without B. So we cannot take 
snake across now because would leave frog alone on right (that's okay) but also snake would be left 
alone on left? Actually after moving snake across, left would have spider alone (safe), right would 
have B, snake, frog (frog with snake unsupervised? Actually B present, so safe). The issue is after 
dropping snake, B would need to go back to fetch spider, leaving frog alone on right? That's okay 
(frog with nothing). But snake and frog together without B? That's only when B leaves right side. 
So after B drops snake, B could stay? He can't because need to get spider. He could go back with 
snake? He could bring snake back? That would be wasteful.

Alternate: Use snake as ferry? Not possible.

Maybe we need to first move spider? But initial can't because snake+frog left.

Thus maybe we need to initially move snake? But that leaves frog+spider together unsupervised 
(danger). So impossible? Wait maybe we can use a trick: we can move snake across, then bring frog 
across, then bring snake back, then move spider, then finally return with frog? Let's test.

Start: left S,F,P ; right empty.

B+S cross. Left: F,P (danger! frog and spider together without B). So not allowed even for a moment? 
The puzzle likely assumes we cannot leave them unattended even temporarily. So step invalid.

Thus first move must be B+F.

So we must have B+F cross first.

Now we need to shuttle snake and spider without ever leaving frog with snake or spider with frog 
unattended.

We can use strategy: After B+F cross, B returns alone. Then we take snake across, leaving frog alone 
on right (fine). Then B returns with snake? That would leave snake alone on left (fine). Then take 
spider across, leaving snake alone on left (fine). Then B returns alone, left: snake. Wait need to 
get snake across as well. Hmm.

Let's try systematic search.

State representation (left side): B S F P, but B always on left when he is not crossing. Actually 
boat moves with B plus maybe one animal.

We can brute think.

Let’s denote safe left/right sets: any pair without B that is forbidden cannot exist.

Goal: all on right.

We can attempt to find sequence manually.

Try:

0: left L = {B,S,F,P}, right R = {}

1: B+F cross -> L={S,P}, R={B,F}. Safe? left S,P no forbidden (snake doesn't eat spider). Good.

2: B returns alone -> L={B,S,P}, R={F}. Safe? left has S,P safe. Good.

3: B+S cross -> L={P}, R={B,F,S}. Now left has P alone safe. Right has B with F and S. Are F and S 
together without B? No, B present, so safe.

4: B returns with S? Option: B can bring S back to left, then later take P? Let's see.

If B returns with S: L={B,P,S}, R={F}. Left has S and P together (safe). Right has F alone safe.

Now we need to get P across. Next:

5: B+P cross -> L={S}, R={B,F,P}. Left S alone safe. Right B with F,P safe.

Now need to get S across. Currently B is on right with F and P. He can go back alone to fetch S.

6: B returns alone -> L={B,S}, R={F,P}. Right side has F and P together without B -> dangerous! 
So cannot leave B there.

Thus step 5 leads to problem.

Alternative: after step3, instead of returning with S, maybe B returns alone (leaving S on right). 
Let's test.

3: after B+S cross we had L={P}, R={B,F,S}. Safe.

4: B returns alone -> L={B,P}, R={F,S}. Right side has F and S together without B -> dangerous. 
Not allowed.

Thus can't.

Alternative: after step2, instead of taking S, maybe take P? Let's try.

2: B returns alone (L={B,S,P}, R={F}).

Now take P across:

3: B+P cross -> L={S}, R={B,F,P}. Left S alone safe. Right B with F,P safe.

Now need to get S across, but same issue as before: B must go back alone leaving F,P together.

Thus not good.

Maybe we need to use a different initial move: B+F cross, then B brings frog back? That seems 
wasteful but maybe necessary.

Let's try:

B+F cross -> L={S,P}, R={B,F}
B returns with F -> L={B,S,P}, R={} (back to start). Not helpful.
Maybe we need to accept that puzzle may be unsolvable? Let's think: The constraints form a cycle 
of predator-prey. The only safe state is when predator and prey are never alone together without 
Buddha. This is similar to the classic "wolf, goat, cabbage" where the goat is prey to both. 
In that puzzle solution exists.

Our situation: snake eats frog; frog eats spider. No relation between snake and spider. 
So we have a chain.

We can perhaps treat frog as the "goat": we must never leave it with snake or spider alone. 
So frog can travel with either snake or spider but not alone with them.

Thus we can design sequence where frog is always with Buddha or with the animal that it would 
otherwise eat? Actually frog eats spider, so if frog is with spider, spider is at risk if 
Buddha absent. So we must avoid leaving them alone.

Thus frog must be either with Buddha or with snake? Snake doesn't affect spider, but frog with 
snake is okay because snake doesn't eat frog. So frog can be with snake without issue.

Thus we can use snake as carrier to keep frog safe while moving spider.

Potential sequence:

Goal: get spider across, but must avoid leaving frog with spider alone. So we can first move 
spider with Buddha, then bring frog across, etc.

Let's attempt systematic search quickly (maybe using reasoning). Use states (left side composition). 
We'll attempt to find a path.

Let’s encode safe condition: On any side without Buddha, the set must not contain both S and F, 
nor both F and P.

We start L = {B,S,F,P}.

We consider moves: B plus optional animal to other side.

We can try BFS manually small.

From start, possible moves:

B alone: L={S,F,P}, R={B}. Left side has S and F together -> unsafe. So can't.
B+S: L={F,P}, R={B,S}. Left side F,P safe. Right side B with S safe. So valid.
B+F: L={S,P}, R={B,F}. Left S,P safe. Valid.
B+P: L={S,F}, R={B,P}. Left S,F unsafe (snake eats frog). So not allowed.
Thus only two valid first moves: B+S or B+F.

We already saw B+S leads to left F,P safe but then we later had trouble.

Let's explore B+S branch fully.

State A: L={F,P}, R={B,S}. (B on right)

Now possible moves from A (B on right). Options: B can go alone back, or bring S back.

B returns alone: L={B,F,P}, R={S}. Left side has F,P safe. Right side single S safe. This is the 
same as earlier after step2 of other branch.
B brings S back: L={B,F,S,P}, R={} back to start (useless).
Thus must go B returns alone to A' = {B,F,P} left, {S} right.

Now from A', we have B on left with F and P. Options: B can take alone, F, or P to right.

Consider B+F cross: L={P}, R={B,F,S}. Check left P alone safe. Right has B with F,S safe (F and S 
together but B present). So valid.

State B: L={P}, R={B,F,S}.

Now B on right, can return alone (leaving F,S together without B -> unsafe). So cannot return alone. 
Can bring F back, or S back, or go alone? Actually B must bring someone because leaving F and S 
together unsupervised is not allowed. So options:

B+F back: L={B,P,F}, R={S}. Left has B,F,P safe? Check left without B? B present, fine. So valid.
B+S back: L={B,F,P,S}, R={} start.
Thus the only promising is B+F back.

State C: L={B,P,F}, R={S}. This is same as after step3 earlier? Actually left has all three plus B? 
Wait B is on left now, left animals B,P,F (but B is Buddha). So left side effectively has P,F (since 
B can be alone). Right side S.

Now we need to get P across. Options: B can take P to right, or F, or go alone.

If B takes P: L={F}, R={B,P,S}. Left F alone safe. Right B with P,S safe (P and S together but B 
present). So valid.

State D: L={F}, R={B,P,S}.

Now B on right with P,S. Options: B cannot return alone (P and S left alone unsafe). Can bring P back, 
S back, or go alone? Must bring someone.

If B brings P back: L={B,F,P}, R={S}. Left has B,F,P safe? Check left without B: F,P together safe 
(F and P not predator/prey). Right S alone safe.

That's state similar to C again but with B left.

If B brings S back: L={B,F,S}, R={P}. Left B,F,S safe? Check F and S together without B? F present, 
S present, B present, okay. Right P alone safe.

If B takes F? Actually B could take F across? He is on right; to take F across he'd need to go left 
first. So not.

Now from state where right side has P alone (state D), we could consider moving F across next? But B is 
on right, can't take F. So need to get B back to left to take F.

Thus from D, B must return with either P or S. Let's try B+S back.

State E: L={B,F,S}, R={P}. Now B left with F,S. Need to get F across.

Options: B+F cross -> L={S}, R={B,F,P}. Left S alone safe. Right B with F,P safe (F,P together but B 
present). That's State D again but mirrored.

Seems we are cycling.

Goal is to have all on right: {B,S,F,P}. Need to move remaining left animals across without violating.

Observation: The problem is that when B is on right, left side often has F and P together causing 
violation unless B is there. So we need a move that leaves left side safe without B. That means we 
must never have a side where F and P are together without B. So final step must bring last animal 
such that left side empty or only safe combos.

Thus we need to arrange that when B is on left, the left side may contain F and P? Not allowed. So 
left side cannot have both F and P at any time without B. Therefore we must move them such that they 
never coexist on a side without B.

Thus we must move them one at a time with B accompanying.

But there are three animals: snake, frog, spider. The dangerous pairs are (F,S) and (S,F). Actually 
both same pair. So only pair is F and S. So as long as they are not left alone together, we are fine. 
Snake and spider together are fine.

Thus we can treat the problem as we cannot have F and S on same side without B. So they must always 
be separated or with B.

Thus we can try to shuttle them such that B always stays with whichever of them is on a side with 
the others.

Sequence attempt: Use snake as carrier to keep frog safe.

Plan: Move frog across with B (B+F). Then B returns alone? That would leave frog alone on right, okay. 
Then move snake across (B+S). But before moving snake, need B on left. So B must go back with frog? 
Actually after B returns alone, right side has frog alone, left side has snake,spider,B.

Now B+ snake cross -> left side spider alone, right side B, snake, frog (frog with snake together but 
B present, okay). Now need to get spider across. But B is on right with frog and snake. If we take B 
alone back, left side spider alone (fine), right side frog and snake together without B -> violation. 
So cannot take B alone. Could take frog back? That would leave snake alone on right (fine) and bring 
frog left with spider (frog and spider together, violation). So not good. Could take snake back? Leaves 
frog alone on right (fine) and snake left with spider (snake and spider together fine). Then B is on left? 
Wait after moving snake back, B would be on left? Actually B is on right initially. To take snake back, 
B must also go back (since boat has B and one animal). So moving B+ snake back results in left side B, 
snake, spider (snake and spider fine), right side frog alone. That's safe. Now we could take B+frog across, 
but then left side snake alone (fine), right side B,frog together (but spider not there). However need 
snake to cross as well. After that, B is on right with frog, can return alone? That would leave frog alone 
on right (fine). Then B can take snake across. So seems possible.

Let's lay out stepwise:

Start L: B,S,F,P. Goal R: all.

B+F cross. (L: S,P ; R: B,F) (safe)
B returns alone. (L: B,S,P ; R: F) (F alone safe)
B+S cross. (L: P ; R: B,S,F) (F and S together but B present, ok)
Now R has B,F,S. L has P.

B+S return. (L: B,S,P ; R: F) (check: L has B with S,P, S and P fine; R has F alone)
Now L: B,S,P ; R: F.

B+F cross. (L: S,P ; R: B,F) (Now L has S and P together, safe; R has B,F)
Now we need to move S and P across.

Current: L: S,P ; R: B,F.

B returns alone? Not allowed because L has S,P together without B -> violation. So cannot.
Instead, B could bring P across? But B is on right. To bring P, need to go left first.

Option: B+F return? That would leave R with F alone (safe) and L with B,S,P (snake and spider 
together fine). So step6: B+F return.

State after 6: L: B,S,P ; R: F.

Now same as after step4. Cycle again.

We need a different approach after step3.

Maybe after step3 (L: P ; R: B,S,F), instead of returning S, we could take P across? But B is 
on right, need to get to left. Could bring B+S back? That leaves L: S,P ; R: F (violation L). 
So no.

Thus maybe initial move should be B+F? Let's try alternative strategy.

Start.

B+F cross -> L: S,P ; R: B,F.
B returns alone? That leaves R: F alone safe. L: B,S,P.
Now we have snake and spider together left with B present, okay.

But maybe we should take spider across next? B is left, so can take P.

B+P cross -> L: S ; R: B,F,P. (F and P together but B present, ok)
Now left has snake alone, right has B,F,P.

Now need snake across. B is on right. If we take B alone back, left would be S alone (fine), 
right would be F,P together without B -> violation. So cannot.

If B takes F back? Then right would have P alone (fine) and left would have B,F,S. Check left: 
B with F,S, frog eats spider? F and P not together, ok. Right: P alone fine.

Let's try:

B+F return -> L: B,F,S ; R: P.
Now left has B,F,S (frog and spider together but B present, fine). Right has P alone.

Now we can get P across:

B+P cross -> L: B,F,S ; R: P? Wait B already on left, crossing with P moves to right, but we 
already have P on right, so after crossing, both B and P on right, left has F,S.
State: L: F,S ; R: B,P.

Now left has F,S together without B -> violation! So can't.

Thus step4 not good.

Maybe after step3, we should take B+S back (instead of B+F). Let's test.

After step3 (L:S ; R:B,F,P). Move B+S back:

B+S return -> L: B,S ; R: F,P.
Now right side has F,P together without B -> violation. So not allowed.

Thus seems we are stuck.

Maybe puzzle is unsolvable? Let's consider parity: Since only problematic pair is frog and spider, 
we must never have them separated by Buddha. The boat can transport only one other. Equivalent to 
needing to move frog and spider such that they are always together or with Buddha.

We could try to keep them together as a pair, transport them together? But boat can only take one 
animal besides Buddha. So cannot transport both at same time. So they must cross separately, each 
time Buddha with them, and after one crosses, the other remains on original side with Buddha? 
Actually after first crosses, Buddha is on other side with that animal, leaving other alone on 
original side. That's okay because the other is not with frog/spider. The other animal could be 
snake, which is okay. So after moving frog across, frog and Buddha on right, snake alone left, spider 
alone left? Wait both frog and spider cannot stay together alone. So we need to move them one at a 
time and ensure they are never left alone together.

Thus we need to interleave snake moves to keep them apart.

Let's attempt systematic with state graph maybe quickly mental.

Goal state: all right.

We can try to use algorithmic reasoning: treat frog as needing escort when crossing; after crossing, 
frog must be accompanied on right side by Buddha until snake or spider moves to right to separate them? 
Actually once frog is on right, if spider later moves right, they'd be together without Buddha (since 
Buddha may need to go left). So to avoid that, after frog arrives, we must bring Buddha back before 
spider arrives, or bring snake to right to separate? But snake doesn't affect frog-spider conflict. 
So only way is to ensure Buddha is always present when frog and spider are on same side. Thus after 
frog arrives, Buddha must stay on right until spider also arrives, but then they'd be together without 
Buddha? Actually if both frog and spider are on right and Buddha also on right, that's okay. So we can 
have them all together with Buddha. So final state all right is okay. So the only problematic moment is 
when Buddha leaves a side where frog and spider are together. So we must schedule such that whenever 
Buddha is not on a side, that side does not have both frog and spider.

Thus we can try: Move frog across, Buddha stays (so right side has B,F). Left side has S,P safe. Then 
move spider across while Buddha still on right (B,F,P). All together safe. Then move snake across maybe 
later. At that point Buddha can return alone? If Buddha returns alone, right side would have F,P together 
without B -> violation. So after moving spider, we must not leave Buddha. So maybe after moving spider, 
we bring snake across with Buddha, then all on right, and then we are done; Buddha already on right, 
no need to return. So final step is moving snake with Buddha.

But can we get snake across while Buddha and frog and spider are on right? Snake is on left. Boat is on 
right (since after moving spider, boat is on right). Buddha can take snake across alone (with boat) while 
staying on right? He would need to be on left to board. So boat needs to go to left. So we need to have 
Buddha on left with snake to cross, then come back? That would leave right side with frog and spider 
without Buddha -> violation. So we need to avoid that.

Thus perhaps order different: Move snake first, then it is safe to move frog and spider together without 
conflict? But snake doesn't affect.

Let's try: B+S cross first. Then B returns alone? left side has S plus others, right side has B with S? 
Actually after crossing, left side has F,P ; right has B,S. B could return alone leaving left side F,P 
together (violation). So can't.

Thus initial move cannot be S because then B must return leaving frog and spider together. So initial move 
must be F? Let's test: B+F cross, left S,P safe. B returns alone? left would have S,P together (safe), 
right frog alone (safe). Yes because frog alone doesn't cause problem. So initial move can be B+F, B 
returns alone is okay.

Thus we can start with B+F across, then B returns alone (as earlier). That leaves left: S,P ; right: F. Good.

Now we need to bring snake across, then bring spider, then finally get frog across with Buddha? But frog 
is alone on right, okay. Let's continue.

State after step2: L: S,P ; R: F.

Now we can take snake across with Buddha (who is on left after returning). Wait Buddha is on left (since 
he returned). So step3: B+S cross -> L: P ; R: B,F,S.

Now right side has B,F,S (frog and snake together but B present, okay). Left side has P alone.

Now we need to move spider across. If we take B+P across, left becomes empty, right has B,F,S,P all together 
with B present, okay. But boat ends on right with Buddha. That's final! However we need to consider that 
after moving B+P, left side empty, right side all. No violation because any side with frog and spider also 
has Buddha. So this seems successful.

But we must check step after step3: left side P alone, right side B,F,S. Boat is on right (since B crossed). 
To move B+P, B must be on left. Actually B is on right, P is on left. Boat is on right. To take P across, 
boat must go back first (someone must row). The only rowers are Buddha and animals. Could have Buddha row 
back alone, or with one animal. If Buddha rows back alone, that would leave right side with F,S together 
without Buddha -> violation. So cannot. Therefore we cannot take P across directly after step3. So need to 
get another animal to bring boat back, perhaps snake can bring boat back? Let's see: after step3, right side 
has B and S. Left side has P. If S rows back (with B?), B must stay? Actually B could stay on right, S could 
go back alone? Then boat moves left with S, leaving right side with B alone (fine). Left side then has P and S. 
Are P and S together without Buddha? Yes, they are together left side with Buddha absent (B on right). That's 
violation (frog not present, but snake and spider together is okay, only problematic pair is frog-spider). 
So okay. So S can go alone back, leaving B alone on right.

Now left side has P,S. Buddha on right.

Now we can take P across with Buddha? But Buddha is on right, can't. So we need to bring Buddha to left. Could 
have B (snake) bring boat back with Buddha? Not possible.

Thus seems stuck.

Maybe after step3, instead of moving B+S, we could bring B+F back? Let's explore alternative path.

Given complexity, perhaps puzzle has solution: Sequence: (1) Buddha + frog cross; (2) Buddha returns alone; 
(3) Buddha + spider cross; (4) Buddha + frog return; (5) Buddha + snake cross; (6) Buddha + frog cross. 
Need check violations.

Let's test:

Start L: S,F,P ; R: empty.

B+F cross -> L: S,P ; R: B,F. (ok)
B returns alone -> L: B,S,P ; R: F. (frog alone right ok)
B+S? Actually step says B+ spider cross, but B is on left with S,P. Boat left. Take B+P cross 
-> L: S ; R: B,F,P. 
Check left S alone ok. Right has B with F,P ok.
B+F return -> B takes F back to left? Boat right. Move B+F left -> L: B,F,S ; R: P. Check right 
P alone ok. Left has B,F,S: frog and spider together? They are together but B present, so ok.
B+S cross -> B takes S across? Boat left. Take B+S -> L: F ; R: B,P,S. Check left F alone ok. 
Right has B with P,S ok.
B+F cross -> B takes F across? Boat right. Take B+F -> L: empty ; R: B,F,P,S. All together, ok.
Now check step 4: after step3, right side had B,F,P. B present, okay. Then B+F return left: 
left B,F,S, right P. Right P alone fine. Left B,F,S fine.

Step5: B+S cross left->right: left F alone, right B,P,S fine.

Step6 final ok.

We need to verify that at any point we never had B absent with frog and spider together. 
Let's scan:

After step1: left S,P (no frog) ok. right B,F (frog with B) ok.
After step2: left B,S,P (frog with B) ok. right F alone.
After step3: left S alone. right B,F,P (frog with B) ok.
After step4: left B,F,S (frog with B) ok. right P alone.
After step5: left F alone. right B,P,S (frog not with spider) ok.
After step6: all right.
All good! So this sequence works.

Thus answer: Provide steps and explanation.

We can present in Japanese.