Struct Var 

pub struct Var<'t> { /* private fields */ }

テープ上の 1 ノードを指す追跡対象値。値そのものではなく NodeId + テープへの共有参照を保持し、演算のたびにテープへ新しいノードを 追加する（docs/public-api-design.md §3.1）。

クロステープ安全性: ライフタイム 't の一致は同一 Tape を 指す証明にはならない（同一スコープに複数の Tape が存在する場合、 それぞれの Var<'t> は同一の 't を持ちうる）。そのため二項演算 （matmul/add/mul/mse_loss）は入口で self.tape.id と相手側 Var が保持する TapeId の一致を実行時検査し、不一致なら AutodiffError::TapeMismatch を返す。

Implementations

impl<'t> Var<'t>

pub fn value(&self) -> Ref<'_, Tensor<f32>>

追跡を外し、現在の値を非追跡の Tensor<f32> の借用として取り出す。

TASK-12.1d（#164）: 対象ノードが未実体化（elementwise の遅延 グラフの一部）であれば materialize_non_fallible（層 2。融合を 試み、失敗すれば ops の per-op メソッド → eval.rs の順に必ず 値を返す）経由で実体化する。matmul/sum/max・Tape::backward が使う層 1（crate::tape::materialize_fallible）とは異なる エラー処理契約を持つ（docs/fusion-graph-design.md §3.5.3）。

借用注意: この Ref を保持したまま、同じ Tape に対して borrow_mut() を要する演算（matmul/add 等のノード追加）を 呼ぶと RefCell の二重可変借用で実行時 panic になる。値をその場 の参照ではなく所有値として持ち出したい場合は to_tensor() を 使うこと（docs/public-api-design.md §3.1）。

pub fn to_tensor(&self) -> Tensor<f32>

value() の所有値版。Tensor<f32> へ複製して返すため Ref を 持ち越さず、直後に同じ Tape へノード追加演算を呼んでも借用 エラー・panic が起きない。

pub fn host_view(&self) -> VarHostView

ホスト可視の値を借用で読み出す（イシュー #1335・docs/public-api- design.md §3.1「VarHostView」）。

P1 是正（codex-review 指摘・イシュー #1335）: 当初実装は Tape の RefCell 借用（Ref<'_, [f32]>）をそのまま VarHostView へ持ち越しており、host_view() を保持したまま 同じ Tape へノード追加演算（add/matmul 等の push_lazy）を 呼ぶと borrow_mut() が実行時 panic した（本番経路 panic 禁止・ .claude/rules/coding-rust.md 違反）。value() の既存制約と 同型ではあるが、新規公開 API がその制約をそのまま持ち込む理由には ならないため、RefCell 借用を関数内に閉じ込める形へ是正した。

Tensor<f32> は内部 storage: Arc<Storage<T>> を Arc 共有する 値型（tensor.rs モジュール冒頭コメント「Clone は Arc の ポインタ複製のみで安価」参照）であるため、materialize_non_fallible が返す &Tensor<f32>（Tape の RefCell 借用が生存中のみ有効） を Tensor::contiguous()（contiguous な場合は内部で self.clone() する安価な Arc 複製、非 contiguous な場合のみ 1 回実体化）へ 通してから所有値として持ち出せば、いずれの分岐でもデータの 追加コピーなしに RefCell 借用（nodes）をこの関数のスコープ内 で確実に解放できる。返す VarHostView は Tape の借用を一切 保持しないため、生存中に同じ Var／Tape への他の演算を呼んでも panic しない。

pub fn detach(&self) -> Result<Var<'t>, AutodiffError>

追跡を切り離し、現在の値を requires_grad == false の新しい 葉ノードとして同じ Tape へ登録する（イシュー #1748。PyTorch Tensor.detach() 相当。設計は docs/ autodiff-nograd-leaf-dinput-skip-decision.md §5「案 B」）。

専用 Op を追加しない設計: 「detach された Var」を 「requires_grad == false の通常の葉ノード」として表現する （Tape::var_no_grad と実体を共有する）。専用 Op::Detach variant を追加する案は、前方伝播（Op::for_each_input の網羅 match）・is_checkpoint_eligible・grad::vjp の網羅 match に 3 箇所以上の更新を要するのに対し、本 issue が満たすべき契約 （値を共有しつつ勾配経路を切る）は既存の葉ノード機構で過不足 なく表現できるため採用しなかった。

値の共有: Tensor<f32> は内部 storage: Arc<Storage<T>> を 共有する値型（immutable）のため、新しい葉ノードへ渡す materialize_fallible の戻り値の .clone() は Arc のポインタ 複製のみで実データのコピーは発生しない（PyTorch の detach() が storage を共有するのと同型）。

副作用: 対象がまだ実体化されていない lazy elementwise 連鎖・ view ノードの場合、本メソッド呼び出し時点でその実体化が走る （materialize_fallible 経由）。また checkpoint 解放済み （イシュー #1624）で再計算に失敗（poison）した値を detach する と Err を返す（stale／不正な値を新しい葉へ複製しない fail-closed 方針）。

pub fn device(&self) -> Device

この Var が属する Tape のデバイス（イシュー #1614）。 Tape::device()（self.tape.ops.device() への委譲）をそのまま 返す。

pub fn to(&self, device: Device) -> Result<Var<'t>, AutodiffError>

PyTorch Tensor.to(device) 相当の同一デバイス検査（イシュー #1614）。Var は所属する 1 つの Tape（＝1 デバイス）に束縛 されており（本ファイル冒頭「クロステープ安全性」）、同一テープ 内でデバイスを差し替える演算は表現できない。そのため本メソッドは 実際に値を転送する変換ではなく、要求先デバイスが現在のデバイス と一致するかを検査する fail-fast の入口として設計している:

• device == self.device() の場合: 恒等（*self をそのまま 返す。Var: Copy のためテープへ新規ノードを追加しない）。
• 不一致の場合: AutodiffError::DeviceMismatch。黙って別 デバイスへフォールバックしたり、暗黙にクロステープ複製（勾配 経路が切れる）したりしない。

別デバイスへ実際に値を転送したい場合は Self::to_tape（もしくは facade Tape::transfer）を使うこと——to_tape は新しい Tape 上へ値を複製した葉ノードとして登録するため、テープをまたぐ 明示的な操作であることが型シグネチャ（戻り値のライフタイムが 変わる）からも分かる。

pub fn to_tape<'u>(&self, target: &'u Tape) -> Result<Var<'u>, AutodiffError>

この Var の値を、別の Tape（target。同一デバイスでもよい） 上へ新しい葉ノードとして転送する（イシュー #1614。facade Tape::transfer の実体）。

target が同一 Tape の場合は恒等（Var::detach と異なり 追跡は切り離さない——同一テープへの「転送」は no-op として 扱う）。この判定は self.tape.nodes の借用（materialize_ fallible が要る Ref）より前に行う必要がある——後回しに すると、同一テープの場合に不変借用が生きたまま target. push_leaf（borrow_mut）を呼ぶことになり RefCell の二重 可変借用で実行時 panic になる（早期 return により到達不能に する）。

別テープの場合は crate::tape::materialize_fallible （Var::detach と同じ層 1 の実体化経路。lazy elementwise 連鎖・ view ノードはここで確定し、checkpoint 解放済みで再計算に失敗 した poison 値は Err で fail-closed に拒否する）で転送元 デバイス上の値を取り出し、Tensor<f32> の Arc 共有複製 （実データコピーなし）を target.push_leaf で新しい葉として 登録する。

数値契約: 転送は算術を含まないホスト値の受け渡しのため、 転送元で実体化された値と転送後の葉の値は bit 完全一致する。 勾配契約: 勾配はテープをまたがない（Var::detach／Tape:: var_no_grad と同じ「非微分境界」）。転送先では通常の葉として requires_grad()（転送元の値を引き継ぐ）に従って勾配を受け取る ——転送元 Var 自身の勾配経路には一切影響しない。reset 契約: 転送先の Tape で既に非葉ノードが積まれている場合、 この葉は以後の crate::tape::Tape::reset で truncate される （既存 Tape::var と同じ挙動）。

