Fix #420: t2s function folds under the rule contract + close trans gaps

Extract the construction folds of the t2s functions (trace/det/norm/dot/
dot_product) from the tensor_to_scalar_functions.cpp if-chains into named,
group-tagged try_* rules under the uniform contract
`std::optional<result> try_<name>(tensor_holder const&)`, cataloged in
tensor_to_scalar/simplifier/tensor_to_scalar_function_rules.h with bodies in the
matching .cpp (operator ADL — the same .h/.cpp split as scalar_function_rules).
The functions drive the rules in sequence at construction; det's terminal
tensor_det node + PD/PSD annotation stays in det() (not an early-return fold).

Extraction is behavior-identical — the existing Trace/Det/Norm simplification
tests are unchanged. Two new always-on canonicalizers close transpose gaps
(both transpose-invariant): trace(Aᵀ)→trace(A), ‖Aᵀ‖→‖A‖, matched on
permute_indices_wrapper{2,1} like the existing det(trans A) fold.

Reordering (trace(AB)=trace(BA)) is non-confluent and deferred to an opt-in
pass. New tests: TraceNormTransGaps (end-to-end) and FunctionRulesUnitCoverage
(each rule fires/declines; transpose rules guarded for dim≥2). Full suite
2298/2298; g++-14 -Wall -Wextra -Werror clean. Second domain of #417.

Signed-off-by: Peter Lenz <peterlenz89.pl@gmail.com>

Author: petlenz

include/numsim_cas/tensor_to_scalar/simplifier/tensor_to_scalar_function_rules.h

@@ -0,0 +1,64 @@
+#ifndef TENSOR_TO_SCALAR_FUNCTION_RULES_H
+#define TENSOR_TO_SCALAR_FUNCTION_RULES_H
+
+#include <optional>
+
+#include <numsim_cas/tensor/tensor_expression.h>
+#include <numsim_cas/tensor_to_scalar/tensor_to_scalar_expression.h>
+
+// Construction-time fold rules for the t2s functions (#417 / #420).
+//
+// Rule contract: each rule is a named, group-tagged free function
+//     std::optional<result> try_<name>(tensor_holder const& arg);
+// returning nullopt when it does not fire. The trace/det/norm/dot functions in
+// tensor_to_scalar_functions.cpp drive the applicable rules in sequence at
+// construction. Bodies live in the matching .cpp because they call the t2s /
+// tensor / scalar operators (operator*, /, pow, abs), which must be visible via
+// ADL there — the same .h-decl / .cpp-def split as scalar_function_rules.
+//
+// These rules are cross-domain: they take a tensor and yield a t2s scalar. The
+// catalog is the enumerable list a later registry would consume.
+namespace numsim::cas::t2s_rules {
+
+using tensor_holder = expression_holder<tensor_expression>;
+using result = expression_holder<tensor_to_scalar_expression>;
+
+// ── dot / dot_product [dot] ──────────────────────────────────────────
+std::optional<result> try_dot_product_zero(tensor_holder const &lhs,
+                                           tensor_holder const &rhs);
+std::optional<result> try_dot_zero(tensor_holder const &e); // dot(0) → 0
+
+// ── trace [trace] ────────────────────────────────────────────────────
+std::optional<result> try_trace_zero(tensor_holder const &e);     // tr(0) → 0
+std::optional<result> try_trace_identity(tensor_holder const &e); // tr(I) → dim
+std::optional<result>
+try_trace_of_trans(tensor_holder const &e); // tr(Aᵀ) → tr(A)
+std::optional<result>
+try_trace_scalar_mul(tensor_holder const &e); // tr(s·A) → s·tr(A)
+std::optional<result>
+try_trace_add(tensor_holder const &e); // tr(A+B) → tr(A)+tr(B)
+
+// ── norm [norm] ──────────────────────────────────────────────────────
+std::optional<result> try_norm_zero(tensor_holder const &e); // ‖0‖ → 0
+std::optional<result> try_norm_of_trans(tensor_holder const &e); // ‖Aᵀ‖ → ‖A‖
+std::optional<result>
+try_norm_scalar_mul(tensor_holder const &e); // ‖s·A‖ → |s|·‖A‖
+
+// ── det [det] ────────────────────────────────────────────────────────
+std::optional<result> try_det_zero(tensor_holder const &e);     // det(0) → 0
+std::optional<result> try_det_identity(tensor_holder const &e); // det(I) → 1
+std::optional<result>
+try_det_chirality(tensor_holder const &e); // proper→1, improper→-1
+std::optional<result>
+try_det_inv(tensor_holder const &e); // det(A⁻¹) → 1/det(A)
+std::optional<result> try_det_trans(tensor_holder const &e); // det(Aᵀ) → det(A)
+std::optional<result>
+try_det_outer_product(tensor_holder const &e); // det(u⊗v) → 0, dim≥2
+std::optional<result>
+try_det_scalar_mul(tensor_holder const &e); // det(s·A) → sᵈ·det(A)
+std::optional<result>
+try_det_mul(tensor_holder const &e); // det(∏Aᵢ) → ∏det(Aᵢ)
+
+} // namespace numsim::cas::t2s_rules
+
+#endif // TENSOR_TO_SCALAR_FUNCTION_RULES_H

