Fix #354: t2s constant_mul keeps a symbolic scalar_wrapper factor

constant_mul::dispatch(tensor_to_scalar_mul) handled a numeric LHS by
merging it into the coefficient, but a non-numeric scalar_wrapper LHS
fell through the same path: the factor was never inserted and the
coefficient was reset to the wrapped default, so
wrapper(x) * (trace(A)*det(A)) evaluated as if x were 1. The promoted
route (plain x * (f*g)) goes through mul_base and was correct, which
is why tests missed it - the bug fires whenever the wrapper is the
visitor's LHS.

Non-numeric wrappers are now inserted as factors via push_or_combine
(merging with an existing wrapper child through the unwrap-multiply-
rewrap path).

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

Author: petlenz

src/numsim_cas/tensor_to_scalar/simplifier/tensor_to_scalar_simplifier_mul.cpp

@@ -12,6 +12,9 @@ namespace simplifier {
 // --- constant_mul ---
 using t2s_traits = domain_traits<tensor_to_scalar_expression>;
 
+static void push_or_combine(tensor_to_scalar_mul &mul,
+                            mul_base::expr_holder_t const &child);
+
 constant_mul::constant_mul(expr_holder_t lhs, expr_holder_t rhs)
     : base(std::move(lhs), std::move(rhs)),
       lhs_val{t2s_traits::try_numeric(base::m_lhs)} {}
@@ -36,10 +39,14 @@ constant_mul::dispatch(tensor_to_scalar_mul const &rhs) {
   }
   auto mul_expr{make_expression<tensor_to_scalar_mul>(rhs)};
   auto &mul{mul_expr.template get<tensor_to_scalar_mul>()};
-  auto coeff{get_coefficient<t2s_traits>(mul, 1)};
-  if (lhs_val) {
-    coeff = coeff * *lhs_val;
+  if (!lhs_val) {
+    // symbolic scalar_wrapper: keep it as a factor instead of silently
+    // resetting the coefficient (#354)
+    push_or_combine(mul, base::m_lhs);
+    return mul_expr;
   }
+  auto coeff{get_coefficient<t2s_traits>(mul, 1)};
+  coeff = coeff * *lhs_val;
   mul.set_coeff(t2s_traits::make_constant(coeff));
   return mul_expr;
 }

tests/TensorToScalarExpressionTest.h

@@ -921,4 +921,20 @@ TYPED_TEST(TensorToScalarExpressionTest,
   EXPECT_EQ(d.get().dim(), X.get().dim());
 }
 
+// #354 — a symbolic scalar_wrapper multiplied into an existing t2s mul must
+// survive as a factor (it was silently dropped and the coefficient reset).
+TYPED_TEST(TensorToScalarExpressionTest,
+           SymbolicWrapperFactorSurvivesMulMerge) {
+  auto &X = this->X;
+  auto &x = this->x;
+  using numsim::cas::det;
+  using numsim::cas::trace;
+  auto f = trace(X) * det(X); // tensor_to_scalar_mul
+  auto w = numsim::cas::make_expression<
+      numsim::cas::tensor_to_scalar_scalar_wrapper>(x);
+  auto e = w * f; // wrapper-first: hits constant_mul::dispatch(mul)
+  auto const s = numsim::cas::to_string(e);
+  EXPECT_NE(s.find("x"), std::string::npos) << s;
+}
+
 #endif // TENSORTOSCALAREXPRESSIONTEST_H