pub fn matmul(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

matmul（rank≥2。バッチ次元は NumPy 互換ブロードキャスト。 docs/public-api-design.md §3.2・spec REQ-9 2026-09-12 追記 Tier 1「バッチ行列積」・docs/compat-api-scope.md §1.2。 イシュー #1715 でバッチ次元対応へ拡張。rank 2 同士は従来どおり ops.gemm を呼ぶため既存の bit 一致契約〈tape_matmul_cpu_bit_exact.rs・ repack カウンタテスト〉は不変）。

TASK-12.1d（#164）: 非 elementwise のため常に実体化済みで 返る（push_eager）。実行は eval.rs 直接呼び出しから matmul_forward（BackendOps 経由。rank 2 は ops.gemm・ rank≥3 を含む場合は ops.gemm_batched へ分岐）へ置き換えた （TASK-1.9「backend 経由実行への置き換え」・設計書 §3.5.2）。 入力が elementwise の遅延グラフであった場合は materialize_fallible（層 1）で自身の実行の一部として実体化 する。

pub fn matmul_checksum( &self, other: &Var<'t>, readout: ChecksumReadout, ) -> Result<GemmChecksum, AutodiffError>

C = self @ other を計算しつつ、C の全要素和（checksum）を バックエンド側の f64 reduction（BackendOps::gemm_checksum）で 求める（イシュー #1339）。framework-compare の gemm 計測窓が毎 反復行っていた「D2H → ホスト f64 逐次和」の 2 段を、GPU バックエンドでは「checksum（8 バイト）のみ読み戻す」経路へ置き 換えるための入口（docs/perf/device-checksum-readback-ab.md）。

Var::matmul との相違（tape への非記録）: 本メソッドは self.tape.push_eager を呼ばず、戻り値の GemmChecksum は tape ノードを持たない生の計算結果として返す（backward の対象外。 ベンチハーネスの計測専用入口という位置づけであり、学習経路 （Var::matmul チェーン）とは独立している）。readout が ChecksumReadout::ChecksumOnly のときバックエンド実装は C をホストへ download しない契約（BackendOps::gemm_checksum doc 参照）。

検証手順は matmul と同じ「①クロステープ検査 → ②shape 検査 → ③入力実体化」までを行い、④のみ ops().gemm ではなく ops().gemm_checksum を呼ぶ。既定実装（CUDA／Metal は本イシュー 時点で未オーバーライド）が返す BackendError::Unsupported は そのまま呼び出し元（framework-compare ハーネス）へ伝播する （判定迂回経路を作らない。.claude/rules/security.md A08）。

pub fn add(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

bias broadcast を含む要素ごとの加算（docs/public-api-design.md §3.2）。

TASK-12.1d（#164）: elementwise 5 演算の 1 つ。shape 検証 （①クロステープ検査・②shape 検査）のみ即時実行し、値計算 （③）は実体化境界まで遅延させる（push_lazy。Ok を返すことは 「shape が妥当でノードが記録された」ことのみを意味し「加算が 計算済み」であることを意味しない。設計書 §3.5.1）。

連鎖長上限（#404・設計書 §3.5.4）: push_lazy を呼ぶ前に Tape::pre_materialize_for_binary_merge で fan-in 事前実体化を 行う（2 本の未実体化枝を合流させた結果が単独で上限を超えるなら 大きい方の枝を先に実体化する。codex-review PR #406 の P1 是正。 push 後の自己実体化だけでは fan-in を防げないため必須）。続けて push_lazy が返す at_limit が true（新規ノードの lazy_chain_size が MAX_FUSED_CHAIN_LEN に到達）の場合、層 1 （materialize_fallible）でその場実体化する。いずれの実体化 も発生した場合、Ok の意味は「shape が妥当でノードが記録され かつバックエンド実行が成功した」へ拡張される（同じ層 1 契約 を持つ matmul/sum/max と同型の Ok 意味）。実体化失敗は （事前実体化・push 後の自己実体化のいずれも）? でそのまま伝播 する。

pub fn mul(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの乗算。elementwise 5 演算の 1 つ （add と同じ遅延契約・fan-in 事前実体化契約・連鎖長上限での 自己実体化契約。Ok の意味の拡張も add と同型。 TASK-12.1d・#164・#404・codex-review PR #406）。

pub fn log(&self) -> Result<Var<'t>, AutodiffError>

自然対数 ln(x)。ScalarUnaryOp::Log への薄い委譲 （Var::scalar_unary 参照。イシュー #1711・親 #1593・#1592）。 定義域外（x <= 0）は IEEE のまま（x == 0 は -inf・ x < 0 は NaN。panic しない）。導関数は 1/x （eval::scalar::unary_grad_factor）。

pub fn log2(&self) -> Result<Var<'t>, AutodiffError>

底 2 の対数 log2(x)。数値規約は Var::log と同じ （定義域外は IEEE のまま）。導関数は 1/(x·ln2)。

pub fn log10(&self) -> Result<Var<'t>, AutodiffError>

底 10 の対数 log10(x)。数値規約は Var::log と同じ （定義域外は IEEE のまま）。導関数は 1/(x·ln10)。

pub fn sin(&self) -> Result<Var<'t>, AutodiffError>

正弦 sin(x)。ScalarUnaryOp::Sin への薄い委譲。導関数は cos(x)（eval::scalar::unary_grad_factor）。

pub fn cos(&self) -> Result<Var<'t>, AutodiffError>

余弦 cos(x)。導関数は -sin(x)。

pub fn tan(&self) -> Result<Var<'t>, AutodiffError>

正接 tan(x)。極（x = π/2 + kπ 近傍）でのマスクは行わず IEEE のまま（inf／NaN が伝播しうる）。導関数は 1/cos(x)^2。

pub fn abs(&self) -> Result<Var<'t>, AutodiffError>

絶対値 |x|。劣勾配は x == 0 で 0（sign(0) = 0。 ScalarUnaryOp::Abs doc・eval::scalar::unary_grad_factor 参照）。

pub fn neg(&self) -> Result<Var<'t>, AutodiffError>

符号反転 -x。-0.0 の符号ビット反転を含め IEEE のまま。 導関数は定数 -1。

pub fn silu(&self) -> Result<Var<'t>, AutodiffError>

SiLU／Swish（x * sigmoid(x)。PyTorch torch.nn.functional.silu 相当）。イシュー #1714（親 #1595）。

Var::scalar_unary（ScalarUnaryOp::Silu）への薄い委譲 （sqrt／log と同型——eager 実体化契約により Result を返す）。 導関数は fandhe_ai_tensor_core::scalar_op::silu_grad （eval::scalar::unary_grad_factor）。CUDA／Metal は超越関数 （exp）を含むため REQ-2 統一複合判定（bit 同一は主張しない）。

pub fn hardswish(&self) -> Result<Var<'t>, AutodiffError>

Hardswish（x * clamp(x + 3, 0, 6) / 6。PyTorch torch.nn.functional.hardswish 相当）。イシュー #1714 （親 #1595）。

Var::scalar_unary（ScalarUnaryOp::Hardswish）への薄い委譲。 選択・算術のみのため CUDA／Metal ともホスト f32 演算と bit 同一になる想定（kernels_scalar_op.rs／scalar_op_source.rs モジュール doc 参照）。導関数は fandhe_ai_tensor_core::scalar_op::hardswish_grad。

pub fn leaky_relu(&self, negative_slope: f32) -> Result<Var<'t>, AutodiffError>

Leaky ReLU（x >= 0 なら x、それ以外は negative_slope * x。 PyTorch torch.nn.functional.leaky_relu 相当）。イシュー #1714 （親 #1595）。

Var::scalar_unary（ScalarUnaryOp::LeakyRelu）への薄い委譲。 negative_slope は検証せず IEEE のまま伝播する（NaN を渡せば NaN が出る。PyTorch と同様）。選択・乗算のみのため bit 同一に なる想定。導関数は x >= 0 で 1、それ以外は negative_slope。

pub fn elu(&self, alpha: f32) -> Result<Var<'t>, AutodiffError>

ELU（x > 0 なら x、それ以外は alpha * (exp(x) - 1)。 PyTorch torch.nn.functional.elu 相当）。イシュー #1714 （親 #1595）。

Var::scalar_unary（ScalarUnaryOp::Elu）への薄い委譲。 alpha は検証せず IEEE のまま伝播する。CUDA／Metal は超越関数 （expm1f／metal::precise::exp）を含むため REQ-2 統一複合 判定のみ（Metal の expm1 非対応・数値誤差は scalar_op_source.rs モジュール doc「Elu の expm1 非対応」 参照）。導関数は x > 0 で 1、それ以外は alpha * exp(x)。

pub fn sub(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの減算（self − other。PyTorch torch.sub／- 演算子相当）。イシュー #1710（親 #1593）。

Var::scalar_binary（ScalarBinaryOp::Sub）への薄い委譲 （add／mul と同じ NumPy 互換ブロードキャスト・eager 実体化 契約。docs/scalar-op-dispatch-design.md §7）。facade は crates/autodiff::Var を再エクスポートするのみで新規公開面は 追加しない（docs/compat-api-scope.md §5「Tier 1／Tier 2 列挙 済み機能は再適用不要」）。

pub fn div(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの除算（self ÷ other。PyTorch torch.div／/ 演算子相当）。イシュー #1710（親 #1593）。

Var::scalar_binary（ScalarBinaryOp::Div）への薄い委譲。 数値規約（設計 §7 を変更せず踏襲）: IEEE 754 のまま （0 除算は inf／NaN を返し panic しない）。db = -(a/b)/b の 0 除算・overflow・underflow 耐性は #1634／#1686 の是正済みホスト参照実装（eval::scalar::binary_partials）に 従う。

pub fn pow(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの冪乗（self.powf(other)。PyTorch torch.pow／** 演算子相当。Var × Var の 2 項演算のみで、 スカラー指数版〈ScalarUnaryOp::PowScalar〉は CUDA／Metal カーネル未実装のため本メソッドの対象外。入口は crate::scalar_unary_ops::pow_scalar〈イシュー #2145〉）。 イシュー #1710（親 #1593）。

Var::scalar_binary（ScalarBinaryOp::Pow）への薄い委譲。 数値規約（設計 §7）: da = b·a^(b−1)・db = y·ln(a) （a == 0 または b == 0 は #1686 是正によりマスクされ勾配 0。 a < 0 かつ b が非整数のとき forward は IEEE NaN を返す PyTorch 同様の定義域規約）。

pub fn sqrt(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの平方根（PyTorch torch.sqrt 相当）。イシュー #1710 （親 #1593）。

Var::scalar_unary（ScalarUnaryOp::Sqrt）への薄い委譲 （relu／exp／tanh と異なり Result を返す——scalar_unary の eager 実体化契約〈①層 1 実体化 → ②バックエンド dispatch → ③push_eager〉が型付きエラーを返しうるため。where_cond／ softmax／add／mul と同型）。数値規約（設計 §7）: 定義域 外（x < 0）は IEEE NaN を返し panic しない（PyTorch torch.sqrt と同じ）。導関数は 0.5 / y（eval::scalar:: unary_grad_factor）。

pub fn clamp(&self, min: f32, max: f32) -> Result<Var<'t>, AutodiffError>

要素ごとの範囲制限（PyTorch torch.clamp 相当）。イシュー #1712 （親 #1593）。

Var::scalar_unary（ScalarUnaryOp::Clamp）への薄い委譲。 数値規約（eval::scalar::unary_grad_factor を変更せず踏襲）: 範囲内（境界値を含む）は勾配係数 1・範囲外は 0。NaN 入力は forward がそのまま NaN を伝播し勾配は 0。min > max は （PyTorch と同じく）常に max を返す定数関数として扱われ、 勾配は常に 0（panic しない）。

pub fn gt(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの大なり比較（self > other。 PyTorch torch.gt／> 演算子相当）。イシュー #1712（親 #1593）。

比較演算 6 種（gt／ge／lt／le／eq／ne）は共通の出力・ 勾配規約を持つ: 出力は f32 の 0.0／1.0（厳密な Tensor<bool> 出力版は fandhe_ai_autodiff::bool_ops::gt_bool 等〈イシュー #2141。Var::gt_bool 等の委譲メソッドとして #2510 で facade 公開済み〉 が本メソッドとは独立に提供する。docs/scalar-op-dispatch-design.md §3.2）。IEEE 754 準拠の比較（NaN を含む比較は eq を含め常に 偽・ne のみ真）。VJP は両入力とも常にゼロ勾配（比較演算は 局所的に階段関数のため微分不可能。eval::scalar::binary_partials が (0.0, 0.0) を返す設計を grad.rs::vjp がそのまま Some として伝播——寄与を省略しない）。add／mul と同じ NumPy 互換ブロードキャスト。

pub fn ge(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの以上比較（self >= other。 PyTorch torch.ge 相当）。数値規約は Var::gt を参照。 イシュー #1712（親 #1593）。

pub fn lt(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの小なり比較（self < other。 PyTorch torch.lt 相当）。数値規約は Var::gt を参照。 イシュー #1712（親 #1593）。

pub fn le(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの以下比較（self <= other。 PyTorch torch.le 相当）。数値規約は Var::gt を参照。 イシュー #1712（親 #1593）。

pub fn eq(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの等価比較（self == other。 PyTorch torch.eq 相当）。数値規約は Var::gt を参照（NaN 同士は偽）。イシュー #1712（親 #1593）。

pub fn ne(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

ブロードキャスト付き要素ごとの非等価比較（self != other。 PyTorch torch.ne 相当）。数値規約は Var::gt を参照（NaN が絡む比較は常に真）。イシュー #1712（親 #1593）。

pub fn gt_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの大なり（self > other）比較の bool 出力版 （PyTorch torch.gt 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::gt_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::gt とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn ge_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの以上（self >= other）比較の bool 出力版 （PyTorch torch.ge 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::ge_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::ge とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn lt_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの小なり（self < other）比較の bool 出力版 （PyTorch torch.lt 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::lt_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::lt とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn le_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの以下（self <= other）比較の bool 出力版 （PyTorch torch.le 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::le_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::le とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn eq_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの等価（self == other）比較の bool 出力版 （PyTorch torch.eq 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::eq_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::eq とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn ne_bool(&self, other: &Var<'t>) -> Result<Tensor<bool>, AutodiffError>

ブロードキャスト付き要素ごとの非等価（self != other）比較の bool 出力版 （PyTorch torch.ne 相当。厳密な Tensor<bool> を返す）。

crate::bool_ops::ne_bool への薄い委譲（イシュー #2141 で実装・#2510 で facade 公開。docs/autodiff-bool-ops-exposure-decision.md §6）。 非微分・tape 非記録で、返す Tensor<bool> は tape から切り離される （f32 マスクを Var で返す Var::ne とは独立）。IEEE 754 準拠 （NaN を含む比較は ne のみ真・-0.0 == +0.0）。結果は Var::where_cond／Var::masked_fill の条件へそのまま渡せる。 other が別 tape なら TapeMismatch、ブロードキャスト不能なら shape エラー。

pub fn masked_select( &self, mask: &Tensor<bool>, ) -> Result<Tensor<f32>, AutodiffError>

bool マスクで self の要素を row-major 順に選び rank 1 の Tensor<f32> で返す（PyTorch torch.masked_select 相当）。

crate::bool_ops::masked_select への薄い委譲（イシュー #2141 で実装・ #2510 で facade 公開）。PyTorch と異なり非微分（tape 非記録・ detached。微分可能版は決定記録 §6 項目 2 の別イシュー）。マスクは self と共通形状へ相互にブロードキャストされる（broadcast_shape。 マスク側の次元が大きければ self も拡張されて選択対象になる）。 全て偽なら shape [0] を返す。選ばれた要素の NaN は bit 保存される。

pub fn gelu(&self) -> Result<Var<'t>, AutodiffError>

GELU（誤差関数版。PyTorch F.gelu(x, approximate='none') 相当）: 0.5 * x * (1 + erf(x / sqrt(2)))。イシュー #1713 （親 #1595）。

Var::scalar_unary（ScalarUnaryOp::Gelu）への薄い委譲 （sqrt と同型）。数値規約: erf は依存追加不可 （.claude/rules/deps-policy.md）のため f64 精度の自作近似 （Abramowitz–Stegun 7.1.26。scalar_op.rs::erf_f64）を使う。 導関数は Φ(x) + x·φ(x)（eval::scalar::unary_grad_factor・ scalar_op::gelu_erf_grad）。CUDA（erff）・Metal（自作 scalar_erf_f32 prelude）はいずれも超越関数のため REQ-2 統一 複合判定のみで検証する（bit 同一は主張しない）。facade は crates/autodiff::Var を再エクスポートするのみで新規公開面は 追加しない（docs/compat-api-scope.md §5）。

pub fn gelu_tanh(&self) -> Result<Var<'t>, AutodiffError>

GELU（tanh 近似版。PyTorch F.gelu(x, approximate='tanh') 相当）: 0.5 * x * (1 + tanh(sqrt(2/pi) * (x + 0.044715 * x^3)))。 イシュー #1713（親 #1595）。

Var::gelu と同じ委譲・公開面方針。導関数は scalar_op::gelu_tanh_grad（huge magnitude 入力でも NaN を 生まない是正済み実装。scalar_op.rs 参照）。

pub fn softplus( &self, beta: f32, threshold: f32, ) -> Result<Var<'t>, AutodiffError>

Softplus（PyTorch F.softplus(x, beta, threshold) 相当）: x * beta > threshold なら恒等（x）、それ以外は (1 / beta) * ln(1 + exp(beta * x))。イシュー #1713 （親 #1595）。

beta（有限かつ > 0。apply が / beta を含むため beta == 0 は inf／NaN を生む）・threshold（有限）を dispatch 前に検査し、違反時は AutodiffError::InvalidArgument を返す（nn/norm.rs::validate_eps と同じ fail-closed 規律）。 導関数は sigmoid(beta * x)（恒等領域では 1.0。 eval::scalar::unary_grad_factor）。CUDA／Metal は超越関数の ため REQ-2 統一複合判定のみで検証する。facade は crates/autodiff::Var を再エクスポートするのみで新規公開面は 追加しない（docs/compat-api-scope.md §5）。

pub fn sum(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

dim に沿った縮約和。dim: None は全軸縮約（スカラー）。 非 elementwise のため常に実体化済みで返る（matmul と同じ TASK-12.1d の置き換え方針。実行は self.tape.ops().sum 経由）。

BackendOps::sum が BackendError::Unsupported を返した場合も ホスト参照実装へはフォールバックせず、AutodiffError::Backend としてそのまま伝播する（Self::cumsum のフォールバック規律とは 対になる契約。案 C・2026-09-17 ユーザー承認済み。 docs/backend-metal-reduce-sum-design.md §10。CPU／CUDA／Metal の 本番 sum は実装済みで、Unsupported は Metal のカーネル引数上限 超過等の到達しにくい経路に限られる。ホスト側 eval::sum は素の f32 逐次和で CPU 参照実装〈f64 チャンク 2 段〉と bit 一致しないため silent fallback を許すと mean／var／std 等 sum に依存する 演算へ数値方式の非一貫性が波及する）。

pub fn max(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

dim に沿った縮約最大値。dim: None は全軸縮約（スカラー）。 sum と同じ置き換え方針（self.tape.ops().max 経由）。

pub fn min(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

dim に沿った縮約最小値（torch.min(dim).values 相当。 イシュー #1720）。dim: None は全軸縮約（スカラー）。Var::max と対称だが、BackendOps::min はデフォルトメソッド （既定 Unsupported）のため min_with_fallback 経由で ホスト参照実装（eval::min）へフォールバックする （Var::sort／argsort と同じ非破壊拡張方針）。空縮約 （要素数 0）は単位元を持たないため AutodiffError:: InvalidArgument を返す（min_with_fallback doc 参照）。 keepdim／多軸縮約は非対応（別イシューの対象。#1719 の max_dims と同型の min_dims は本メソッドの対象外）。

pub fn argmax(&self, dim: Option<usize>) -> Result<Tensor<i32>, AutodiffError>

dim に沿った最大値の添字（torch.argmax(dim) 相当。イシュー #1720）。非微分演算でテープにノードを追加しない （Var::argsort と同じ扱い）。戻り値は Tensor<i32> （shape は min／max と同じ縮約 shape）。タイは最初の添字・ NaN は無視（fandhe_ai_tensor_core::BackendOps::argmax doc 参照）。空縮約はエラー。

pub fn argmin(&self, dim: Option<usize>) -> Result<Tensor<i32>, AutodiffError>

dim に沿った最小値の添字（torch.argmin(dim) 相当。イシュー #1720）。Var::argmax の最小値版で、非微分・空縮約エラー等の 契約は同一（NaN 規約は Var::min と整合）。

pub fn mean(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

dim に沿った縮約平均。dim: None は全軸縮約（スカラー）。 sum／max と同じ置き換え方針だが、BackendOps を拡張せず self.tape.ops().sum の結果をホスト側で縮約対象要素数 n に より 1 回だけ除算する合成実装（CPU バックエンド側の参照 実装〈reduction::mean〉の「sum の後に 1 回だけ除算する」丸め 規律と同じ。tape::Op::Mean doc 参照）。

n == 0（縮約対象の要素数が 0）は AutodiffError::InvalidArgument で拒否する（PyTorch は NaN を返すが、.claude/rules/coding-rust.md の本番経路 panic 禁止方針の趣旨に合わせ、値が定義されない縮約は安全側で 明示的に拒否する。CPU バックエンド側の参照実装 ReduceError::EmptyReduction と同じ考え方）。

REQ-9 Tier 1「縮約（mean）」根拠: イシュー #1719・親 #1601 「Phase 2（Tier 1）」。fandhe_ai::compat::array／ crates/autodiff::Var を再エクスポートするのみで新規公開面は 追加しない（docs/compat-api-scope.md §5「Tier 1 に列挙済みの 機能の実装は本節の再適用を要しない」）。

pub fn sum_dims( &self, dims: &[usize], keepdim: bool, ) -> Result<Var<'t>, AutodiffError>

複数軸の縮約和（torch.sum(dim=[...], keepdim=) 相当。イシュー #1719）。単一軸なら sum(Some(d)) とbit 同一（crate:: reduce_dims::merge_for_reduction が単一軸・全軸を無加工で 既存単軸 API へ直接委譲するため）。それ以外は permute → contiguous（非 contiguous のときのみ）→ reshape で reduced 軸を 1 軸へ併合してから単軸 sum を呼ぶ（crate::reduce_dims モジュール doc「併合方式を選ぶ理由」参照。f64 アキュムレータの 1 パス蓄積を軸をまたいで維持するため、軸ごとの逐次縮約にはしない）。

dims は空・範囲外・重複のいずれも AutodiffError（crate::reduce_dims::plan_reduce_dims が 検査）で拒否する。keepdim: true は縮約軸をサイズ 1 のまま 元の rank を保持する（PyTorch keepdim=True 相当）。

pub fn max_dims( &self, dims: &[usize], keepdim: bool, ) -> Result<Var<'t>, AutodiffError>

複数軸の縮約最大値（forward 値は torch.amax(dim=[...], keepdim=) と同一。イシュー #1719）。sum_dims と同じ併合方式 （crate::reduce_dims）を使うため、同値タイは縮約対象全要素を 1 回の max_vjp 呼び出しで見る（併合順「kept 軸〈元の 順序〉→ reduced 軸〈昇順〉」で最初に現れる要素が先勝ちする。 grad.rs::max_vjp（extremum_first_match_vjp）の「先勝ち 決定的」規約は、イシュー #1718 の確定により本メソッドも含めて 維持される（torch.amax の均等分配とは勾配が異なる点は 意図的な設計判断。docs/autodiff-amax-grad-distribution- decision.md 参照）。torch.amax 相当の均等分配 VJP は crate::extremum_ops::amax（単一軸限定。イシュー #2154）で 別途提供する（本メソッドの先勝ち挙動は変えない）。dims／ keepdim の契約は sum_dims と同一。

pub fn mean_dims( &self, dims: &[usize], keepdim: bool, ) -> Result<Var<'t>, AutodiffError>

複数軸の縮約平均（torch.mean(dim=[...], keepdim=) 相当。 イシュー #1719）。sum_dims と同じ併合（crate::reduce_dims） の結果へ Var::mean を適用するだけの合成（新規 Op は追加しない）。 dims／keepdim の契約・n == 0 拒否は mean／sum_dims と同一。

pub fn mse_loss(&self, target: &Var<'t>) -> Result<Var<'t>, AutodiffError>

平均二乗誤差（self = 予測値、target = 正解値。全要素平均・ PyTorch nn.MSELoss の既定 reduction='mean' 相当）。 mse_loss_with(target, Reduction::Mean) への委譲（#190）。 既存呼び出し元（nn::activation 系テスト・tests/backward.rs 等）のシグネチャ・意味を変えないため本メソッドは維持する。

pub fn mse_loss_with( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

平均二乗誤差（self = 予測値、target = 正解値）。reduction で mean/sum の縮約種別を選べる（#190。親イシュー #189「損失関数 （MSE・CrossEntropy）の実装」）。nn::loss::MseLoss（nn/loss.rs） はこのメソッドを呼ぶだけの薄いラッパー（REQ-9）。

TASK-12.1d（#164）→ イシュー #1045 で更新: 入力を層 1 （materialize_fallible）で実体化したうえで、self.tape.ops() の BackendOps::mse_loss（CPU／CUDA／Metal の融合カーネル。 docs/kernel-fusion.md）を試みる。Err(BackendError:: Unsupported(_)) のときのみ従来のホスト参照実装 eval::mse_loss へフォールバックし、それ以外のエラー（融合カーネルが実行時に 失敗した場合等）は伝播する（判定迂回経路を作らない。 .claude/rules/security.md A08。materialize_fallible の run_fused フォールバック規律と同じ方針。tape.rs:905 参照）。 require_same_shape が既に shape 一致を検査済みのため、 バックエンド実装が返す ShapeMismatch は「バックエンド実装の 契約違反」を意味し、こちらも Unsupported 同様フォールバック せず伝播する（想定内の分岐で握り潰さない）。

pub fn huber_loss( &self, target: &Var<'t>, delta: f32, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

Huber 損失（self = 予測値、target = 正解値。PyTorch nn.HuberLoss(delta) 相当。イシュー #1739）。|d| < delta （d = pred − target）で二次（0.5·d²）、それ以外で線形 （delta·(|d| − 0.5·delta)）となる区分的損失（eval:: huber_elem_loss が意味論の正）。delta は有限かつ > 0 を 要求する（PyTorch の delta 引数と同じ制約）。 huber_loss_impl(target, HuberKind::Huber, delta, reduction) への委譲。

pub fn smooth_l1_loss( &self, target: &Var<'t>, beta: f32, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

SmoothL1 損失（self = 予測値、target = 正解値。PyTorch nn.SmoothL1Loss(beta) 相当。イシュー #1739）。Self::huber_loss と同じ折れ点構造だが二次分岐が 0.5·d²/beta に beta で スケールされる点のみ異なる（beta = 1.0 のとき両者は一致する）。 beta = 0（PyTorch では nn.L1Loss 相当に退化する特殊値）は 本メソッドの対象外——他の delta／beta 値と同じ「有限かつ > 0」検査により AutodiffError::InvalidArgument で拒否する。 huber_loss_impl(target, HuberKind::SmoothL1, beta, reduction) への委譲。

pub fn bce_loss( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

二値交差エントロピー損失（self = 予測確率 [0, 1]、target = 正解ラベル。全要素平均・PyTorch nn.BCELoss 相当）。 bce_loss_impl(target, BceKind::Probabilities, reduction) への 委譲（#1737。親イシュー #1609「損失関数の拡張」）。nn::loss:: BceLoss（nn/loss.rs）はこのメソッドを呼ぶだけの薄いラッパー （REQ-9）。

pub fn bce_with_logits_loss( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

二値交差エントロピー損失（logits 入力版。self = 未正規化の logits、target = 正解ラベル。PyTorch nn.BCEWithLogitsLoss 相当）。sigmoid をカーネル内に内包した数値安定な合成式で計算 する（docs/compat-api-scope.md §1.2 参照）。 bce_loss_impl(target, BceKind::Logits, reduction) への委譲 （#1737）。self（logits）は [0, 1] 範囲制約を受けない （Self::bce_loss と異なり範囲検査を行わない）。nn::loss:: BceWithLogitsLoss（nn/loss.rs）はこのメソッドを呼ぶだけの 薄いラッパー（REQ-9）。

pub fn rms_norm( &self, weight: Option<&Var<'t>>, eps: f32, ) -> Result<Var<'t>, AutodiffError>

行方向 RMSNorm（x · rsqrt(mean(x²) + eps) · w。w が None の場合は乗算をスキップ。イシュー #1596）。正規化軸は常に 最終軸（row_norm_layout が (rows, hidden) を導出する）。

検査順序（mse_loss_with と同じ演算メソッド規律。weight を 渡す場合のみクロステープ検査を追加）: ①weight があれば check_same_tape → ②eps が有限かつ非負であることを検査 （違反は AutodiffError::InvalidArgument。docs/norm-ops-design.md 「eps 検査」節） → ③row_norm_layout で self の shape から hidden を導出し、weight の shape が [hidden] と厳密一致する ことを検査（ShapeError::ShapeMismatch） → ④実体化（層 1） → ⑤self.tape.ops().rmsnorm を試み Unsupported のときのみ eval::rmsnorm_rows へフォールバック（それ以外のエラーは伝播。 判定迂回経路を作らない。.claude/rules/security.md A08） → ⑥バックエンド契約検証（戻り値 shape が入力と恒等） → ⑦ノード記録。

pub fn layer_norm( &self, weight: Option<&Var<'t>>, bias: Option<&Var<'t>>, eps: f32, ) -> Result<Var<'t>, AutodiffError>

行方向 LayerNorm（(x − mean(x)) · rsqrt(var(x) + eps) · w + b。 w／b はそれぞれ None の場合は対応する演算をスキップ。 分散は biased（÷N）。イシュー #1596）。Self::rms_norm と 同じ最終軸限定契約・検査順序（bias も weight と同じ クロステープ検査・shape [hidden] 検査を受ける）。

pub fn batch_norm( &self, weight: Option<&Var<'t>>, bias: Option<&Var<'t>>, eps: f32, ) -> Result<Var<'t>, AutodiffError>

BatchNorm1d／2d の train モード（バッチ統計。チャネル軸は常に dim 1。イシュー #1732・親 #1608・docs/batch-norm-ops-design.md）。 Self::batch_norm_with_batch_stats の .0（output のみ）を 返す薄いラッパー。

pub fn batch_norm_with_batch_stats( &self, weight: Option<&Var<'t>>, bias: Option<&Var<'t>>, eps: f32, ) -> Result<(Var<'t>, Tensor<f32>, Tensor<f32>), AutodiffError>

Self::batch_norm の本体。バッチ統計（batch_mean／ batch_var。biased ÷M）も (output, batch_mean, batch_var) タプルで返す——呼び出し元（nn::BatchNorm1d／BatchNorm2d）が running stats を更新するために必要（Var::layer_norm と異なり BatchNorm はバッチ統計を呼び出し元へ公開する必要がある）。

検査順序（Self::layer_norm と同じ演算メソッド規律）: ① weight／bias があれば check_same_tape → ②eps が有限かつ 非負であることを検査 → ③[fandhe_ai_tensor_core:: batch_norm_layout] で (n, c, spatial) を導出 → ④M = n*spatial が 1 以下の場合 AutodiffError::InvalidArgument（unbiased 分散 の M-1 除算で 0 除算になるため。PyTorch torch.nn.functional. batch_norm の _verify_batch_size と同じ拒否）→ ⑤weight／ bias の shape が [c] と厳密一致することを検査 → ⑥実体化 → ⑦batch_norm_train_with_fallback（grad.rs。バックエンド → Unsupported のときのみホスト参照実装）→ ⑧ノード記録 （fixed_stats: None が train モードを表す）。

pub fn batch_norm_infer( &self, weight: Option<&Var<'t>>, bias: Option<&Var<'t>>, running_mean: &Tensor<f32>, running_var: &Tensor<f32>, eps: f32, ) -> Result<Var<'t>, AutodiffError>

BatchNorm1d／2d の eval モード（固定統計。running_mean／ running_var は呼び出し元〈nn::BatchNorm1d／BatchNorm2d〉が 保持する running stats。イシュー #1732・親 #1608）。 Self::batch_norm_with_batch_stats と同じ検査順序だが、M を導出・検査しない（バッチから統計を計算しないため M<=1 制約が不要）代わりに running_mean／running_var の shape [c] を検査する。

pub fn softmax(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

行方向 softmax（exp(x − max(x)) / Σexp(x − max(x))。イシュー #1594）。dim は reduce_out_shape で範囲検査する（既存の sum/max と同じ軸検査ヘルパーを再利用。softmax は shape 不変 のため戻り値 shape 自体には使わないが、AxisOutOfRange の検査 目的のみで呼ぶ）。

self.tape.ops().softmax（BackendOps::softmax。CPU／CUDA／ Metal の行カーネル。最終軸専用）を試み、Err(BackendError:: Unsupported(_)) のときのみホスト参照実装 eval::softmax_along （最終軸に限らず任意軸へ対応）へフォールバックする（それ以外の エラーは伝播する。判定迂回経路を作らない。.claude/rules/ security.md A08。mse_loss_with と同じ規律）。

pub fn log_softmax(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

行方向 log_softmax（x − m − ln(Σexp(x − m))。イシュー #1594）。 Self::softmax と同じ dim 検査・フォールバック規律 （BackendOps::log_softmax → Unsupported のときのみ eval:: log_softmax_along へフォールバック）。

pub fn cumsum(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

dim 軸に沿った累積和（torch.cumsum 相当。イシュー #1731）。 Self::softmax と同じ dim 検査・フォールバック規律 （BackendOps::cumsum → Unsupported のときのみ eval:: cumsum_along へフォールバック）。出力 shape は self と恒等 （累積演算は shape を変えない）。

pub fn cumprod(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

dim 軸に沿った累積積（torch.cumprod 相当。イシュー #1731）。 Self::cumsum と同じ dim 検査・フォールバック規律 （BackendOps::cumprod → Unsupported のときのみ eval:: cumprod_along へフォールバック）。

pub fn cross_entropy_loss( &self, targets: &Tensor<i32>, class_dim: usize, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

CrossEntropy 損失（log-sum-exp 安定化・クラス次元指定。#191・ 親イシュー #189）。self = logits（追跡対象）、targets = 正解 クラス添字（非追跡・Tensor<i32>。勾配は定義されないため Var にしない。tape::Op::CrossEntropyLoss doc 参照）。

検査順序（本メソッド冒頭 doc の演算メソッド規律に、targets 範囲検査〈REQ-8 趣旨の境界外アクセス防止・A03 対策〉を追加）: ①class_dim 範囲・targets shape 一致（reduce_out_shape を 再利用。class_dim >= rank は ShapeError::AxisOutOfRange） → ②targets 全添字が 0 <= t < C（違反は AutodiffError::InvalidArgument）→ ③実体化（層 1）→ ④forward 値計算（eval::cross_entropy_loss。mse_loss_with と同じく BackendOps に対応メソッドがないため融合対象外）→ ⑤ノード記録。

本メソッドのシグネチャ・数値経路は不変（イシュー #2166）。 label_smoothing・ignore_index・class_weight の各オプションは Self::cross_entropy_loss_with（crate::loss_ops への委譲。 #2538 で facade 公開）で追加提供する。

pub fn nll_loss( &self, targets: &Tensor<i32>, class_dim: usize, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

負対数尤度損失（self = log 確率、targets = 正解クラス添字。 PyTorch nn.NLLLoss 相当。log_softmax(x).nll_loss(t) が cross_entropy_loss(x, t) と一致する。#1738。親イシュー #1609 「損失関数の拡張」）。targets は Self::cross_entropy_loss と 同じく非追跡（Tensor<i32>。勾配は定義されないため Var に しない。tape::Op::NllLoss doc 参照）。

検査順序（Self::cross_entropy_loss と同じ演算メソッド規律）: ①class_dim 範囲・targets shape 一致（reduce_out_shape を 再利用）→ ②targets 全添字が 0 <= t < C（違反は AutodiffError::InvalidArgument。REQ-8 趣旨の境界外アクセス 防止・A03 対策）→ ③実体化（層 1）→ ④self.tape.ops() の融合 カーネル（BackendOps::nll_loss）を試み Unsupported のときのみ ホスト参照実装（eval::nll_loss）へフォールバック（それ以外の エラーは伝播し判定迂回経路を作らない。.claude/rules/security.md A08）→ ⑤戻り値 shape [] の契約検証 → ⑥ノード記録。nn::loss:: NllLoss（nn/loss.rs）はこのメソッドを呼ぶだけの薄いラッパー （REQ-9）。

pub fn kl_div_loss( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

Kullback-Leibler ダイバージェンス損失（self = log 確率、 target = 確率〈PyTorch 既定 log_target=False〉。PyTorch nn.KLDivLoss 相当。#1738）。kl_div_loss_impl(target, KlDivTarget::Probabilities, reduction) への委譲。nn::loss:: KlDivLoss（nn/loss.rs）はこのメソッドを呼ぶだけの薄いラッパー （REQ-9）。

pub fn kl_div_loss_with_log_target( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

Kullback-Leibler ダイバージェンス損失（対数確率 target 版。 self = log 確率、target = 対数確率。PyTorch nn.KLDivLoss( log_target=True) 相当）。kl_div_loss_impl(target, KlDivTarget::LogProbabilities, reduction) への委譲（#1738）。 nn::loss::KlDivLoss::new_with_log_target（nn/loss.rs）はこの メソッドを呼ぶだけの薄いラッパー（REQ-9）。

pub fn relu(&self) -> Var<'t>

ReLU。shape を変えない要素ごとの演算のため構造的に失敗しえない （docs/public-api-design.md §3.2）。elementwise 5 演算の 1 つ （add/mul と同じ遅延契約。TASK-12.1d・#164）。

連鎖長上限（#404・設計書 §3.5.4）: 非 fallible な単項演算 のため、上限到達時は層 2（materialize_non_fallible）でその場 実体化する（add/mul の層 1 とは異なり、必ず値が入り panic／Err を返さない）。

pub fn exp(&self) -> Var<'t>

要素ごとの指数関数。elementwise 5 演算の 1 つ（relu と同じ 遅延契約・連鎖長上限での自己実体化契約。#404）。

pub fn tanh(&self) -> Var<'t>

要素ごとの双曲線正接。elementwise 5 演算の 1 つ（relu と同じ 遅延契約・連鎖長上限での自己実体化契約。#404）。

pub fn sigmoid(&self) -> Var<'t>

要素ごとのシグモイド（1 / (1 + exp(-x))）。relu/exp/tanh と同じく shape 不変の単項演算のため構造的に失敗しえない （TASK-9.1b・#92。nn::activation::Sigmoid の薄いラッパーが このメソッドを呼ぶ）。forward は eval::sigmoid（数値安定形） を使う。

TASK-12.1d（#164）: BackendOps に対応メソッドがないため 融合対象外とし、常に実体化済みで返る（push_eager）。入力読み 出しは非 fallible な本メソッド自身の契約に合わせ value() （層 2）経由とする（設計書 §3.5.1）。

pub fn checkpoint_from( &self, inputs: &[&Var<'t>], ) -> Result<Var<'t>, AutodiffError>

activation checkpointing（イシュー #1624・docs/ autodiff-checkpoint-design.md）: self を区間の出力、inputs を区間の外側入力として、inputs より後・self 以前に push された再計算可能ノード（Op::is_checkpoint_eligible()）を解放 する（Tape::register_checkpoint 経由）。self 自身は解放 されない（呼び出し元が戻り値として保持し続けるため）。

Tape::checkpoint（閉包版）の低儀式な代替入口——facade は Tape newtype への新規 pub fn 追加を承認事項として保留して いる一方、Var は素で再エクスポート済みのため、本メソッドが facade 経由でも到達可能な唯一の checkpoint 入口となる （docs/compat-api-scope.md §1.3）。

inputs が空の場合、区間はテープ先頭（node id 0）から self までとする。inputs のいずれかが別 Tape に属する場合は Err(TapeMismatch)（クロステープ検査。check_same_tape doc 参照）。self の node id が inputs のどれよりも小さい（区間が 空）場合は no-op で self をそのまま返す。

pub fn reshape(&self, shape: &[usize]) -> Result<Var<'t>, AutodiffError>

新しい shape へ再解釈する view 系ノード（イシュー #1047・親 #1043）。Tensor::reshape（tensor-core）と同じく contiguous な 入力に限り zero-copy（案 A・エラー方式。docs/spec/ public-api-design.md §2.2.1 は未決事項としていたが、本イシューは 自動運転モードのため安全側の案 A を踏襲する。案 B〈暗黙コピー〉 への変更はユーザー承認事項として tensor-core::Tensor::reshape のドキュメント参照）。

検査順序（演算メソッド規律「①クロステープ検査 → ②shape 検査 → ③forward 値計算 → ④ノード記録」を view 系向けに具体化）: ①要素数一致（クロステープ検査は単項演算のため不要）→ ②層 1 （materialize_fallible）で入力を実体化 → ③実体化値の is_contiguous() を検査（非 contiguous なら ShapeError::NonContiguousReshape を返し、暗黙コピーでバッファ 確保 0 の契約を破らない）→ ④Tape::push_view でホスト値を持たない ノードとして記録する（tape::Op::Reshape doc「forward のたびに バッファ確保しない」の中核）。

pub fn transpose( &self, dim0: usize, dim1: usize, ) -> Result<Var<'t>, AutodiffError>

2 軸の転置（view 系ノード。イシュー #1047・親 #1043）。 Tensor::transpose（tensor-core）と同じく常に zero-copy （strides の入れ替えのみ）。dim0 == dim1 は恒等 view として 許容する（Tensor::transpose 自体が同じ挙動）。

検査順序: ①dim0／dim1 が rank 範囲内 → ②Tape::push_view で ホスト値を持たないノードとして記録する（reshape と異なり transpose は非 contiguous 化しても失敗しない演算のため実体化前 検査は軸範囲のみで足りる。ただし Tape::push_view の呼び出し 契約〈input 事前実体化〉を満たすため、軸検査の後に層 1で入力を 実体化してから記録する）。

pub fn permute(&self, perm: &[usize]) -> Result<Var<'t>, AutodiffError>

任意軸並べ替え（view 系ノード。イシュー #1597）。transpose の 2 軸限定を補う N 階一般対応版（Tensor::permute／ONNX Transpose と同じ規約: perm[k] は出力軸 k が指す入力軸）。 常に zero-copy（strides の並べ替えのみ）。

検査順序: ①perm の長さが rank と一致（不一致は ShapeError::RankMismatch）→ ②各軸が範囲内（AxisOutOfRange） かつ重複なし（DuplicateAxis）→ ③層 1 で入力を実体化してから Tape::push_view（transpose と同じ理由で、実体化前検査は shape 情報のみで足りるため軸検査の後に行う）。

perm が 2 軸のみを入れ替える順列（例 [1, 0]）の場合、出力 strides は Var::transpose(0, 1) と同一になるため、CPU／Metal の NT/TN 転置入口（#1213／#1215）の高速経路は本メソッド経由でも 従来どおり到達する（strides 判定のため）。

pub fn einsum( spec: &str, operands: &[&Var<'t>], ) -> Result<Var<'t>, AutodiffError>

einsum 記法（PyTorch torch.einsum／TF tf.einsum 相当）による 汎用縮約（イシュー #1620）。既存の matmul／sum／permute／ reshape／mul（crate::einsum モジュール）への分解として 実装しており、新規カーネルは追加していない。VJP は分解先の 各演算の VJP 合成として自動的に成立する（einsum 専用の VJP を grad.rs に追加していない）。

受理範囲（v1・安全側）: 添字は ASCII 英字のみ（空白は無視）。 オペランドは 1〜2 個限定。ellipsis（...）・同一オペランド内の 添字重複（対角／trace）・出力添字の重複は AutodiffError::InvalidArgument で拒否する。両オペランドと 出力に共通する batch 添字を伴う 2 項縮約（例 "bij,bjk->bik"） は rank≥3 matmul（イシュー #1715。gemm_batched）への分解で 受理する（イシュー #2517。従来 Err だった入力が Ok になる 非破壊拡張）。既知の制約: create_graph 下（高階微分）では rank≥3 MatMul のため AutodiffError::Backward を返す・ size-1 broadcast なし・複数 batch 添字の bit 同一は主張しない。 -> 省略時は NumPy einsum 既定（入力に 1 回だけ現れる添字を ASCII 昇順）を出力とみなす。詳細な受理 範囲・分解アルゴリズムは crate::einsum モジュール doc を参照。

数値契約: 縮約（contract が非空）を伴う場合は Var::matmul をそのまま呼ぶため、CUDA TF32 opt-in の挙動を 含めて matmul と同一（.claude/rules/coding-rust.md FMA 契約統一）。

pub fn scaled_dot_product_attention( query: &Var<'t>, key: &Var<'t>, value: &Var<'t>, attn_mask: Option<&Tensor<bool>>, is_causal: bool, scale: Option<f32>, ) -> Result<Var<'t>, AutodiffError>

PyTorch torch.nn.functional.scaled_dot_product_attention 相当 （イシュー #1639。親 #1605「MultiheadAttention」の sub-issue (a)。設計・対象外事項は crate::attention〈非公開モジュール〉の doc 参照）。

query: [..., L, E]・key: [..., S, E]・value: [..., S, Ev] （バッチ次元 ... は NumPy 互換ブロードキャスト。Var::matmul と同じ契約）を受け取り [..., L, Ev] を返す。

attn_mask（true = attend。PyTorch bool mask 規約。[..., L, S] へ broadcast 可能な形状）と is_causal（top-left aligned の j <= i causal mask）は同時指定不可（[AutodiffError:: InvalidArgument]）。scale は None のとき 1/sqrt(E) （E == 0 かつ scale == None は [AutodiffError:: InvalidArgument]）。

対象外: dropout_p（SDPA への結線は対象外。Var::dropout 自体は #1603 で実装済み）・enable_gqa・attention weights の返却・f16／bf16（#1626）。既存カーネルの合成のみで 実装しており、新規 Op／BackendOps メソッドは追加していない （CUDA／Metal 専用の融合 attention カーネルは対象外。 docs/kernel-fusion.md）。

Errors

query／key が rank < 2、attn_mask と is_causal の同時 指定、attn_mask が [..., L, S] へ broadcast 不能、いずれかの 行が全 key を masked にしてしまう、scale（既定値含む）が非 有限・0 以下、のいずれかで型付きエラーを返す。E／S の不一致・ バッチ broadcast 不能・テープ不一致は内部で呼ぶ matmul／ transpose の既存検査へ委譲する。

pub fn rnn_cell( &self, h_prev: &Var<'t>, p: GateParams<'_, 't>, ) -> Result<Var<'t>, AutodiffError>

RNN（tanh 版）セル 1 step（イシュー #1647・設計 docs/autodiff- rnn-cell-tape-design.md 決定 1・4・5）。 h_t = tanh(x·W_ih + b_ih + h_{t-1}·W_hh + b_hh)。

self が x_t: [B, D]、h_prev: [B, H]、p.w_ih: [D, H]、 p.w_hh: [H, H]、p.b_ih／p.b_hh はいずれも [H]（両方 Some か両方 None。片方のみは AutodiffError::InvalidArgument）。 D == 0／H == 0 は zero-K ガードとして拒否する。

pub fn broadcast_to(&self, shape: &[usize]) -> Result<Var<'t>, AutodiffError>

shape へブロードキャストする view 系ノード（イシュー #1597）。 Tensor::broadcast_to（NumPy broadcast_to 相当）と同じ規約: 拡張軸（元の軸長 1 が shape 側で 1 より大きい値に広がる軸）は stride 0 の view になり zero-copy。同一 shape への broadcast は 恒等 view として許容する。

検査順序: ①要素数オーバーフロー検査（reshape と同じ自前 checked_mul 実装。tensor-core は checked_numel を非公開に しているため）→ ②shape.len() < rank または各軸が src == dst || src == 1 を満たさない場合は ShapeError::BroadcastIncompatible → ③層 1 で入力を実体化して から Tape::push_view。

VJP（grad.rs）は Op::Add／Op::Mul の暗黙ブロードキャストと 同じ reduce_to_shape 縮約を使うため、勾配バッファの確保を 伴う（reshape／transpose／permute の VJP は zero-copy だが 本メソッドの VJP は異なる。tape::Op::BroadcastTo doc 参照）。

pub fn expand(&self, shape: &[usize]) -> Result<Var<'t>, AutodiffError>

Var::broadcast_to の PyTorch 名別名（Tensor.expand。イシュー #1597）。負値（-1 で当該軸を維持する PyTorch の記法）は shape: &[usize] の型上表現できないため非対応——呼び出し側は 維持したい軸の実サイズを明示的に渡すこと。

pub fn squeeze(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

長さ 1 の軸を除去する view 系ノード（Var::reshape への委譲。 イシュー #1597）。

• dim: None — 長さ 1 の軸をすべて除去する（NumPy／PyTorch squeeze() と同じ）。
• dim: Some(d) — 軸 d が rank 範囲外なら ShapeError::AxisOutOfRange。d が範囲内だが shape[d] != 1 の場合は PyTorch 準拠の no-op（shape を変えず reshape を 記録する。numpy／TensorFlow はここをエラーにするが、適合する ShapeError variant が存在せず、crates.io 公開クレート tensor-core の公開 enum への variant 追加は semver 可視の 変更になるため、本イシューでは PyTorch 方式を採用する）。

非 contiguous な入力（例: permute／transpose／broadcast_to の直後）に対する制約は reshape と同じ（ShapeError:: NonContiguousReshape）。

pub fn unsqueeze(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

長さ 1 の軸を挿入する view 系ノード（Var::reshape への委譲。 イシュー #1597）。dim は挿入後の rank（rank + 1）に対する 軸位置として扱うため有効範囲は 0..=rank（PyTorch unsqueeze と同じ: 末尾への挿入 dim == rank を許容する）。 範囲外は ShapeError::AxisOutOfRange { axis: dim, rank: rank + 1 }。

非 contiguous な入力に対する制約は reshape と同じ。

pub fn flatten( &self, start_dim: usize, end_dim: usize, ) -> Result<Var<'t>, AutodiffError>

[start_dim, end_dim]（両端含む）の連続する軸を 1 軸へ潰す view 系ノード（Var::reshape への委譲。イシュー #1597）。 PyTorch torch.flatten(start_dim, end_dim) と同じ規約。

end_dim >= rank または start_dim > end_dim は ShapeError::AxisOutOfRange（後者は axis: start_dim として 報告する）。rank 0（スカラー）は (start_dim, end_dim) == (0, 0) のみ許容し [1] を返す（PyTorch と同じ）。潰す軸区間 の部分積自体は usize::MAX を含むゼロ長軸混在形状で オーバーフローしうるため checked_mul で検査し、オーバー フロー時は ShapeError::ElementCountOverflow を返す（総要素数 が reshape 側で検査済みでも部分積は別途検査が要る）。

非 contiguous な入力に対する制約は reshape と同じ。

pub fn unflatten( &self, dim: usize, sizes: &[usize], ) -> Result<Var<'t>, AutodiffError>

軸 dim を sizes の複数軸へ展開する（torch.unflatten(input, dim, sizes) 相当。Var::flatten の逆変換。イシュー #2521）。

sizes が空・dim >= rank・sizes の積が shape[dim] と不一致 （checked_mul オーバーフロー含む）は Err。shape 検査を通るまで tape を操作しないため、エラー時に孤児ノードを残さない。

pub fn dropout2d( &self, p: f32, training: bool, ) -> Result<Var<'t>, AutodiffError>

チャネル単位 dropout（PyTorch F.dropout2d(input, p, training) 相当。 イシュー #2528）。[N, C, H, W]（rank 4 限定）の (n, c) チャネルを まとめて確率 p で 0 に落とし、残すチャネルは 1/(1-p) 倍する。

p が非有限または [0, 1] の範囲外は InvalidArgument、rank 4 以外は Shape(RankMismatch)。検査は tape 操作より前に完了するため Err で 孤児ノードを残さない。training == false または p == 0.0 は self を そのまま返す（ノードを積まず RNG も消費しない）。本体は nn::Dropout2d と共有する forward（pub(crate)）への 1 行委譲。

pub fn alpha_dropout( &self, p: f32, training: bool, ) -> Result<Var<'t>, AutodiffError>

AlphaDropout（PyTorch F.alpha_dropout(input, p, training) 相当。 イシュー #2528）。SELU 系ネットワーク向けに、drop 後の出力が入力の 平均・分散を保つようアフィン補正する。入力 rank は任意。

p の検査・早期リターン・孤児ノードを残さない規律は Self::dropout2d と同じ。本体は nn::AlphaDropout と共有する forward への 1 行委譲。

pub fn embedding_bag( &self, ids: &Tensor<i32>, mode: EmbeddingBagMode, padding_idx: Option<usize>, ) -> Result<Var<'t>, AutodiffError>

EmbeddingBag（PyTorch F.embedding_bag(ids, weight, mode=..) の長さの 揃った bag 形式相当。イシュー #2528）。self は weight [num_embeddings, D]、ids は [B, L]、戻り値は [B, D] （bag ごとに mode で縮約）。padding_idx に一致する id は縮約から除外する。

weight の rank 不一致・padding_idx >= num_embeddings・ids の rank 不一致・ 範囲外 id は Err。検査は tape 操作より前に完了するため Err で孤児ノードを 残さない。本体は nn::EmbeddingBag と共有する forward への 1 行委譲。 可変長 bag（offsets）は未公開。

pub fn pixel_shuffle( &self, upscale_factor: usize, ) -> Result<Var<'t>, AutodiffError>

チャネル軸を空間軸へ並べ替える（PyTorch F.pixel_shuffle 相当。イシュー #2526）。

[*, C*r*r, H, W] → [*, C, H*r, W*r]（r = upscale_factor）。軸の並びは out[.., c, h*r+i, w*r+j] = in[.., c*r*r+i*r+j, h, w]。rank 3 以上を受理する。 0・rank 3 未満・チャネル軸の非整除・オーバーフローは Err で、shape 検査を 通るまで tape を操作しないためエラー時に孤児ノードを残さない。

pub fn pixel_unshuffle( &self, downscale_factor: usize, ) -> Result<Var<'t>, AutodiffError>

空間軸をチャネル軸へ並べ替える（PyTorch F.pixel_unshuffle 相当。 Var::pixel_shuffle の逆変換。イシュー #2526）。

[*, C, H*r, W*r] → [*, C*r*r, H, W]（r = downscale_factor）。 エラー条件・孤児ノード無しの規律は Var::pixel_shuffle と同じ。

pub fn conv_transpose1d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: usize, padding: usize, output_padding: usize, dilation: usize, groups: usize, ) -> Result<Var<'t>, AutodiffError>

1 次元転置畳み込み（PyTorch F.conv_transpose1d。イシュー #2521）。

self は [N, Cin, L]、weight は [Cin, Cout/groups, k]、bias は [Cout]。nn::ConvTranspose1dVars::forward と同じ本体 （reshape 併合 → conv_transpose2d）へ委譲する。shape 検査は tape 操作の前に完了し、エラー時に孤児ノードを残さない。

pub fn cat(vars: &[Var<'t>], dim: usize) -> Result<Var<'t>, AutodiffError>

複数の Var を dim 軸で連結する（torch.cat 相当。イシュー #1598）。関連関数（&self を取らない）——Var は Copy の ため &[Var<'t>] で受ける。

検査順序: ①空リストは vars[0] に触れる前に AutodiffError::InvalidArgument → ②先頭要素基準の check_same_tape（AutodiffError::TapeMismatch）→ ③shape 検査 （fandhe_ai_tensor_core::concat_out_shape。rank 不一致・ dim 範囲外・dim 以外の軸不一致・要素数オーバーフローを 個別 variant で報告）→ ④全入力を層 1 で実体化 → ⑤ Tape::push_eager で記録する（Op::Concat doc 参照）。

forward 値は grad::concat_with_fallback（ops.concat → Unsupported のときのみ eval::concat）で計算する。VJP （grad.rs）は各入力へ upstream.narrow を zero-copy に分配 する。1 要素リストも通常どおり Op::Concat ノードを記録する （恒等コピー）。

pub fn stack(vars: &[Var<'t>], dim: usize) -> Result<Var<'t>, AutodiffError>

複数の Var を新規軸 dim で積み上げる（torch.stack 相当。 イシュー #1598）。各要素を unsqueeze(dim) してから Self::cat する（PyTorch の定義そのもの）。関連関数。

検査順序: ①空リスト → InvalidArgument（vars[0] に触れる 前）→ ②先頭要素基準の check_same_tape → ③dim <= rank （ShapeError::AxisOutOfRange { rank: rank + 1 }）→ ④全要素の shape 完全一致（ShapeError::ShapeMismatch）→ ここまで全て 通過してから unsqueeze ノードを push する（失敗した stack がテープに中間ノードを残さないよう、unsqueeze を呼ぶ前に 全要素の contiguity も検査する）。

unsqueeze は reshape へ委譲するため、非 contiguous な 要素（permute／transpose 直後）は ShapeError::NonContiguousReshape を返す（暗黙 contiguous() はしない。Var::reshape doc「案 A」と同じ規律）。

pub fn narrow( &self, dim: usize, start: usize, len: usize, ) -> Result<Var<'t>, AutodiffError>

[start, start+len) を切り出す zero-copy view（torch.narrow 相当。イシュー #1598・#1599「narrow」行の解消）。

検査順序: ①dim < rank（ShapeError::AxisOutOfRange）→ ②start + len <= shape[dim]（checked_add。 ShapeError::NarrowOutOfBounds）→ ③層 1 で入力を実体化してから Tape::push_view（transpose／permute と同じ規律）。

pub fn pad( &self, pads: &[(usize, usize)], value: f32, ) -> Result<Var<'t>, AutodiffError>

各軸を定数値 value で拡張する（torch.nn.functional.pad (mode='constant') 相当。イシュー #1756）。pads[i] = (before, after) は先頭次元から順に対応する（PyTorch F.pad の「末尾 次元から逆順の平坦リスト」とは異なる意図的な設計。負パディング （クロップ）は非対応——Self::narrow を使うこと。reflect／ replicate モードも対象外。docs/compat-feature-gap.md 追補参照）。

検査順序: ①fandhe_ai_tensor_core::pad_out_shape（pads.len() == rank・各軸の before／after 加算オーバーフロー・ 出力要素数積オーバーフローを検査し out_shape を確定。違反は AutodiffError::Shape）→ ①’確保前の実用上限検査（out_shape の総要素数を crate::rearrange_ops::checked_index_alloc_len へ渡す。size_of::<i32>() == size_of::<f32>() == 4 のため 添字ベクタ向けの 1 GiB 上限がそのまま f32 出力の確保前 バイト数検査として転用できる——Var::diag の 1-D→2-D 経路 〈matrix_ops::diag_1d_to_2d〉と同じ線引き・イシュー #2264。ここで拒否すれば ②以降の実体化・確保に進まないため、 eval::pad／backend-cpu::constant_pad::pad の確保 （後者は try_reserve_exact で二重に fail-closed だが、 ホスト参照実装 eval::pad は失敗しない確保のため本検査が 早期防波堤——③pad_with_fallback 側でも同じ検査を再実行する ため、ここでの拒否は「実体化前に早く落とす」最適化であり 唯一の防波堤ではない。イシュー #2264 レビュー是正: Var::pad を経由しない呼び出し元〈ZeroPad2d::forward_host 等〉のために pad_with_fallback 自身が呼び出し元を問わない確保前検査を持つ） を実際に起動する前に巨大な pad 幅を Err で拒否する）→ ②self を層 1 で実体化（RefCell 借用を閉じてから push。 Var::gather と同じ「実体化してからフォールバックへ渡す」 方針）→ ③pad_with_fallback（ops.pad → Unsupported の ときのみホスト参照実装 eval::pad へフォールバック。確保前 上限検査もここで再実行する——唯一の確保前チェックポイント） → ④戻り shape 検証（.claude/rules/security.md A08）→ ⑤push_eager（非融合・常実体化。value は子テープの forward 再生 （create_graph。イシュー #3084）専用に Op::Pad へ保持する。VJP は使わない）。

pub fn conv3d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: [usize; 3], padding: [usize; 3], dilation: [usize; 3], groups: usize, ) -> Result<Var<'t>, AutodiffError>

3 次元畳み込み（torch.nn.functional.conv3d 相当。NCDHW 固定。 イシュー #2524・設計 docs/conv-ops-design.md §16.7）。 crate::conv3d_ops::conv3d への 1 行委譲で、引数順は Var::conv2d を空間 3 軸に一般化したもの。self（input）: [N, Cin, D, H, W]・weight: [Cout, Cin/groups, kD, kH, kW]・ bias: Some なら [Cout]。検査順序・エラー時に tape を操作 しない契約は自由関数と同一。

pub fn conv2d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], groups: usize, ) -> Result<Var<'t>, AutodiffError>

2 次元畳み込み（torch.nn.functional.conv2d 相当の cross-correlation。NCHW 固定。イシュー #1764・設計 docs/ conv-ops-design.md）。self（input）: [N, Cin, H, W]・ weight: [Cout, Cin/groups, kH, kW]（PyTorch 準拠。nn:: Linear の [in, out] 格納とは異なる）・bias: Some なら [Cout]。

検査順序（設計 doc §3）: ①weight.shape()[2..4] から kernel_size を導出し Conv2dParams::new（stride／ dilation／groups の 0・2·padding オーバーフローを BackendError::InvalidArgument → AutodiffError::InvalidArgument で拒否）→ ②fandhe_ai_tensor_core::conv2d_out_shape で out_shape を確定（rank・チャンネル整合・空間軸 H／W = 0 拒否・負分子拒否ゲート。AutodiffError::Shape）→ ③self／ weight／bias を層 1 で実体化（RefCell 借用を閉じてから push）→ ④conv2d_with_fallback（grad 内非公開。ops.conv2d → im2col → gemm_batched〈常にバックエンド〉→ add〈bias〉の段階的合成） → ⑤戻り shape 検証（.claude/rules/security.md A08）→ ⑥push_eager（非融合・常実体化。col は Op::Conv2d 自身に 保持しない——backward で再計算する）。

pub fn matmul_low_precision( &self, other: &Var<'t>, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

Self::matmul の opt-in 低精度版（イシュー #2071・親 #1626／ #1648）。fandhe_ai_tensor_core::matmul_low_precision （TypedOps<f16>／TypedOps<bf16> 経由。rank 2 は TypedOps::gemm 直接委譲・rank≥3 は per-batch ループ）へ forward 値計算のみを委譲する opt-in 経路。crate::attention の低精度 SDPA・nn::attention の低精度 MultiheadAttention が 経由する。

checkpoint／create_graph からの除外（TapeNode:: low_precision）: Op::MatMul は既定で is_checkpoint_ eligible() == true（activation checkpointing が解放し matmul_forward〈ops.gemm。常に f32〉で再計算してよい対象） かつ supports_create_graph() == true（create_graph が子 テープへ replay できる対象）だが、いずれも「精度情報を持たない Op::MatMul(a, b) のみから forward を再現する」ため、低精度 ノードをそのまま通すと静かに f32 精度へフォールバックしてしまう （fail-closed 方針違反。.claude/rules/security.md A04）。 matmul_fp32_strict が TapeNode::fp32_strict で checkpoint 除外するのと同型のノード単位フラグ（TapeNode::low_precision） を立てることで、①解放対象から除外（release_checkpoint_ region）②create_graph::validate_ancestors が祖先に含まれた 時点で無条件拒否、の 2 経路とも fail-closed に塞ぐ （create_graph.rs 側の拒否分岐 doc 参照）。

自由関数 crate::low_precision_ops::matmul_low_precision（イシュー #2628。elementwise 5 演算と同じ入口の並び）が本メソッドへ 1 行委譲 する。可視性は pub（イシュー #2678 で facade 公開を承認形どおりに実施。 委譲の向きは自由関数 → 本メソッドのまま変えない。本体を移すと再帰か大きな 移動になるため、決定記録 §6.5 の「自由関数への 1 行委譲」とは逆向き）。

pub fn conv_transpose2d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: [usize; 2], padding: [usize; 2], output_padding: [usize; 2], dilation: [usize; 2], groups: usize, ) -> Result<Var<'t>, AutodiffError>

2 次元転置畳み込み（torch.nn.functional.conv_transpose2d／ nn.ConvTranspose2d 相当。NCHW 固定。イシュー #2067・設計 docs/conv-ops-design.md §15）。self（input）: [N, Cin, H, W]・weight: [Cin, Cout/groups, kH, kW]（PyTorch nn.ConvTranspose2d.weight のレイアウト。Self::conv2d の [Cout, Cin/groups, kH, kW] と先頭 2 軸が逆な点に注意）・ bias: Some なら [Cout]。

意図的な PyTorch 非互換: output_padding[i] < stride[i] を要求する（PyTorch は output_padding < max(stride, dilation) まで許容）。3 バックエンド共通の BackendOps:: col2im override 契約（P 軸＝conv_out_len(Hout)· conv_out_len(Wout)）と、op >= stride では conv_out_len(Hout) ≠ H になり不整合を起こすため （fandhe_ai_tensor_core::conv_transpose_out_len doc 参照。 緩和は col2im の P 軸契約を conv_out_len から切り離す 拡張が必要でスコープ外）。

検査順序: ①check_same_tape → ②weight rank 4 検査 → ③weight.shape()[2..4] から kernel_size を導出し Conv2dParams::new（stride == 0 はここで拒否される。 output_padding 検査より先に置くことで stride=0 入力が output_padding 起因の誤ったエラーで拒否されるのを防ぐ）→ ④output_padding[i] < stride[i]（AutodiffError:: InvalidArgument）→ ⑤conv_transpose2d_out_shape で out_shape を確定（rank・チャンネル整合・空間軸 H／W = 0 拒否・op < s ゲート込み）→ ⑥bias shape 検査 → ⑦self／ weight／bias を実体化 → ⑧conv_transpose2d_with_fallback （grad 内非公開。§15「w_mat・x4・col2im」の段階的合成）→ ⑨戻り shape 検証（.claude/rules/security.md A08）→ ⑩push_eager（非融合・常実体化。col2im／im2col の中間 結果は保持せず backward で再計算する。Op::Conv2d（非公開）と同型）。

pub fn conv1d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: usize, padding: usize, dilation: usize, groups: usize, ) -> Result<Var<'t>, AutodiffError>

1 次元畳み込み（torch.nn.functional.conv1d 相当の cross-correlation）。Self::conv2d を H 軸固定 （kernel=1・stride=1・padding=0・dilation=1）で呼び出す reshape 併合の薄いラッパーであり、新規 Op／BackendOps メソッド・VJP・バックエンドカーネルは追加しない（設計 docs/conv-ops-design.md §2／§8・イシュー #1765）。self （input）: [N, Cin, L]・weight: [Cout, Cin/groups, k]・ bias: Some なら [Cout]。

検査順序（Var::reshape は view ノードを tape へ push する ため、reshape より前にすべての引数検査を完了させ Err 経路で 孤児ノードを残さない）: ①check_same_tape（weight／bias。 クロステープの weight を reshape すると相手 tape へ push して しまうため最初に行う）→ ②self／weight の rank 検査 （rank 3 以外は ShapeError::RankMismatch）→ ③ Conv2dParams::new（H 軸固定・W 軸に stride／ padding／dilation を渡す。stride／dilation／groups の 0・2 * padding オーバーフローを拒否）→ ④合成した 4d shape に対する fandhe_ai_tensor_core::conv2d_out_shape （チャンネル整合・L = 0 拒否・負分子拒否ゲート。純粋な shape 計算で tape 非接触）→ ⑤bias shape 検査 → ⑥ここで 初めて input／weight を [N, Cin, 1, L]／ [Cout, Cin/groups, 1, k] へ reshape し conv2d を呼ぶ （Self::contiguous 前段で Var::reshape の非 contiguous 拒否契約と conv2d〈transpose 済み入力も受理〉の間の非対称を 解消する）→ ⑦出力 [N, Cout, 1, Lout] を [N, Cout, Lout] へ reshape。

conv2d 内部で再検査される項目（rank・チャンネル整合等）は fail-closed の二重検査として許容する。conv2d 側のバックエンド 失敗（Unsupported 以外）で view ノードが残る点は他の eager 演算と同じ振る舞い。CUDA 専用 im2col／col2im カーネルは #1766／#1767 で到達済み・Metal 専用 im2col／col2im カーネルも #1768 で到達済み（いずれも新規 Op／BackendOps／カーネル なしの reshape 併合のため、conv2d 側の CUDA／Metal override へそのまま委譲される。Metal 経路の 1d 形状テスト（model・ ops・facade bit 一致）は #1769 で追加済み。CUDA／Metal 実機 実測は #1771 へ申し送り）。nn::Conv1d 層・ compat::Sequential::add_conv1d は対象外（#1770 へ引き継ぐ）。

pub fn max_pool2d( &self, kernel_size: [usize; 2], stride: Option<[usize; 2]>, padding: [usize; 2], dilation: [usize; 2], ceil_mode: bool, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

2 次元 max pooling（torch.nn.functional.max_pool2d 相当。 NCHW 固定。イシュー #1728・設計 docs/pooling-ops-design.md）。 self（input）: [N, C, H, W]。戻り値は (values, index) で、index（(n,c) 平面内 flat 添字 h·W+w）は Var::topk と同様に追跡外の Tensor<i32> として公開する。

検査順序（設計 doc §3・§5）: ①ceil_mode == true を AutodiffError::InvalidArgument で拒否（v1 は false のみ） → ②Pool2dParams::new（kernel_size／stride／dilation の 0・padding 上限〈padding <= kernel/2〉超過を BackendError::InvalidArgument → AutodiffError::Backend で 拒否）→ ③pool2d_out_shape（rank・空間軸ゼロ拒否・負分子 拒否ゲート・空窓拒否。AutodiffError::Shape）→ ④ H·W <= i32::MAX（索引は i32 のため。Var::sort／topk にはない Max 固有の追加検査）→ ⑤self を層 1 で実体化 （RefCell 借用を閉じてから push）→ ⑥ max_pool2d_with_fallback → ⑦戻り shape 再検証 （.claude/rules/security.md A08）→ ⑧push_eager （非融合・常実体化）。

pub fn max_pool1d( &self, kernel_size: usize, stride: Option<usize>, padding: usize, dilation: usize, ceil_mode: bool, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

1 次元 max pooling。Self::max_pool2d を H 軸固定 （kernel=1・stride=1・padding=0・dilation=1）で呼び出す reshape 併合の薄いラッパー（Self::conv1d と同型。イシュー #1728）。self（input）: [N, C, L]。索引は H=1 のため flat w そのもの。

pub fn avg_pool2d( &self, kernel_size: [usize; 2], stride: Option<[usize; 2]>, padding: [usize; 2], ceil_mode: bool, count_include_pad: bool, ) -> Result<Var<'t>, AutodiffError>

2 次元 average pooling（torch.nn.functional.avg_pool2d 相当。NCHW 固定。イシュー #1728・設計 docs/pooling-ops- design.md）。self（input）: [N, C, H, W]。

検査順序: ①ceil_mode == true を AutodiffError:: InvalidArgument で拒否 → ②Pool2dParams::new（dilation は常に [1, 1] 固定で構築する。設計 doc §2「Avg 系は dilation=[1,1] 固定」）→ ③pool2d_out_shape → ④実体化 → ⑤avg_pool2d_with_fallback → ⑥戻り shape 再検証 → ⑦push_eager。

pub fn avg_pool1d( &self, kernel_size: usize, stride: Option<usize>, padding: usize, ceil_mode: bool, count_include_pad: bool, ) -> Result<Var<'t>, AutodiffError>

1 次元 average pooling。Self::avg_pool2d を H 軸固定で 呼び出す reshape 併合の薄いラッパー（Self::max_pool1d と 同型。イシュー #1728）。self（input）: [N, C, L]。

pub fn adaptive_avg_pool2d( &self, output_size: [usize; 2], ) -> Result<Var<'t>, AutodiffError>

2 次元 adaptive average pooling（torch.nn.functional. adaptive_avg_pool2d 相当。NCHW 固定。イシュー #1728・設計 docs/pooling-ops-design.md）。self（input）: [N, C, H, W]・output_size: [Hout, Wout]。

検査順序: ①adaptive_pool2d_out_shape（rank・空間軸ゼロ 拒否・output_size >= 1）→ ②実体化 → ③ adaptive_avg_pool2d_with_fallback → ④戻り shape 再検証 → ⑤push_eager。

pub fn adaptive_avg_pool1d( &self, output_size: usize, ) -> Result<Var<'t>, AutodiffError>

1 次元 adaptive average pooling。Self::adaptive_avg_pool2d を H 軸固定（output_size[0]=1）で呼び出す reshape 併合の 薄いラッパー（イシュー #1728）。self（input）: [N, C, L]。

pub fn adaptive_max_pool2d( &self, output_size: [usize; 2], ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

2 次元 adaptive max pooling（PyTorch F.adaptive_max_pool2d(..., return_indices=True) 相当。NCHW 固定。イシュー #2527・設計 docs/autodiff-adaptive-max-global-pool-decision.md §8）。 戻り値は (values, index) で、index は (n, c) 平面内の flat 添字 h·W+w（Self::max_pool2d と同じ意味論）。

self: [N, C, H, W]・output_size: [Hout, Wout]。rank 不一致・ output_size の 0・空間軸ゼロ・H·W > i32::MAX は Err。検査は tape 操作より前に完了するため Err で孤児ノードを残さない。 本体は非公開モジュール adaptive_max_pool_ops の共有 forward （nn::AdaptiveMaxPool2d と共通）への 1 行委譲。

pub fn adaptive_max_pool1d( &self, output_size: usize, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

1 次元 adaptive max pooling（Self::adaptive_max_pool2d の H 軸固定版。イシュー #2527）。self: [N, C, L]。index は l 軸の flat 添字。エラー条件・検査順序は 2d 版と同じ。

pub fn split_with_sizes( &self, sizes: &[usize], dim: usize, ) -> Result<Vec<Var<'t>>, AutodiffError>

指定した各長さ（sizes）で dim 軸を分割する（torch.split の list 形式相当。イシュー #1598）。各出力は Self::narrow （zero-copy view）。

sizes.iter().sum()（checked_add）が shape[dim] と一致しな い場合 ShapeError::ShapeMismatch { lhs: [shape[dim]], rhs: [sum] } を返す。

pub fn split( &self, split_size: usize, dim: usize, ) -> Result<Vec<Var<'t>>, AutodiffError>

先頭から split_size 刻みで dim 軸を分割する（torch.split の int 形式相当。末尾は端数。イシュー #1598）。

split_size == 0 は shape[dim] の値に依らず一律 AutodiffError::InvalidArgument（PyTorch は shape[dim] == 0 のとき許容するが、0 除算相当の分岐を持たない単純な契約を 優先する）。shape[dim] == 0 かつ split_size > 0 は PyTorch と同じく [narrow(dim, 0, 0)] の 1 要素を返す。

pub fn chunk( &self, chunks: usize, dim: usize, ) -> Result<Vec<Var<'t>>, AutodiffError>

dim 軸を chunks 個以下に分割する（torch.chunk 相当。 イシュー #1598）。chunk_size = ceil(shape[dim] / chunks) （div_ceil）を Self::split へ委譲する。

chunks == 0 は AutodiffError::InvalidArgument。 shape[dim] == 0 は chunk_size が 0 になり split の split_size == 0 規則と衝突するため、split へ委譲せず PyTorch と同じく chunks 個の空 narrow(dim, 0, 0) を返す （Self::split_with_sizes へ [0; chunks] を渡す）。

pub fn where_cond( cond: &Tensor<bool>, a: &Var<'t>, b: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

条件テンソル cond で a／b を要素選択する（torch.where 相当。イシュー #1637）。関連関数（cond が Var ではなく &Tensor<bool> のため。Var::cat と同様の位置づけ）。 #[doc(alias = "where")] は Rust 予約語 where の代替名として 検索性を確保する目的。

出力 shape は a・b・cond 3 入力の共通 broadcast 形状 とする（cond 単独が軸を拡張するケース、例えば a／b が [3]・cond が [2, 1] で出力 [2, 3] になるケースを含む。 codex-review 指摘・PR #1684）。

手順: ①a.check_same_tape(b) → ②out_shape = broadcast_shape(broadcast_shape(a.shape, b.shape), cond.shape) → ③cond を out_shape へ broadcast（不可なら AutodiffError::Shape）→ ④bool→f32 変換（out_shape ちょうど の contiguous テンソルへ 1 回だけ実体化。 fandhe_ai_tensor_core::BackendOps::where_cond doc の f32 マスク契約）→ ⑤a／b を層 1 で実体化（RefCell 借用を 閉じてから push_eager を呼ぶ規律。Var::cat と同型）→ ⑥ops.where_cond → Unsupported のときのみホスト参照実装 （eval::where_cond）へフォールバック → ⑦戻り shape 検証 （.claude/rules/security.md A08）→ ⑧push_eager。

backward（where_vjp）は a／b の勾配を out_shape から 元の a_shape／b_shape（cond を含まない）へ reduce_to_shape で縮約するため、cond 由来の拡張軸は Op::Mul 等の一般 broadcast VJP と同じ経路で正しく縮約される。

pub fn masked_fill( &self, mask: &Tensor<bool>, value: f32, ) -> Result<Var<'t>, AutodiffError>

mask が真の位置を定数 value で置換する（torch.masked_fill 相当。イシュー #1637）。メソッド（self を書き換えず新しい Var を返す）。mask は self の shape へ broadcast 可能で あること（Var::where_cond と同じ bool→f32 変換規律）。

pub fn dropout(&self, p: f32, training: bool) -> Result<Var<'t>, AutodiffError>

dropout（torch.nn.functional.dropout(input, p, training) 相当。イシュー #1603）。要素ごと独立に確率 p で 0 へ落とし、 残す要素は 1/(1-p) 倍する（inverted dropout。学習時と推論時で 期待値のスケールを揃える PyTorch と同じ規約）。

早期リターン（Op を記録しない・RNG を消費しない）

training == false または p == 0.0 のときは self をそのまま 返す（at::native::dropout の if (p == 0 || !train) return input; と同じ。crate::tensor_core::rng::with_global_rng を 一切呼ばないため、eval モード下ではグローバル RNG の状態が dropout 呼び出しの有無で変化しない）。

マスク生成（イシュー #1602 のグローバル RNG 契約）

crate::grad::dropout_mask が [fandhe_ai_tensor_core::rng:: rand] を経由してホスト側だけでマスクを生成する（BackendOps を経由しない。docs/rng-global-contract-design.md §3.2）。

エラー

p が非有限、または [0, 1] の範囲外の場合 AutodiffError::InvalidArgument。

pub fn gather( &self, dim: usize, index: &Tensor<i32>, ) -> Result<Var<'t>, AutodiffError>

dim 軸に沿って index が指す要素を独立に読み出す （torch.gather 相当。イシュー #1776）。index（Tensor<i32>） は非追跡データ（Var::cross_entropy_loss の targets と同じ 「Op payload に直接埋め込む」設計。勾配は index 側には 流れない）。

検査順序: ①fandhe_ai_tensor_core::gather_out_shape（dim 範囲・index の rank・dim 以外の軸一致を検査し out_shape を確定。違反は AutodiffError::Shape）→ ②index 全添字が 0 <= idx < self.shape()[dim]（違反は AutodiffError::InvalidArgument。cross_entropy_loss の targets 範囲検査と同じパターン）→ ③index を実体化 （contiguous()。Op::Where の cond と同じ「1 回だけ 実体化し以後再計算しない」方針）→ ④self を層 1 で実体化 → ⑤ops.gather → Unsupported のときのみホスト参照実装 （eval::gather）へフォールバック → ⑥戻り shape 検証 （.claude/rules/security.md A08）→ ⑦push_eager。

pub fn interpolate( &self, size: &[usize], mode: InterpolateMode, ) -> Result<Var<'t>, AutodiffError>

空間軸（末尾 size.len() 軸）を size へリサンプリングする （torch.nn.functional.interpolate／tf.image.resize 相当。 イシュー #1757・#1762・#2152）。先頭の残り軸（batch／channel 等）は素通し。mode の意味論・数値契約は fandhe_ai_tensor_core::InterpolateMode doc を正とする （Nearest／NearestExact は算術を含まない純粋なコピー演算 のため forward は 3 バックエンド間で構造的に bit 完全一致・ それ以外〈Bilinear／Linear／Trilinear／Bicubic／ Area〉は REQ-2 統一複合判定）。scale_factor 引数は持たず、 fandhe_ai_tensor_core::interpolate_size_from_scale_factor が 導出した size をそのまま渡す設計（イシュー #2152 の配置 判断。docs/autodiff-interpolate-modes-decision.md §3.6）。

検査順序: ①fandhe_ai_tensor_core::interpolate_out_shape_for_mode （size の rank〈mode 別の空間軸数要求を含む〉・空間軸の 0 サイズ・要素数オーバーフローを検査し out_shape を確定。 違反は AutodiffError::Shape）→ ②self を層 1 で実体化 → ③ops.interpolate → Unsupported のときのみホスト参照実装 （eval::interpolate_*。mode ごとに分岐）へフォールバック （それ以外のエラーは伝播する。判定迂回経路を作らない）→ ④戻り shape 検証（.claude/rules/security.md A08）→ ⑤push_eager。

pub fn index_select( &self, dim: usize, index: &Tensor<i32>, ) -> Result<Var<'t>, AutodiffError>

1 次元 index で dim 軸を選択する（torch.index_select 相当。イシュー #1776）。専用 Op は持たず、index（[k]）を self.shape() と同 rank の stride-0 view（reshape して dim 軸のみ k・他軸 1 にしたあと broadcast_to で self.shape() の dim 軸だけ k に置き換えた形へ拡張。 いずれも zero-copy）へ拡張してから Self::gather へ委譲する （検査・VJP・Op 構築を 1 箇所に集約し重複を避ける設計判断。 実装計画「設計判断」§1 参照）。index は rank 1 でなければ AutodiffError::Shape(ShapeError::RankMismatch)。

pub fn l1_loss( &self, target: &Var<'t>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

L1 損失（torch.nn.L1Loss 相当。イシュー #2166・#2538）。 crate::loss_ops::l1_loss へ委譲する。テープ不一致・shape 不一致は型付き エラーで拒否する。

pub fn cross_entropy_loss_with( &self, targets: &Tensor<i32>, class_dim: usize, reduction: Reduction, options: &CrossEntropyOptions, ) -> Result<Var<'t>, AutodiffError>

label_smoothing・ignore_index・class_weight 付き CrossEntropy （torch.nn.CrossEntropyLoss(label_smoothing=, ignore_index=, weight=) 相当。 イシュー #2166・#2538）。crate::loss_ops::cross_entropy_loss_with へ委譲する。 options が既定値なら Self::cross_entropy_loss へ丸ごと委譲される（R3）。

pub fn cosine_embedding_loss( &self, x2: &Var<'t>, y: &Tensor<f32>, margin: f32, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

コサイン埋め込み損失（torch.nn.CosineEmbeddingLoss 相当。self が x1。 イシュー #2167・#2539）。crate::loss_ops::cosine_embedding_loss へ委譲する。 テープ不一致・shape 不一致・y が ±1 以外・margin 非有限は型付きエラーで 拒否する。PyTorch との差分は決定記録 docs/autodiff-distance-poisson-loss-ops-decision.md §3 参照。

pub fn margin_ranking_loss( &self, x2: &Var<'t>, y: &Tensor<f32>, margin: f32, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

マージンランキング損失（torch.nn.MarginRankingLoss 相当。self が x1。 イシュー #2167・#2539）。crate::loss_ops::margin_ranking_loss へ委譲する。 テープ不一致・shape 不一致・y が ±1 以外・margin 非有限は型付きエラーで拒否する。

pub fn hinge_embedding_loss( &self, y: &Tensor<f32>, margin: f32, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

HingeEmbedding 損失（torch.nn.functional.hinge_embedding_loss 相当。self が input、 y は非追跡で同 shape・厳密に ±1）。crate::elementwise_loss_ops::hinge_embedding_loss へ 1 行委譲する。reduction は fandhe_ai::nn::loss::Reduction。

pub fn soft_margin_loss( &self, y: &Tensor<f32>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

SoftMargin 損失（torch.nn.functional.soft_margin_loss 相当。y は非追跡で同 shape・ 厳密に ±1）。crate::elementwise_loss_ops::soft_margin_loss へ 1 行委譲する。 reduction は fandhe_ai::nn::loss::Reduction。

pub fn multilabel_margin_loss( &self, target: &Tensor<i32>, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

MultiLabelMargin 損失（torch.nn.functional.multilabel_margin_loss 相当。target は self と同 shape のクラス添字で、行ごとに最初の負値の手前までが target 列）。 crate::margin_focal_loss_ops::multilabel_margin_loss へ 1 行委譲する。 reduction は fandhe_ai::nn::loss::Reduction。

pub fn bce_with_logits_loss_with( &self, target: &Var<'t>, reduction: Reduction, options: &BceWithLogitsOptions, ) -> Result<Var<'t>, AutodiffError>

BCE-with-logits 損失のオプション指定版（torch.nn.functional.binary_cross_entropy_with_logits 相当。self が logits、target は追跡対象の同 shape）。 crate::elementwise_loss_ops::bce_with_logits_loss_with へ 1 行委譲する。 引数順は (target, reduction, options) で、他の 4 本と異なる。オプション型は fandhe_ai::nn::loss::BceWithLogitsOptions、reduction は fandhe_ai::nn::loss::Reduction。

pub fn gaussian_nll_loss( &self, target: &Var<'t>, var: &Var<'t>, options: &GaussianNllOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

ガウス負の対数尤度損失（torch.nn.functional.gaussian_nll_loss 相当。self が input、 target・var は追跡対象）。crate::elementwise_loss_ops::gaussian_nll_loss へ 1 行委譲する。 オプション型は fandhe_ai::nn::loss::GaussianNllOptions、reduction は fandhe_ai::nn::loss::Reduction。

pub fn multi_margin_loss( &self, target: &Tensor<i32>, options: &MultiMarginOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

MultiMargin 損失（torch.nn.functional.multi_margin_loss 相当。target はクラス添字）。 crate::margin_focal_loss_ops::multi_margin_loss へ 1 行委譲する。オプション型は fandhe_ai::nn::loss::MultiMarginOptions、reduction は fandhe_ai::nn::loss::Reduction。

pub fn multilabel_soft_margin_loss( &self, target: &Tensor<f32>, options: &MultiLabelSoftMarginOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

MultiLabelSoftMargin 損失（torch.nn.functional.multilabel_soft_margin_loss 相当。 target は同 shape の 0／1）。crate::margin_focal_loss_ops::multilabel_soft_margin_loss へ 1 行委譲する。オプション型は fandhe_ai::nn::loss::MultiLabelSoftMarginOptions、reduction は fandhe_ai::nn::loss::Reduction。

pub fn sigmoid_focal_loss( &self, target: &Tensor<f32>, options: &SigmoidFocalLossOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

Sigmoid focal 損失（torchvision.ops.sigmoid_focal_loss 相当。target は同 shape の 0／1）。 crate::margin_focal_loss_ops::sigmoid_focal_loss へ 1 行委譲する。オプション型は fandhe_ai::nn::loss::SigmoidFocalLossOptions、reduction は fandhe_ai::nn::loss::Reduction。

pub fn triplet_margin_loss( &self, positive: &Var<'t>, negative: &Var<'t>, options: &TripletMarginOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

トリプレットマージン損失（torch.nn.TripletMarginLoss 相当。self が anchor。 イシュー #2167・#2539）。crate::loss_ops::triplet_margin_loss へ委譲する。 テープ不一致・shape 不一致・p < 1・eps 負などは型付きエラーで拒否する。

pub fn poisson_nll_loss( &self, target: &Var<'t>, options: &PoissonNllOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

Poisson 負の対数尤度損失（torch.nn.PoissonNLLLoss 相当。self が input。 イシュー #2167・#2539）。crate::loss_ops::poisson_nll_loss へ委譲する。 テープ不一致・shape 不一致・eps 不正は型付きエラーで拒否する。

pub fn ctc_loss( &self, targets: &Tensor<i32>, input_lengths: &[usize], target_lengths: &[usize], options: &CtcLossOptions, reduction: Reduction, ) -> Result<Var<'t>, AutodiffError>

CTC 損失（torch.nn.CTCLoss 相当。self が log_probs〈[T, N, C]〉。 イシュー #2168・#2540）。crate::loss_ops::ctc_loss へ委譲する。 rank／長さ不一致・blank >= C・target 値域外・確保前上限超過は型付きエラーで拒否する。 数式・VJP 規約・PyTorch との差分は docs/autodiff-ctc-design.md 参照。

pub fn mish(&self) -> Result<Var<'t>, AutodiffError>

Mish（x * tanh(softplus(x))。torch.nn.functional.mish 相当。イシュー #2146・#2516）。crate::activation_ops::mish へ委譲する。

pub fn hardtanh(&self, min: f32, max: f32) -> Result<Var<'t>, AutodiffError>

[min, max] へのクランプ（torch.nn.functional.hardtanh 相当。イシュー #2146・#2516）。crate::activation_ops::hardtanh へ委譲する。NaN または min >= max は AutodiffError::InvalidArgument で拒否する。

pub fn relu6(&self) -> Result<Var<'t>, AutodiffError>

[0, 6] へのクランプ（torch.nn.functional.relu6 相当。イシュー #2146・#2516）。crate::activation_ops::relu6 へ委譲する。

pub fn prelu(&self, weight: &Var<'t>) -> Result<Var<'t>, AutodiffError>

PReLU（torch.nn.functional.prelu 相当。イシュー #2146・#2516）。 crate::activation_ops::prelu へ委譲する。weight の rank・チャネル数 不一致は Shape、要素数 0 は InvalidArgument で拒否する。

pub fn glu(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

GLU（torch.nn.functional.glu 相当。イシュー #2146・#2516）。 crate::activation_ops::glu へ委譲する。範囲外の軸は Shape、奇数長は InvalidArgument で拒否する。

pub fn rfft( &self, n: Option<usize>, dim: Option<usize>, norm: FftNorm, ) -> Result<Var<'t>, AutodiffError>

実入力の片側 FFT（torch.fft.rfft 相当）。イシュー #2678。crate::fft_ops::rfft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn irfft( &self, n: Option<usize>, dim: Option<usize>, norm: FftNorm, ) -> Result<Var<'t>, AutodiffError>

片側スペクトルから実信号への逆 FFT（torch.fft.irfft 相当）。イシュー #2678。crate::fft_ops::irfft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn fft( &self, n: Option<usize>, dim: Option<usize>, norm: FftNorm, ) -> Result<Var<'t>, AutodiffError>

実入力の全域 FFT（torch.fft.fft 相当）。イシュー #2678。crate::fft_ops::fft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn ifft( &self, n: Option<usize>, dim: Option<usize>, norm: FftNorm, ) -> Result<Var<'t>, AutodiffError>

全域 FFT の逆変換（torch.fft.ifft 相当）。イシュー #2678。crate::fft_ops::ifft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn stft( &self, n_fft: usize, window: Option<&Tensor<f32>>, options: &StftOptions, ) -> Result<Var<'t>, AutodiffError>

短時間 FFT（torch.stft 相当）。イシュー #2678。crate::fft_ops::stft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn istft( &self, n_fft: usize, window: Option<&Tensor<f32>>, options: &IstftOptions, ) -> Result<Var<'t>, AutodiffError>

短時間 FFT の逆変換（torch.istft 相当）。イシュー #2678。crate::fft_ops::istft へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn add_low_precision( &self, other: &Var<'t>, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

elementwise 加算の opt-in 低精度 forward。イシュー #2678。crate::low_precision_ops::add_low_precision へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn mul_low_precision( &self, other: &Var<'t>, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

elementwise 乗算の opt-in 低精度 forward。イシュー #2678。crate::low_precision_ops::mul_low_precision へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn relu_low_precision( &self, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

ReLU の opt-in 低精度 forward。イシュー #2678。crate::low_precision_ops::relu_low_precision へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn exp_low_precision( &self, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

exp の opt-in 低精度 forward。イシュー #2678。crate::low_precision_ops::exp_low_precision へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tanh_low_precision( &self, dtype: ScalarDType, ) -> Result<Var<'t>, AutodiffError>

tanh の opt-in 低精度 forward。イシュー #2678。crate::low_precision_ops::tanh_low_precision へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn atan(&self) -> Result<Var<'t>, AutodiffError>

逆正接（torch.atan 相当）。イシュー #2678。crate::trig_ops::atan へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn asin(&self) -> Result<Var<'t>, AutodiffError>

逆正弦（torch.asin 相当）。定義域外は NaN。イシュー #2678。crate::trig_ops::asin へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn acos(&self) -> Result<Var<'t>, AutodiffError>

逆余弦（torch.acos 相当）。定義域外は NaN。イシュー #2678。crate::trig_ops::acos へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn sinh(&self) -> Result<Var<'t>, AutodiffError>

双曲線正弦（torch.sinh 相当）。イシュー #2678。crate::trig_ops::sinh へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn cosh(&self) -> Result<Var<'t>, AutodiffError>

双曲線余弦（torch.cosh 相当）。イシュー #2678。crate::trig_ops::cosh へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn asinh(&self) -> Result<Var<'t>, AutodiffError>

逆双曲線正弦（torch.asinh 相当）。イシュー #2678。crate::trig_ops::asinh へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn acosh(&self) -> Result<Var<'t>, AutodiffError>

逆双曲線余弦（torch.acosh 相当）。イシュー #2678。crate::trig_ops::acosh へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn atanh(&self) -> Result<Var<'t>, AutodiffError>

逆双曲線正接（torch.atanh 相当）。イシュー #2678。crate::trig_ops::atanh へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn atan2(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

2 引数逆正接（torch.atan2(self, other) 相当。self が y・other が x）。イシュー #2678。crate::trig_ops::atan2 へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn isnan(&self) -> Result<Tensor<bool>, AutodiffError>

NaN 判定（torch.isnan 相当）。イシュー #2678。crate::nonfinite_ops::isnan へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn isinf(&self) -> Result<Tensor<bool>, AutodiffError>

±inf 判定（torch.isinf 相当）。イシュー #2678。crate::nonfinite_ops::isinf へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn isfinite(&self) -> Result<Tensor<bool>, AutodiffError>

有限値判定（torch.isfinite 相当）。イシュー #2678。crate::nonfinite_ops::isfinite へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn nan_to_num( &self, nan: Option<f32>, posinf: Option<f32>, neginf: Option<f32>, ) -> Result<Var<'t>, AutodiffError>

NaN・±inf の置換（torch.nan_to_num 相当）。イシュー #2678。crate::nonfinite_ops::nan_to_num へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn cummax( &self, dim: usize, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

指定軸の累積最大値と索引（torch.cummax 相当）。イシュー #2678。crate::cumulative_ops::cummax へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn cummin( &self, dim: usize, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

指定軸の累積最小値と索引（torch.cummin 相当）。イシュー #2678。crate::cumulative_ops::cummin へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn logcumsumexp(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

指定軸の累積 log-sum-exp（torch.logcumsumexp 相当）。イシュー #2678。crate::cumulative_ops::logcumsumexp へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn median(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

中央値（torch.median 相当。偶数個は下側）。イシュー #2678。crate::stat_reduce_ops::median へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn median_with_indices( &self, dim: usize, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

指定軸の中央値と索引（torch.median(dim) 相当）。イシュー #2678。crate::stat_reduce_ops::median_with_indices へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn kthvalue( &self, k: usize, dim: usize, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

指定軸の k 番目に小さい値と索引（torch.kthvalue 相当）。イシュー #2678。crate::stat_reduce_ops::kthvalue へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn quantile( &self, q: f32, dim: Option<usize>, interpolation: QuantileInterpolation, ) -> Result<Var<'t>, AutodiffError>

分位数（torch.quantile 相当）。イシュー #2678。crate::stat_reduce_ops::quantile へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn nanmean(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

NaN を無視した平均（torch.nanmean 相当）。イシュー #2678。crate::stat_reduce_ops::nanmean へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn nansum(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

NaN を無視した総和（torch.nansum 相当）。イシュー #2678。crate::stat_reduce_ops::nansum へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn histc( &self, bins: usize, min: f32, max: f32, ) -> Result<Tensor<f32>, AutodiffError>

等幅ヒストグラム（torch.histc 相当）。イシュー #2678。crate::binning_ops::histc へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn searchsorted( &self, values: &Var<'t>, right: bool, ) -> Result<Tensor<i32>, AutodiffError>

self を昇順列として values の挿入位置を求める（torch.searchsorted 相当）。イシュー #2678。crate::binning_ops::searchsorted へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn bucketize( &self, boundaries: &Var<'t>, right: bool, ) -> Result<Tensor<i32>, AutodiffError>

self の各要素の所属バケット索引（torch.bucketize 相当）。イシュー #2678。crate::binning_ops::bucketize へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn unbind(&self, dim: usize) -> Result<Vec<Var<'t>>, AutodiffError>

指定軸で分解する（torch.unbind 相当）。イシュー #2678。crate::shape_view_ops::unbind へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tensor_split( &self, sections: usize, dim: usize, ) -> Result<Vec<Var<'t>>, AutodiffError>

指定軸を sections 個へ分割する（torch.tensor_split 相当）。イシュー #2678。crate::shape_view_ops::tensor_split へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tensor_split_indices( &self, indices: &[usize], dim: usize, ) -> Result<Vec<Var<'t>>, AutodiffError>

指定軸を境界索引で分割する（torch.tensor_split の索引版）。イシュー #2678。crate::shape_view_ops::tensor_split_indices へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn movedim( &self, source: &[usize], destination: &[usize], ) -> Result<Var<'t>, AutodiffError>

軸の移動（torch.movedim 相当）。イシュー #2678。crate::shape_view_ops::movedim へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn swapaxes( &self, axis0: usize, axis1: usize, ) -> Result<Var<'t>, AutodiffError>

2 軸の入れ替え（torch.swapaxes 相当）。イシュー #2678。crate::shape_view_ops::swapaxes へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn rot90( &self, k: isize, dims: [usize; 2], ) -> Result<Var<'t>, AutodiffError>

90 度回転（torch.rot90 相当）。イシュー #2678。crate::shape_view_ops::rot90 へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn scatter_reduce( &self, dim: usize, index: &Tensor<i32>, src: &Var<'t>, reduce: ScatterReduceMode, include_self: bool, ) -> Result<Var<'t>, AutodiffError>

縮約付き scatter（torch.scatter_reduce 相当）。イシュー #2678。crate::indexed_update_ops::scatter_reduce へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn index_add( &self, dim: usize, index: &Tensor<i32>, source: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

索引加算（torch.index_add 相当。alpha は持たない）。イシュー #2678。crate::indexed_update_ops::index_add へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn index_copy( &self, dim: usize, index: &Tensor<i32>, source: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

索引コピー（torch.index_copy 相当）。イシュー #2678。crate::indexed_update_ops::index_copy へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn masked_scatter( &self, mask: &Tensor<bool>, source: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

マスク位置へ source を順に書き込む（torch.masked_scatter 相当）。イシュー #2678。crate::indexed_update_ops::masked_scatter へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn kron(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

クロネッカー積（torch.kron 相当）。イシュー #2678。crate::tensor_product_ops::kron へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tensordot( &self, other: &Var<'t>, n: usize, ) -> Result<Var<'t>, AutodiffError>

末尾 n 軸と先頭 n 軸の縮約（torch.tensordot(dims=n) 相当）。イシュー #2678。crate::tensor_product_ops::tensordot へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tensordot_axes( &self, other: &Var<'t>, dims_self: &[usize], dims_other: &[usize], ) -> Result<Var<'t>, AutodiffError>

軸指定の縮約（torch.tensordot(dims=(a, b)) 相当）。イシュー #2678。crate::tensor_product_ops::tensordot_axes へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn cdist(&self, other: &Var<'t>, p: f32) -> Result<Var<'t>, AutodiffError>

p ノルムの総当たり距離（torch.cdist 相当）。イシュー #2678。crate::tensor_product_ops::cdist へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn cross( &self, other: &Var<'t>, dim: usize, ) -> Result<Var<'t>, AutodiffError>

3 次元ベクトルの外積（torch.linalg.cross 相当）。イシュー #2678。crate::tensor_product_ops::cross へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn pad_with_mode( &self, pads: &[(usize, usize)], mode: PadMode, ) -> Result<Var<'t>, AutodiffError>

モード指定パディング（torch.nn.functional.pad のモード版）。イシュー #2678。crate::pad_ops::pad_with_mode へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn max_pool3d( &self, kernel_size: [usize; 3], stride: Option<[usize; 3]>, padding: [usize; 3], dilation: [usize; 3], ceil_mode: bool, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

3D 最大プーリング（torch.nn.functional.max_pool3d 相当）。イシュー #2850。crate::pool3d_ops::max_pool3d へ 1 行委譲する。 索引は (n, c) 平面内 flat 添字の Tensor<i32> で、max_unpool3d へそのまま渡せる。引数検査・エラー契約（ceil_mode = true は型付きエラー）は委譲先に従う。

pub fn avg_pool3d( &self, kernel_size: [usize; 3], stride: Option<[usize; 3]>, padding: [usize; 3], ceil_mode: bool, count_include_pad: bool, ) -> Result<Var<'t>, AutodiffError>

3D 平均プーリング（torch.nn.functional.avg_pool3d 相当）。イシュー #2850。crate::pool3d_ops::avg_pool3d へ 1 行委譲する。 引数検査・エラー契約（ceil_mode = true は型付きエラー）は委譲先に従う。

pub fn conv_transpose3d( &self, weight: &Var<'t>, bias: Option<&Var<'t>>, stride: [usize; 3], padding: [usize; 3], output_padding: [usize; 3], dilation: [usize; 3], groups: usize, ) -> Result<Var<'t>, AutodiffError>

3D 転置畳み込み（torch.nn.functional.conv_transpose3d 相当）。イシュー #2850。crate::conv_transpose3d_ops::conv_transpose3d へ 1 行委譲する。 引数検査・エラー契約（output_padding >= stride 拒否等）は委譲先に従う。

pub fn max_unpool1d( &self, indices: &Tensor<i32>, kernel_size: usize, stride: Option<usize>, padding: usize, output_size: Option<usize>, ) -> Result<Var<'t>, AutodiffError>

1D MaxUnpool（torch.nn.functional.max_unpool1d 相当）。イシュー #2850。crate::max_unpool_ops::max_unpool1d へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn max_unpool2d( &self, indices: &Tensor<i32>, kernel_size: [usize; 2], stride: Option<[usize; 2]>, padding: [usize; 2], output_size: Option<[usize; 2]>, ) -> Result<Var<'t>, AutodiffError>

2D MaxUnpool（torch.nn.functional.max_unpool2d 相当）。イシュー #2850。crate::max_unpool_ops::max_unpool2d へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn max_unpool3d( &self, indices: &Tensor<i32>, kernel_size: [usize; 3], stride: Option<[usize; 3]>, padding: [usize; 3], output_size: Option<[usize; 3]>, ) -> Result<Var<'t>, AutodiffError>

3D MaxUnpool（torch.nn.functional.max_unpool3d 相当）。イシュー #2850。crate::max_unpool_ops::max_unpool3d へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn unfold( &self, kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ) -> Result<Var<'t>, AutodiffError>

torch.nn.functional.unfold（nn.Unfold）相当の列展開。torch.Tensor.unfold（次元方向のスライディング窓）とは別の演算である。 [N, C, H, W] を [N, C·kH·kW, L] へ展開する。引数順は crate 内 conv2d 系（kernel_size, stride, padding, dilation）で、 PyTorch の dilation, padding, stride 順ではない。バッチなし入力は非対応、C = 0 は受理する。 イシュー #2851。crate::fold_ops::unfold へ 1 行委譲し、引数検査・エラー契約は委譲先に従う。

pub fn fold( &self, output_size: [usize; 2], kernel_size: [usize; 2], stride: [usize; 2], padding: [usize; 2], dilation: [usize; 2], ) -> Result<Var<'t>, AutodiffError>

torch.nn.functional.fold（nn.Fold）相当。[N, C·kH·kW, L] を [N, C, H, W] へ戻し、重なる窓は加算する。 output_size が先頭引数。イシュー #2851。crate::fold_ops::fold へ 1 行委譲し、引数検査・エラー契約は委譲先に従う。

pub fn local_response_norm( &self, size: usize, alpha: f32, beta: f32, k: f32, ) -> Result<Var<'t>, AutodiffError>

torch.nn.functional.local_response_norm 相当。非有限パラメータは拒否する。 イシュー #2851。crate::lrn_ops::local_response_norm へ 1 行委譲し、引数検査・エラー契約は委譲先に従う。

pub fn weight_norm( &self, g: &Var<'t>, dim: Option<usize>, ) -> Result<Var<'t>, AutodiffError>

torch.nn.utils.weight_norm 相当（w = g · v / ‖v‖）。self が v。 g の shape は dim = Some(d) なら d 軸以外が長さ 1 の keepdim 形、dim = None なら rank 0 で、完全一致のみ受理する （決定記録 §12.3）。norm_except_dim は公開していないため、初期値の g は利用者が自前で用意する。 イシュー #2851。crate::weight_reparam_ops::weight_norm へ 1 行委譲し、引数検査・エラー契約は委譲先に従う。

pub fn spectral_norm( &self, state: &mut SpectralNormState, training: bool, ) -> Result<Var<'t>, AutodiffError>

torch.nn.utils.spectral_norm 相当。self が weight。training = true のときだけ state を更新し、失敗時は状態不変。 勾配は weight のみへ流れる。乱数初期化は行わない（PyTorch の予備反復は power_iterate(weight, 15) で再現する）。rank 1 は非対応。 イシュー #2851。crate::weight_reparam_ops::spectral_norm へ 1 行委譲し、引数検査・エラー契約は委譲先に従う。

pub fn selu(&self) -> Result<Var<'t>, AutodiffError>

SELU（torch.nn.functional.selu 相当）。イシュー #2678。crate::activation_scalar_ops::selu へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn celu(&self, alpha: f32) -> Result<Var<'t>, AutodiffError>

CELU（torch.nn.functional.celu 相当）。alpha はゼロでない有限値（負値も受理）。イシュー #2678。crate::activation_scalar_ops::celu へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn softsign(&self) -> Result<Var<'t>, AutodiffError>

Softsign（torch.nn.functional.softsign 相当）。イシュー #2678。crate::activation_scalar_ops::softsign へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn hardsigmoid(&self) -> Result<Var<'t>, AutodiffError>

Hardsigmoid（torch.nn.functional.hardsigmoid 相当）。イシュー #2678。crate::activation_scalar_ops::hardsigmoid へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn log_sigmoid(&self) -> Result<Var<'t>, AutodiffError>

LogSigmoid（torch.nn.functional.logsigmoid 相当）。イシュー #2678。crate::activation_scalar_ops::log_sigmoid へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn softmin(&self, dim: usize) -> Result<Var<'t>, AutodiffError>

Softmin（torch.nn.functional.softmin 相当）。イシュー #2678。crate::softmin_threshold_ops::softmin へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn tanhshrink(&self) -> Result<Var<'t>, AutodiffError>

Tanhshrink（torch.nn.functional.tanhshrink 相当）。イシュー #2678。crate::softmin_threshold_ops::tanhshrink へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn threshold( &self, threshold: f32, value: f32, ) -> Result<Var<'t>, AutodiffError>

Threshold（torch.nn.functional.threshold 相当）。イシュー #2678。crate::softmin_threshold_ops::threshold へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn rrelu( &self, lower: f32, upper: f32, training: bool, ) -> Result<Var<'t>, AutodiffError>

RReLU（torch.nn.functional.rrelu 相当）。イシュー #2678。crate::softmin_threshold_ops::rrelu へ 1 行委譲する。 引数検査・エラー契約は委譲先に従う。

pub fn meshgrid( tensors: &[Var<'t>], indexing: MeshgridIndexing, ) -> Result<Vec<Var<'t>>, AutodiffError>

1 次元テンソル列から座標格子を作る（torch.meshgrid 相当）。イシュー #2678。 crate::shape_view_ops::meshgrid へ 1 行委譲する関連関数（self を取らない）。

pub fn flip(&self, dims: &[usize]) -> Result<Var<'t>, AutodiffError>

指定軸を反転する（torch.flip 相当。イシュー #2143・#2511）。 crate::rearrange_ops::flip へ委譲する。軸範囲外・重複は AutodiffError::Shape で拒否し、dims が空なら恒等。

pub fn roll( &self, shifts: &[isize], dims: &[usize], ) -> Result<Var<'t>, AutodiffError>

指定軸を循環シフトする（torch.roll(shifts, dims) 相当。イシュー #2143・#2511）。crate::rearrange_ops::roll へ委譲する。shifts と dims の長さ不一致は InvalidArgument。dims=None 形は非対応。

pub fn repeat(&self, repeats: &[usize]) -> Result<Var<'t>, AutodiffError>

各軸を repeats 回繰り返す（Tensor.repeat 相当。イシュー #2143・ #2511）。crate::rearrange_ops::repeat へ委譲する。repeats.len() が rank 未満なら InvalidArgument、巨大確保は確保前に拒否する。

pub fn tile(&self, reps: &[usize]) -> Result<Var<'t>, AutodiffError>

torch.tile 相当（reps が rank 未満なら先頭を 1 で埋める。イシュー #2143・#2511）。crate::rearrange_ops::tile へ委譲する。

pub fn advanced_indexing( &self, indices: &[Tensor<i32>], ) -> Result<Var<'t>, AutodiffError>

先頭 indices.len() 軸を複数軸整数配列索引で読み出す（x[i0, i1, …] 相当。イシュー #2148・#2518）。crate::indexing_ops::advanced_indexing へ委譲する。範囲外・負の添字・k 不正は InvalidArgument。

pub fn index_put( &self, indices: &[Tensor<i32>], values: &Var<'t>, accumulate: bool, ) -> Result<Var<'t>, AutodiffError>

索引位置へ values を代入した新しい Var を返す非破壊版（Tensor.index_put 相当。イシュー #2148・#2518）。crate::indexing_ops::index_put へ委譲する。 accumulate=true は重複添字を加算、false は最後の書き手が勝つ。別 tape の values は TapeMismatch、broadcast 不能は Shape。

pub fn index_put_( &mut self, indices: &[Tensor<i32>], values: &Var<'t>, accumulate: bool, ) -> Result<(), AutodiffError>

Var::index_put を呼んで self を再束縛する糖衣（Tensor.index_put_ 相当。イシュー #2148・#2518）。crate::indexing_ops::index_put_ へ委譲する。 Var は Copy なハンドルで tape ノードも Tensor も書き換えないため、同じ ノードを指す他のコピーは古い値のまま残り、旧ノードは tape に残る （docs/autodiff-indexing-inplace-design.md §2.1）。

pub fn topk_with_options( &self, k: usize, opts: TopkOptions, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

dim 軸の上位／下位 k 個を選ぶ（torch.topk(k, dim, largest, sorted) 相当。イシュー #2153・#2519）。crate::topk_unique_ops::topk_with_options へ委譲する。負 dim・sorted=false に対応し、0-d 入力は拒否する。

pub fn unique_with_options( &self, opts: UniqueOptions, ) -> Result<UniqueOutput, AutodiffError>

一意値集合（torch.unique(sorted=True, return_inverse, return_counts, dim) 相当。イシュー #2153・#2519）。crate::topk_unique_ops::unique_with_options へ委譲する。非微分で戻り値は detached。

pub fn unique_consecutive( &self, opts: UniqueOptions, ) -> Result<UniqueOutput, AutodiffError>

連続する重複のみを畳む（torch.unique_consecutive 相当。イシュー #2153・#2519）。crate::topk_unique_ops::unique_consecutive へ委譲する。 非微分で戻り値は detached。

pub fn eigh(&self) -> Result<EighVars<'t>, AutodiffError>

対称行列の固有分解（torch.linalg.eigh 相当。イシュー #2150・#2515）。 crate::linalg_ops::eigh へ委譲し、[n, n] から昇順の固有値 [n] と 固有ベクトル [n, n] を返す。非正方・非有限入力は拒否する。

pub fn slogdet(&self) -> Result<SlogdetVars<'t>, AutodiffError>

符号と対数絶対行列式（torch.linalg.slogdet 相当。イシュー #2150・#2515）。 crate::linalg_ops::slogdet へ委譲する。特異行列は (0, -inf) を返す。

pub fn pinv(&self, rcond: Option<f32>) -> Result<Var<'t>, AutodiffError>

Moore-Penrose 擬似逆行列（torch.linalg.pinv 相当。イシュー #2150・#2515）。 crate::linalg_ops::pinv へ委譲し、[m, n] から [n, m] を返す。 rcond が不正（負・非有限）なら拒否する。

pub fn matrix_rank(&self, rcond: Option<f32>) -> Result<Var<'t>, AutodiffError>

行列の階数（torch.linalg.matrix_rank 相当。イシュー #2150・#2515）。 crate::linalg_ops::matrix_rank へ委譲し、f32 のスカラー（形状 []）を返す。

pub fn lstsq( &self, b: &Var<'t>, rcond: Option<f32>, ) -> Result<Var<'t>, AutodiffError>

最小二乗解（torch.linalg.lstsq 相当。解のみ返す。イシュー #2150・#2515）。 self が A（[m, n]）、b が [m, k] のとき crate::linalg_ops::lstsq へ委譲して [n, k] を返す。

pub fn tril(&self, diagonal: isize) -> Result<Var<'t>, AutodiffError>

下三角以外を 0 にする（torch.tril 相当。イシュー #2144・#2513）。 crate::matrix_ops::tril へ委譲する。rank 2 以上のみ受け付け、 不適合は AutodiffError::Shape で拒否する。

pub fn triu(&self, diagonal: isize) -> Result<Var<'t>, AutodiffError>

上三角以外を 0 にする（torch.triu 相当。イシュー #2144・#2513）。 crate::matrix_ops::triu へ委譲する。rank 条件・エラーは tril と同じ。

pub fn diag(&self, diagonal: isize) -> Result<Var<'t>, AutodiffError>

対角の抽出（2-D→1-D）または対角行列の構築（1-D→2-D） （torch.diag 相当。イシュー #2144・#2513）。crate::matrix_ops::diag へ委譲する。rank 3 以上は InvalidArgument。

pub fn trace(&self) -> Result<Var<'t>, AutodiffError>

2-D の対角和（torch.trace 相当。イシュー #2144・#2513）。 crate::matrix_ops::trace へ委譲する。rank 2 以外は AutodiffError::Shape。

pub fn outer(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

1-D 同士の外積（torch.outer 相当。イシュー #2144・#2513）。 crate::matrix_ops::outer へ委譲する。rank 1 以外は AutodiffError::Shape。

pub fn dot(&self, other: &Var<'t>) -> Result<Var<'t>, AutodiffError>

1-D 同士の内積（torch.dot 相当。イシュー #2144・#2513）。 crate::matrix_ops::dot へ委譲する。rank 1 以外・長さ不一致は AutodiffError::Shape。

pub fn floor(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの床関数（torch.floor 相当）。勾配は恒等的に 0（区分定数）。 crate::scalar_unary_ops::floor へ委譲する（イシュー #2145・#2512）。

pub fn ceil(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの天井関数（torch.ceil 相当）。勾配は恒等的に 0（区分定数）。 crate::scalar_unary_ops::ceil へ委譲する（イシュー #2145・#2512）。

pub fn round(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの偶数丸め（torch.round 相当。2.5 -> 2）。勾配は恒等的に 0。 crate::scalar_unary_ops::round へ委譲する（イシュー #2145・#2512）。

pub fn sign(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの符号（torch.sign 相当。sign(±0) = 0）。勾配は恒等的に 0。 crate::scalar_unary_ops::sign へ委譲する（イシュー #2145・#2512）。

pub fn reciprocal(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの逆数（torch.reciprocal 相当）。0 は IEEE のまま inf で panic しない。 crate::scalar_unary_ops::reciprocal へ委譲する（イシュー #2145・#2512）。

pub fn rsqrt(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの逆平方根（torch.rsqrt 相当）。負数は IEEE のまま NaN で panic しない。 crate::scalar_unary_ops::rsqrt へ委譲する（イシュー #2145・#2512）。

pub fn erf(&self) -> Result<Var<'t>, AutodiffError>

要素ごとの誤差関数（torch.erf 相当）。 crate::scalar_unary_ops::erf へ委譲する（イシュー #2145・#2512）。

pub fn pow_scalar(&self, exponent: f32) -> Result<Var<'t>, AutodiffError>

要素ごとの x ^ exponent（スカラー指数。torch.pow(x, scalar) 相当）。 crate::scalar_unary_ops::pow_scalar へ委譲する（イシュー #2145・#2512）。

pub fn prod(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

積縮約（torch.prod 相当。dim = None は全要素）。 crate::reduce_ops::prod へ委譲する（イシュー #2147・#2514）。

pub fn logsumexp(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

数値安定な log-sum-exp（torch.logsumexp 相当）。空縮約は InvalidArgument。 crate::reduce_ops::logsumexp へ委譲する（イシュー #2147・#2514）。

pub fn any(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

非ゼロ要素の有無（torch.any 相当）を f32 の 0.0／1.0 マスクで返す。勾配はゼロ。 crate::reduce_ops::any へ委譲する（イシュー #2147・#2514）。

pub fn all(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

全要素が非ゼロか（torch.all 相当）を f32 の 0.0／1.0 マスクで返す。勾配はゼロ。 crate::reduce_ops::all へ委譲する（イシュー #2147・#2514）。

pub fn norm_p( &self, p: f32, dim: Option<usize>, ) -> Result<Var<'t>, AutodiffError>

p ノルム（torch.linalg.vector_norm 相当）。p は有限かつ正の値のみ許容する。 crate::reduce_ops::norm_p へ委譲する（イシュー #2147・#2514）。

pub fn amax(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

最大値縮約（torch.amax 相当）。同値タイに勾配を g/k で均等分配する。 crate::extremum_ops::amax へ委譲する（イシュー #2154・#2514）。

pub fn amin(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

最小値縮約（torch.amin 相当）。同値タイに勾配を g/k で均等分配する。 crate::extremum_ops::amin へ委譲する（イシュー #2154・#2514）。

pub fn embedding( &self, index: &Tensor<i32>, padding_idx: Option<usize>, ) -> Result<Var<'t>, AutodiffError>

embedding テーブル（self。[num_embeddings, embedding_dim]） から index が指す行を抽出する（nn::Embedding の forward 本体。torch.nn.functional.embedding 相当。イシュー #1604）。 index は非追跡データ（Self::gather の index と同じ 「Op payload に直接埋め込む」設計。勾配は index 側には 流れない）で、任意 rank（0 次元＝単一 id も含む）を受理する。 padding_idx（Some(p)）を渡すと forward は行 p の現在値を そのまま返すが、勾配は本メソッドの Op::Embedding VJP（ grad.rs）が行 p をゼロ上書きするため流れない（PyTorch nn.Embedding(padding_idx=..) の意味論）。

検査順序: ①self.shape().len() == 2（違反は AutodiffError::Shape(ShapeError::RankMismatch)）→ ②padding_idx < num_embeddings（違反は AutodiffError::InvalidArgument）→ ③index 全添字が 0 <= id < num_embeddings（違反は AutodiffError:: InvalidArgument。Self::gather と同じ「バックエンド呼び出し 前に検査する」契約。.claude/rules/security.md A03）→ ④index を [N, D]（N = index.numel()）へ実体化（contiguous() → reshape([N, 1]) → broadcast_to([N, D]) → contiguous()。 いずれも Self::index_select と同じ zero-copy な view 拡張 手順の最終段のみ実体化する）→ ⑤self（weight）を層 1 （materialize_fallible）で実体化 → ⑥gather_with_fallback → ⑦戻り shape 検証 → ⑧push_eager → ⑨index.rank() != 1 のときのみ、ノード shape（常に [N, D]）を index.shape() ++ [D] へ Self::reshape する（1-D ids は [N] ++ [D] == [N, D] で既に一致するため省略。rank-0 ids は N == 1 から [1, D] を [D] へ縮める）。

pub fn unique(&self) -> Result<Tensor<f32>, AutodiffError>

一意値集合を返す（torch.unique(input, sorted=True) の values のみ。イシュー #1734・契約は fandhe_ai_tensor_core::BackendOps::unique doc を正とする）。

非微分演算: unique は勾配を持たない（出力の各要素がどの 入力位置に由来するかは一意に定まらず、出力形状も入力値に 依存して動的に決まるため既存の Var〈tape ノード・静的 shape〉には乗らない）。そのため本メソッドは新規 Op を tape に 記録せず（push_eager を呼ばない）、self を materialize_fallible（クレート内部ヘルパー）で実体化した値に 対して unique_with_fallback を適用した detached な Tensor<f32> を返す（Var ではない。 docs/unique-facade-exposure-decision.md 参照）。

pub fn cast<T>(&self) -> Result<Tensor<T>, AutodiffError>

where T: CastElement,

self を Tensor<T> へ変換する（torch.Tensor.to(dtype) 相当 の一方向。イシュー #1750。dtype 変換基盤の契約・数値表は docs/tensor-core-cast-design.md を正とする）。

非微分演算: 出力が f32 以外の dtype への cast は勾配を 持たない（Var::argmax／Var::unique と同型の理由——Tensor<T> は Var の tape 表現に乗らない）ため、本メソッドは新規 Op を tape に記録せず（push_eager を呼ばない）、self を materialize_fallible で実体化した値に対して cast_from_f32_with_fallback を適用した detached な Tensor<T> を返す。

T = f32 を指定した場合も本メソッドは detached なコピーを 返すだけであり勾配は伝播しない——勾配を保ったまま f32 系の 恒等射を得たい場合は Var::to_f32 を使うこと。

pub fn to_f32(&self) -> Var<'t>

f32 系の恒等射（イシュー #1750）。self は既に Tensor<f32> を表す Var であるため、Var: Copy により self をそのまま 返すだけで済み、勾配は通常どおり self の tape ノードへ伝播 する（Var::cast::<f32>() が detached なコピーを返し勾配を 打ち切るのとは対照的）。

pub fn scatter( &self, dim: usize, index: &Tensor<i32>, src: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

mask が真の位置を上書きする（torch.scatter 相当。イシュー #1776）。共通実装 Self::scatter_impl（非公開）を fandhe_ai_tensor_core::ScatterReduce::Overwrite で呼ぶ。

pub fn scatter_add( &self, dim: usize, index: &Tensor<i32>, src: &Var<'t>, ) -> Result<Var<'t>, AutodiffError>

index が指す位置へ src を加算する（torch.scatter_add 相当。イシュー #1776）。共通実装 Self::scatter_impl（非公開）を fandhe_ai_tensor_core::ScatterReduce::Add で呼ぶ （決定的集約順序・f64 アキュムレータ契約は fandhe_ai_tensor_core::ScatterReduce doc を正とする）。

pub fn sort( &self, dim: usize, descending: bool, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

dim 軸に沿って並べ替える（torch.sort 相当。イシュー #1733）。戻り値は (values, index) で、values（追跡対象。 Var）は並べ替え後の値、index（非追跡・Tensor<i32>）は 元の dim 軸上の添字。同値（ties）・NaN・±0 の順序契約は fandhe_ai_tensor_core::BackendOps::sort doc の 1〜4 を正と する。

検査順序: ①fandhe_ai_tensor_core::sort_out_shape（dim 範囲を検査。違反は AutodiffError::Shape）→ ②self を層 1 で 実体化 → ③ops.sort → Unsupported のときのみホスト参照 実装（eval::sort）へフォールバック → ④戻り shape 検証 （.claude/rules/security.md A08）→ ⑤push_eager。

pub fn argsort( &self, dim: usize, descending: bool, ) -> Result<Tensor<i32>, AutodiffError>

dim 軸に沿って並べ替えた際の元添字のみを返す（torch.argsort 相当。イシュー #1733）。Self::sort と異なりテープへノードを 追加しない（非微分演算。index は forward 値のみで勾配は 流れない）。self を実体化して Self::sort と同じ検査・ フォールバック経路（sort_out_shape → sort_with_fallback）を 通し、index 出力のみを返す。

pub fn topk( &self, k: usize, dim: usize, largest: bool, ) -> Result<(Var<'t>, Tensor<i32>), AutodiffError>

dim 軸に沿って上位（largest=true）／下位（largest=false） k 個を選ぶ（torch.topk 相当・sorted=True 固定。イシュー #1733）。戻り値は Self::sort と同じ (values, index) の形。

検査順序: ①fandhe_ai_tensor_core::topk_out_shape（dim 範囲・k <= self.shape()[dim] を検査。k > dim_size は ShapeError::NarrowOutOfBounds）→ ②self を層 1 で実体化 → ③ops.topk → Unsupported のときのみホスト参照実装 （eval::topk）へフォールバック → ④戻り shape 検証 → ⑤push_eager。

pub fn one_hot(&self, num_classes: usize) -> Result<Var<'t>, AutodiffError>

クラス id 列を one-hot 行列へ展開する（torch.nn.functional. one_hot／tf.one_hot 相当。非微分演算。イシュー #1755）。 self はクラス id を f32 値として保持する追跡 Var（専用の integer Var 型は無いため、整数値を f32 で表現する既存方針を 踏襲。Var::gather の index 引数と異なり、本メソッドは self 自身がクラス id を保持する——「勾配計算グラフ上の入力」 であることを明示するため Op::OneHot に input: NodeId として 記録し、VJP でゼロ勾配を流す対象にする）。出力 shape は self.shape() ++ [num_classes] （fandhe_ai_tensor_core::one_hot_out_shape）。

検査順序: ①num_classes >= 1（違反は AutodiffError:: InvalidArgument。num_classes == 0 自体は one_hot_out_shape が ShapeError::IndexOutOfRange を返すが、 専用のわかりやすいメッセージを先に出す）→ ② fandhe_ai_tensor_core::one_hot_out_shape で出力 shape を 確定（違反は AutodiffError::Shape）→ ③self を層 1 実体化 → ④全要素が有限・整数値（fract() == 0.0）・ 0 <= v < num_classes であることを検査（違反は InvalidArgument。Self::gather の index 範囲検査と同じ パターン）→ ⑤検証済み値を Tensor<i32>（self.shape() と同一 shape の contiguous）へ変換 → ⑥one_hot_with_fallback （Unsupported のときのみホスト参照実装 eval::one_hot へ フォールバック）→ ⑦戻り shape 再検証（.claude/rules/ security.md A08）→ ⑧push_eager。

pub fn lstm_cell( &self, h_prev: &Var<'t>, c_prev: &Var<'t>, p: GateParams<'_, 't>, ) -> Result<(Var<'t>, Var<'t>), AutodiffError>

LSTM セル 1 step（イシュー #1647・設計 docs/autodiff-rnn-cell- tape-design.md 決定 1・1b・1c・4・5・12）。ゲート順は i,f,g,o （p.w_ih／p.w_hh は [D, 4H]／[H, 4H]、bias は [4H]）。 2 ノード（Op::LstmCell → Op::LstmHidden）を この順で push する（決定 1b の push 順序契約。backward の逆走査が LstmHidden を先に処理し nodes[cell.0].op を参照するため）。

戻り値は (h_t, c_t)。

pub fn gru_cell( &self, h_prev: &Var<'t>, p: GateParams<'_, 't>, ) -> Result<Var<'t>, AutodiffError>

GRU セル 1 step（イシュー #1647・設計 docs/autodiff-rnn-cell- tape-design.md 決定 1c・4・5・12。reset_after=True 規約）。 ゲート順は r,z,n（p.w_ih／p.w_hh は [D, 3H]／[H, 3H]、 bias は [3H]）。1 ノード（Op::GruCell）で表現する（GRU は LSTM と異なり単一出力 h_t のため 2 ノード分割は不要）。

pub fn inv(&self) -> Result<Var<'t>, AutodiffError>

A^{-1}（A: [n,n]）。イシュー #1621・親イシュー #1573 「Tier 2: 線形代数」・docs/spec/04-requirements.md REQ-9 2026-09-12 追記・docs/autodiff-linalg-design.md。

検査順序（mse_loss_with と同じ規律）: ①shape 検査（rank-2・ 正方）→ ②入力実体化（層 1）→ ③self.tape.ops().linalg_inv を 試み Err(BackendError::Unsupported(_)) のときのみ eval::linalg::inv（ホスト参照実装）へフォールバック（それ以外の エラー〈特異行列の InvalidArgument 等〉は伝播する。判定迂回 経路を作らない。.claude/rules/security.md A08）→ ④ノード記録。

pub fn solve(&self, b: &Var<'t>) -> Result<Var<'t>, AutodiffError>

A X = B を解く（self: [n,n]・b: [n,k] → [n,k]）。 イシュー #1621。inv と同じ二段フォールバック規律。

pub fn det(&self) -> Result<Var<'t>, AutodiffError>

det(A)（A: [n,n] → スカラー []）。イシュー #1621。特異行列は forward で 0.0（エラーにしない。eval::linalg::det doc・ torch.linalg.det と同じ挙動）。

pub fn cholesky(&self) -> Result<Var<'t>, AutodiffError>

Cholesky 分解（A: [n,n]〈対称正定値。下三角のみ読む〉→ L: [n,n]〈下三角、A = L Lᵀ〉）。イシュー #1621。非正定値は AutodiffError::InvalidArgument(_)（CPU 本番経路・フォールバック とも unify_backend_error で同一 variant に統一済み。 codex-review 指摘の是正: 以前は逆方向〈Backend(InvalidArgument)〉 へ統一していたため、本番経路の数値エラーがドキュメント記載の variant と一致しなかった）。

pub fn qr(&self) -> Result<QrVars<'t>, AutodiffError>

reduced QR 分解（A: [m,n] → QrVars。k = min(m,n)）。 イシュー #1621。

多出力の扱い（docs/autodiff-linalg-design.md §3.3）: テープは 1 ノード 1 出力のため Q／R を別ノード（Op::QrQ／ Op::QrR）として積む。各ノードは兄弟ノードの forward 値を payload として保持し、VJP（grad.rs）はコタンジェントに線形な ことを利用して各出力ノードの部分寄与を返す （Tape::backward が入力ノードへ合算する）。

pub fn svd(&self) -> Result<SvdVars<'t>, AutodiffError>

reduced SVD（A: [m,n] → SvdVars。k = min(m,n)）。 イシュー #1621。qr と同じ多出力設計（Op::SvdU／ Op::SvdS／Op::SvdVh）。反復が収束しない場合は AutodiffError::InvalidArgument(_)（CPU 本番経路・フォールバック とも unify_backend_error で同一 variant に統一済み。 codex-review 指摘の是正）。

pub fn matrix_norm(&self, ord: MatrixNormOrd) -> Result<Var<'t>, AutodiffError>

行列ノルム（A: [m,n]・ord → スカラー []）。イシュー #1621。 ord が MatrixNormOrd::Nuc／MatrixNormOrd::Spectral の 場合、フォールバック実装（eval::linalg::matrix_norm）内部で 特異値分解を用いる（Var 側で svd ノードを合成しない設計。 docs/autodiff-linalg-design.md §3.2）。

pub fn var( &self, dim: Option<usize>, correction: usize, ) -> Result<Var<'t>, AutodiffError>

分散（dim に沿った縮約。dim: None は全軸縮約〈スカラー〉。 torch.var(dim, correction) 相当。correction: 1 が不偏分散 （既定相当）・0 が母分散（tf.math.reduce_variance 相当）。 イシュー #1723）。

sum／max（BackendOps 必須メソッド）とは異なり BackendOps::var は既定 Unsupported（matrix_norm と同じ フォールバック契約）——バックエンド未実装のときのみ eval::var_along（ホスト参照実装）へ切り替える。

数値契約: f64 二段計算（.claude/rules/coding-rust.md）。 エラー契約: 縮約対象の要素数 n（dim=Some(axis) は shape[axis]・dim=None は全要素数）が 0 または n <= correction の場合は AutodiffError::InvalidArgument （NaN／inf を黙って返さない安全側の判断。PyTorch の NaN／inf 返却とは意図的に異なる。docs/spec/ の対象外の 独自安全策）。巨大な shape（broadcast_to 由来の view 等）で 確保上限（isize::MAX バイト）を超える場合は、実体化・ backend 委譲・eval フォールバックのいずれよりも前に AutodiffError::Shape(ShapeError::ElementCountOverflow) を 返す（var_std_out_shape_checked doc 参照。イシュー #2288）。

pub fn std( &self, dim: Option<usize>, correction: usize, ) -> Result<Var<'t>, AutodiffError>

標準偏差（dim に沿った縮約。torch.std(dim, correction) 相当。イシュー #1723・レビュー是正）。

当初 Var::var(dim, correction)?.sqrt()（新規 Op を設けない 合成）として実装していたが、Op::Var の forward 値が分散を f32 へ downcast してから Op::Sqrt に渡すため、真の分散が f32 の範囲（有限最大値 約 3.4e38）を超える極端な入力（例 [-1e20, 1e20]。分散 ≈1e40）で std 自体は f32 で表現 可能（≈1.41e20）にもかかわらず inf になっていた （codex-review P2 指摘）。本メソッドは専用の Op::Std （crate::tape::Op）ノードを直接構築し、forward・backward とも f64 の分散を経由してから最後に 1 回だけ sqrt を計算 する（eval::std_along／grad::std_vjp 参照。Var::var と 異なり BackendOps に対応メソッドは設けない——常に eval::std_along〈ホスト参照実装〉を使う。将来デバイス側 カーネルが必要になれば非破壊で追加できる）。

数値規約: std は f64 の分散から f64 で sqrt した 値を 1 回だけ f32 へ downcast する（var == 0 の場合 std == 0）。勾配（Op::Std の VJP）は std == 0（縮約対象 が全て同値の定数列）の要素でゼロ勾配へ明示的にマスクする （0.0 / 0.0 の NaN は伝播しない）。これは PyTorch torch.std backward（std_backward。FunctionsManual.cpp）が masked_fill_(result == 0, 0) で行うマスクと一致する規約 （grad::std_vjp doc 参照）。Var::var(..).sqrt()（新規 Op を追加しない合成）とは異なる点に注意——その合成では Var::sqrt の y == 0 規約により 0.0 / 0.0 = NaN を返す。

エラー契約: Var::var と同じ（縮約対象の要素数 n が 0 または n <= correction の場合は AutodiffError::InvalidArgument・巨大な shape で確保上限を 超える場合は AutodiffError::Shape(ShapeError:: ElementCountOverflow)。イシュー #2288）。

pub fn norm_l1(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

L1 ノルム（Σ|x_i|・dim に沿った縮約。torch.norm(p=1) 相当。イシュー #1723）。Var::norm（pub(crate)）への薄い 委譲。

pub fn norm_l2(&self, dim: Option<usize>) -> Result<Var<'t>, AutodiffError>

L2 ノルム（√Σx_i²・dim に沿った縮約。torch.norm(p=2) 相当。イシュー #1723）。Var::norm（pub(crate)）への薄い 委譲。

Trait Implementations

impl<'t> Clone for Var<'t>

fn clone(&self) -> Var<'t>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'t> Copy for Var<'t>

impl<'t> Debug for Var<'t>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.