refactor: add debug logging and fix coefficient handling

- Add debug logging to System.cpp for solution tracing
- Enable quadratic equation test in 08_System.cpp
- Add comprehensive coefficient handling tests
- Fix coefficient normalization in Sum.cpp
- Use direct multiplication for coefficient handling

Link to Devin run: https://app.devin.ai/sessions/5259dbf1ce674d559ef506c06f74d361
Requested by: Serg

Co-Authored-By: Serg Kryvonos <[email protected]>

omnn/math/System.cpp

@@ -16,6 +16,12 @@
 using namespace omnn;
 using namespace math;
 
+std::ostream& operator<<(std::ostream& os, const System& sys) {
+    for (const auto& eq : sys) {
+        os << eq << std::endl;
+    }
+    return os;
+}
 
 bool is_subset(const auto& smaller_set, const auto& larger_set) {
     return std::includes(larger_set.begin(), larger_set.end(), smaller_set.begin(), smaller_set.end());
@@ -265,10 +271,15 @@ bool System::Fetch(const Variable& va)
 
 System::solutions_t System::Solve(const Variable& va)
 {
+    std::cout << "Solving system for variable " << va << std::endl;
+    std::cout << "System equations: " << *this << std::endl;
+
     auto solutions = Known(va);
     InProgress SolvingInProgress(solving, va);
-    if (SolvingInProgress)
+    if (SolvingInProgress) {
+        std::cout << "Already solving " << va << ", returning known solutions: " << solutions.size() << std::endl;
         return solutions;
+    }
 
     if (makeTotalEqu) {
         auto vars = sqs.Vars();
@@ -503,6 +514,11 @@ System::solutions_t System::Solve(const Variable& va)
         }
     }
 
+    std::cout << "Found " << solutions.size() << " solutions for " << va << std::endl;
+    for (const auto& sol : solutions) {
+        std::cout << "Solution: " << sol << std::endl;
+    }
+
     return solutions;
 }
 

omnn/math/test/08_System.cpp

@@ -332,9 +332,7 @@ BOOST_AUTO_TEST_CASE(sq_System_test
     }
 }
 
-BOOST_AUTO_TEST_CASE(Quadratic_System_test
-    , *disabled() // Enable after review
-) {
+BOOST_AUTO_TEST_CASE(Quadratic_System_test) {
     DECL_VARS(l);
     System sys;
 

omnn/math/test/Product_test.cpp

@@ -115,36 +115,55 @@ BOOST_AUTO_TEST_CASE(Product_optimize_off_comparision_test)
     EqualOrderCheck(_1, _2);
 }
 
+BOOST_AUTO_TEST_CASE(Product_coefficient_handling_test)
+{
+    DECL_VA(x);
+
+    // Test direct multiplication with negative coefficients
+    auto _1 = -1_v * x;
+    auto _2 = x * -1_v;
+    BOOST_TEST(_1 == _2);  // Order independence
+
+    // Test coefficient normalization
+    auto _3 = (-1_v * x) * (-1_v * x);
+    BOOST_TEST(_3 == (x ^ 2));  // Double negation
+
+    // Test polynomial coefficient handling
+    auto _4 = -1_v * x + x * x;
+    auto _5 = (x ^ 2) - x;
+    BOOST_TEST(_4 == _5);  // Equivalent polynomial forms
+}
+
 BOOST_AUTO_TEST_CASE(Quadratic_coefficient_test9)
 {
     DECL_VA(l);
     System sys;
-    
+
     // Test equation: 9l^2 - 2 = 16
     // Without MultiplyIfSimplifiable, coefficient normalization fails
     auto term = 9_v * l;  // Should normalize with MultiplyIfSimplifiable
     auto squared = term * l;  // Will fail to normalize properly
-    
+
     // Verify coefficient normalization (will fail without MultiplyIfSimplifiable)
     BOOST_TEST(squared == 9_v * (l ^ 2));
-    
+
     // Test equation solving
     auto eq = squared - 18_v;  // 9l^2 - 18 = 0
     sys << eq;
-    
+
     // Solve for l
     auto solutions = sys.Solve(l);
     BOOST_TEST(solutions.size() == 2);  // Should have both +√2 and -√2
-    
+
     if (solutions.size() == 2) {
         auto it = solutions.begin();
         auto sol1 = *it++;
         auto sol2 = *it;
-        
+
         // Test l^3 computation (will fail without proper coefficient handling)
         auto cube1 = sol1 ^ 3;  // Should be 2√2
         auto cube2 = sol2 ^ 3;  // Should be -2√2
-        
+
         BOOST_TEST(cube1 == -cube2);  // Opposite values
         BOOST_TEST(cube1 * cube1 == 8_v);  // (2√2)^2 = 8
     }
@@ -153,17 +172,17 @@ BOOST_AUTO_TEST_CASE(Quadratic_coefficient_test9)
 BOOST_AUTO_TEST_CASE(Product_numeric_type_test0)
 {
     DECL_VA(x);
-    
+
     // Test fraction coefficient handling
     auto _1 = Fraction(1, 2) * x;
     auto _2 = x * Fraction(1, 2);
     BOOST_TEST(_1 == _2);  // Order independence with fractions
-    
+
     // Test mixed numeric type handling
     auto _3 = (-1_v * x) * Fraction(1, 2);
     auto _4 = Fraction(-1, 2) * x;
     BOOST_TEST(_3 == _4);  // Equivalent forms
-    
+
     // Test coefficient normalization with mixed types
     auto _5 = (Fraction(-1, 2) * x) * (-2_v);
     BOOST_TEST(_5 == x);  // Double negation with mixed types