Fix PARI evaluation error for constant identity functions (#621)

Author: Copilot

CHANGELOG.md

@@ -6,6 +6,10 @@
 * Integrate `zlib` for gzip decompression, replacing external `gzip`/`gunzip` tools
 * Report broken b-files to LODA API server for automatic cache invalidation
 
+### Bugfixes
+
+* Fix PARI evaluation error for formulas with constant identity functions (e.g., A026765)
+
 ## v25.11.29
 
 ### Enhancements

src/form/formula_gen.cpp

@@ -782,6 +782,9 @@ bool FormulaGenerator::generate(const Program& p, int64_t id, Formula& result,
   // replace simple references to recursive functions
   FormulaSimplify::replaceSimpleRecursiveRefs(result);
 
+  // replace constant identity functions (e.g., b(n) = b(n-1) with no base case)
+  FormulaSimplify::replaceConstantIdentityFunctions(result);
+
   // replace arithmetic & geometric progressions
   // TODO: check if this is really needed here
   FormulaSimplify::replaceArithmeticProgressions(formula);

src/form/formula_simplify.cpp

@@ -7,6 +7,20 @@
 #include "form/expression_util.hpp"
 #include "form/formula_util.hpp"
 
+// Helper function to replace all function calls by name with a replacement
+// expression
+void replaceFunctionByName(Expression& expr, const std::string& funcName,
+                           const Expression& replacement) {
+  // First recurse into children
+  for (auto& child : expr.children) {
+    replaceFunctionByName(child, funcName, replacement);
+  }
+  // Then check if this expression matches
+  if (expr.type == Expression::Type::FUNCTION && expr.name == funcName) {
+    expr = replacement;
+  }
+}
+
 // Helper function to collect simple functions from formula
 std::set<std::string> collectSimpleFunctions(const Formula& formula) {
   std::set<std::string> funcs;
@@ -560,3 +574,87 @@ void FormulaSimplify::replaceSimpleRecursiveRefs(Formula& formula) {
     processedRecursiveFuncs.insert(funcName);
   }
 }
+
+// Helper function to check if a function is a constant identity (f(n) = f(n-k))
+bool isConstantIdentityFunction(const Formula& formula,
+                                const std::string& funcName) {
+  // Find the general definition (the one with a parameter, not a constant)
+  Expression funcKey = ExpressionUtil::newFunction(funcName);
+  auto it = formula.entries.find(funcKey);
+  if (it == formula.entries.end()) {
+    return false;  // No general definition found
+  }
+
+  const auto& rhs = it->second;
+
+  // Check if RHS is f(n-k) where k > 0
+  if (rhs.type != Expression::Type::FUNCTION || rhs.children.size() != 1) {
+    return false;
+  }
+
+  // Must reference itself
+  if (rhs.name != funcName) {
+    return false;
+  }
+
+  const auto& arg = rhs.children.front();
+
+  // Check if argument is n-k where k > 0
+  Number offset;
+  if (!extractArgumentOffset(arg, offset)) {
+    return false;
+  }
+
+  // Must be a backwards reference (offset < 0)
+  if (offset >= Number::ZERO) {
+    return false;
+  }
+
+  // Check that there are no initial terms (base cases) for this function
+  for (const auto& entry : formula.entries) {
+    if (entry.first.type == Expression::Type::FUNCTION &&
+        entry.first.name == funcName && entry.first.children.size() == 1 &&
+        entry.first.children.front().type == Expression::Type::CONSTANT) {
+      // Found an initial term - this is not a constant identity function
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool FormulaSimplify::replaceConstantIdentityFunctions(Formula& formula) {
+  // Collect all function names
+  auto funcs = FormulaUtil::getDefinitions(formula, Expression::Type::FUNCTION);
+
+  // Find constant identity functions
+  std::set<std::string> constantFuncs;
+  for (const auto& funcName : funcs) {
+    if (isConstantIdentityFunction(formula, funcName)) {
+      constantFuncs.insert(funcName);
+    }
+  }
+
+  if (constantFuncs.empty()) {
+    return false;
+  }
+
+  // Replace references to constant identity functions with 0
+  Expression zero = ExpressionUtil::newConstant(0);
+  for (const auto& funcName : constantFuncs) {
+    // Remove all entries for this function
+    FormulaUtil::removeFunctionEntries(formula, funcName);
+
+    // Replace all references to funcName(...) with 0 in other entries
+    for (auto& entry : formula.entries) {
+      replaceFunctionByName(entry.second, funcName, zero);
+    }
+  }
+
+  // Normalize after replacements
+  for (auto& entry : formula.entries) {
+    ExpressionUtil::normalize(entry.second);
+  }
+
+  return true;
+}

src/form/formula_simplify.hpp

@@ -82,4 +82,21 @@ class FormulaSimplify {
    * references
    */
   static void replaceSimpleRecursiveRefs(Formula& formula);
+
+  /**
+   * Replaces constant identity functions with constant 0.
+   *
+   * This method identifies functions of the form f(n) = f(n-k) with no base
+   * case (no initial term like f(0) = c). Such functions represent constant
+   * values that were initialized to 0 during formula generation. Without
+   * this simplification, they would cause infinite recursion in PARI/GP.
+   * For example:
+   *   b(n) = b(n-1)  (with no b(0) = ...)
+   * Will be replaced with: constant 0 everywhere b is referenced
+   *
+   * @param formula The formula to simplify by replacing constant identity
+   * functions
+   * @return true if any replacements were made
+   */
+  static bool replaceConstantIdentityFunctions(Formula& formula);
 };