src/numsim_cas/tensor_to_scalar/simplifier/tensor_to_scalar_function_rules.cpp

@@ -0,0 +1,176 @@
+#include <numsim_cas/tensor_to_scalar/simplifier/tensor_to_scalar_function_rules.h>
+
+#include <numsim_cas/tensor_to_scalar/tensor_to_scalar_definitions.h>
+#include <numsim_cas/tensor_to_scalar/tensor_to_scalar_functions.h>
+#include <numsim_cas/tensor_to_scalar/tensor_to_scalar_operators.h>
+
+#include <numsim_cas/basic_functions.h>
+#include <numsim_cas/scalar/scalar_std.h>
+#include <numsim_cas/tensor/tensor_assume.h>
+#include <numsim_cas/tensor/tensor_definitions.h>
+#include <numsim_cas/tensor/tensor_operators.h>
+
+#include <ranges>
+
+// Bodies mirror the previous inline folds in tensor_to_scalar_functions.cpp
+// exactly; #420 extracts them into named, testable rules. The two *_of_trans
+// rules are new (transpose-invariance gaps). The det terminal node + its PD/PSD
+// annotation stays in det() — it is not an early-return fold.
+
+namespace numsim::cas::t2s_rules {
+
+// ── dot / dot_product ────────────────────────────────────────────────
+std::optional<result> try_dot_product_zero(tensor_holder const &lhs,
+                                           tensor_holder const &rhs) {
+  if (is_same<tensor_zero>(lhs) || is_same<tensor_zero>(rhs))
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+std::optional<result> try_dot_zero(tensor_holder const &e) {
+  if (is_same<tensor_zero>(e))
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+
+// ── trace ────────────────────────────────────────────────────────────
+std::optional<result> try_trace_zero(tensor_holder const &e) {
+  if (is_same<tensor_zero>(e))
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+std::optional<result> try_trace_identity(tensor_holder const &e) {
+  // tr(I) = dim. Rank-2 asserted by the caller, so any identity_tensor here
+  // is the rank-2 Kronecker delta (#188 unified kronecker_delta).
+  if (is_same<identity_tensor>(e)) {
+    auto dim = e.get().dim();
+    return make_expression<tensor_to_scalar_scalar_wrapper>(
+        make_expression<scalar_constant>(static_cast<int>(dim)));
+  }
+  return {};
+}
+std::optional<result> try_trace_of_trans(tensor_holder const &e) {
+  // tr(Aᵀ) = tr(A). trans() builds permute_indices_wrapper{2,1}; match the
+  // index sequence so a non-transpose permutation is not mis-simplified.
+  if (is_same<permute_indices_wrapper>(e)) {
+    auto const &perm = e.get<permute_indices_wrapper>();
+    if (perm.indices() == sequence{2, 1})
+      return trace(perm.expr());
+  }
+  return {};
+}
+std::optional<result> try_trace_scalar_mul(tensor_holder const &e) {
+  if (is_same<tensor_scalar_mul>(e)) {
+    auto const &sm = e.get<tensor_scalar_mul>();
+    return sm.expr_lhs() * trace(sm.expr_rhs());
+  }
+  return {};
+}
+std::optional<result> try_trace_add(tensor_holder const &e) {
+  if (is_same<tensor_add>(e)) {
+    auto const &add = e.get<tensor_add>();
+    result r;
+    if (add.coeff().is_valid())
+      r = trace(add.coeff());
+    for (auto const &child : add.symbol_map() | std::views::values) {
+      if (r.is_valid())
+        r = r + trace(child);
+      else
+        r = trace(child);
+    }
+    return r;
+  }
+  return {};
+}
+
+// ── norm ─────────────────────────────────────────────────────────────
+std::optional<result> try_norm_zero(tensor_holder const &e) {
+  if (is_same<tensor_zero>(e))
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+std::optional<result> try_norm_of_trans(tensor_holder const &e) {
+  // ‖Aᵀ‖ = ‖A‖ — the Frobenius norm is transpose-invariant.
+  if (is_same<permute_indices_wrapper>(e)) {
+    auto const &perm = e.get<permute_indices_wrapper>();
+    if (perm.indices() == sequence{2, 1})
+      return norm(perm.expr());
+  }
+  return {};
+}
+std::optional<result> try_norm_scalar_mul(tensor_holder const &e) {
+  if (is_same<tensor_scalar_mul>(e)) {
+    auto const &sm = e.get<tensor_scalar_mul>();
+    return abs(sm.expr_lhs()) * norm(sm.expr_rhs());
+  }
+  return {};
+}
+
+// ── det ──────────────────────────────────────────────────────────────
+std::optional<result> try_det_zero(tensor_holder const &e) {
+  if (is_same<tensor_zero>(e))
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+std::optional<result> try_det_identity(tensor_holder const &e) {
+  if (is_same<identity_tensor>(e))
+    return make_expression<tensor_to_scalar_one>();
+  return {};
+}
+std::optional<result> try_det_chirality(tensor_holder const &e) {
+  // det of an orthogonal tensor is ±1, resolved by chirality (#269):
+  // proper → +1, improper → −1, bare orthogonal → NO fold (sign unknown).
+  if (is_proper_rotation(e))
+    return make_expression<tensor_to_scalar_one>();
+  if (is_improper_rotation(e))
+    return -make_expression<tensor_to_scalar_one>();
+  return {};
+}
+std::optional<result> try_det_inv(tensor_holder const &e) {
+  // det(A⁻¹) = 1/det(A), routed through t2s div → canonical pow(det(A),-1).
+  if (is_same<tensor_inv>(e)) {
+    auto const &inner = e.get<tensor_inv>().expr();
+    return make_expression<tensor_to_scalar_one>() / det(inner);
+  }
+  return {};
+}
+std::optional<result> try_det_trans(tensor_holder const &e) {
+  if (is_same<permute_indices_wrapper>(e)) {
+    auto const &perm = e.get<permute_indices_wrapper>();
+    if (perm.indices() == sequence{2, 1})
+      return det(perm.expr());
+  }
+  return {};
+}
+std::optional<result> try_det_outer_product(tensor_holder const &e) {
+  // det(u ⊗ v) = 0 for dim ≥ 2 (rank-1 matrix). dim = 1 is the 1×1 scalar.
+  if (is_same<outer_product_wrapper>(e) && e.get().dim() >= 2)
+    return make_expression<tensor_to_scalar_zero>();
+  return {};
+}
+std::optional<result> try_det_scalar_mul(tensor_holder const &e) {
+  if (is_same<tensor_scalar_mul>(e)) {
+    auto const &sm = e.get<tensor_scalar_mul>();
+    auto dim = static_cast<int>(sm.expr_rhs().get().dim());
+    auto dim_expr = make_expression<scalar_constant>(dim);
+    return pow(sm.expr_lhs(), std::move(dim_expr)) * det(sm.expr_rhs());
+  }
+  return {};
+}
+std::optional<result> try_det_mul(tensor_holder const &e) {
+  if (is_same<tensor_mul>(e)) {
+    auto const &mul = e.get<tensor_mul>();
+    result r;
+    if (mul.coeff().is_valid())
+      r = det(mul.coeff());
+    for (auto const &child : mul.data()) {
+      if (r.is_valid())
+        r = r * det(child);
+      else
+        r = det(child);
+    }
+    return r;
+  }
+  return {};
+}
+
+} // namespace numsim::cas::t2s_rules