refactor: add debug logging and fix coefficient handling

omnn/math/Sum.cpp

@@ -2114,6 +2114,23 @@ namespace
                             if (dn != constants::one) {
                                 lcm.lcm(dn);
                             }
+                        } else if (c.IsProduct()) {
+                            auto& p = c.as<Product>();
+                            if (p.size() == 2) {
+                                auto it = p.begin();
+                                if (*it == -1) {
+                                    auto next = std::next(it);
+                                    if (next->IsUnivariable()) {
+                                        auto& var = next->as<Variable>();
+                                        if (var == va) {
+                                            isNormalizedPolynomial = true;  // This is a valid normalized form
+                                            continue;  // Skip further normalization for -1*x case
+                                        }
+                                    }
+                                }
+                            }
+                            // Don't set isNormalizedPolynomial to false here
+                            // Let other checks determine normalization status
                         } else {
                             LOG_AND_IMPLEMENT("Solving " << va << " in " << *this << std::endl
         								<< "need to normalize coefficient: " << c << std::endl);
@@ -2137,14 +2154,14 @@ namespace
                     a.optimize();
                 }
                 auto k = coefficients[0];
-                if(!k.IsInt()) {
+                if(!k.IsInt() && !k.IsProduct()) {
 #if !defined(NDEBUG) && !defined(NOOMDEBUG)
                     std::cout << "free member needed optimization: " << k << std::endl;
 #endif
                     OptimizeOn oo;
                     k.optimize();
                 }
-                if(a.IsInt() && k.IsInt()) {
+                if(a.IsInt() && (k.IsInt() || k.IsProduct())) {
                     Valuable test;
                     auto& aFactors = omnn::rt::DivisorsLookupTable::Divisors(a.ca());
 

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 @@
 
 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 @@
         }
     }
 
+    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,6 +115,25 @@ 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(Product_tests)
 {
 	auto f = 1_v / 2;