Verify precalculated constants against OEIS via HTTP when computation times out

When local BigInteger computation exceeds the 10-second limit, the expected
value is now fetched from the authoritative OEIS b-files via real HTTP requests:
- Factorials: OEIS A000142 (https://oeis.org/A000142/b000142.txt)
- Catalan numbers: OEIS A000108 (https://oeis.org/A000108/b000108.txt)

This replaces the previous behaviour of silently skipping those values.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: konard

csharp/Platform.Numbers.Tests/MathTests.cs

@@ -1,13 +1,49 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Net.Http;
 using System.Numerics;
+using System.Text.RegularExpressions;
 using Xunit;
 
 namespace Platform.Numbers.Tests
 {
     public static class MathTests
     {
         private static readonly TimeSpan ComputationTimeLimit = TimeSpan.FromSeconds(10);
+        private static readonly HttpClient HttpClient = new();
+
+        // Fetches all entries from an OEIS b-file (plain text format: "n value" per line).
+        // Returns a dictionary mapping index -> value as BigInteger.
+        // The b-file URL format is: https://oeis.org/AXXXXXX/b000XXX.txt
+        private static Dictionary<ulong, BigInteger> FetchOeisSequence(string bFileUrl)
+        {
+            var result = new Dictionary<ulong, BigInteger>();
+            string content = HttpClient.GetStringAsync(bFileUrl).GetAwaiter().GetResult();
+            foreach (var line in content.Split('\n'))
+            {
+                var trimmed = line.Trim();
+                if (trimmed.StartsWith("#") || trimmed.Length == 0)
+                {
+                    continue;
+                }
+                var parts = Regex.Split(trimmed, @"\s+");
+                if (parts.Length >= 2 && ulong.TryParse(parts[0], out var index) && BigInteger.TryParse(parts[1], out var value))
+                {
+                    result[index] = value;
+                }
+            }
+            return result;
+        }
+
+        // Lazily-fetched OEIS sequences, cached for the lifetime of the test run.
+        private static Dictionary<ulong, BigInteger>? _oeisFactorials;
+        private static Dictionary<ulong, BigInteger> OeisFactorials =>
+            _oeisFactorials ??= FetchOeisSequence("https://oeis.org/A000142/b000142.txt");
+
+        private static Dictionary<ulong, BigInteger>? _oeisCatalans;
+        private static Dictionary<ulong, BigInteger> OeisCatalans =>
+            _oeisCatalans ??= FetchOeisSequence("https://oeis.org/A000108/b000108.txt");
 
         // Computes factorial of n using BigInteger so it never overflows.
         // Returns null if computation exceeds the time limit.
@@ -159,40 +195,52 @@ public static void MaximumConstantsTest()
         public static void PrecalculatedFactorialsMatchComputedValues()
         {
             // Verify that every precalculated factorial constant in Math._factorials is actually
-            // a correct factorial value, computed independently using BigInteger arithmetic.
-            // Only computes values that finish within 10 seconds; larger values would need
-            // verification via an external trusted resource (e.g. OEIS A000142: https://oeis.org/A000142).
+            // a correct factorial value. For values that can be computed locally within 10 seconds,
+            // an independent BigInteger computation is used. For values that take longer, the
+            // expected value is fetched from OEIS A000142 (https://oeis.org/A000142) via HTTP.
             for (ulong n = 0; n <= Math.MaximumFactorialNumber; n++)
             {
                 var computed = ComputeFactorialWithTimeLimit(n);
+                BigInteger expected;
                 if (computed is null)
                 {
-                    // Computation exceeded 10 seconds — skip and rely on external verification.
-                    continue;
+                    // Computation exceeded 10 seconds — verify against OEIS A000142.
+                    Assert.True(OeisFactorials.TryGetValue(n, out expected),
+                        $"OEIS A000142 did not contain a value for n={n}");
+                }
+                else
+                {
+                    expected = computed.Value;
                 }
                 var precalculated = Math.Factorial<ulong>(n);
-                Assert.Equal((ulong)computed, precalculated);
+                Assert.Equal((ulong)expected, precalculated);
             }
         }
 
         [Fact]
         public static void PrecalculatedCatalansMatchComputedFactorials()
         {
             // Verify that every precalculated Catalan constant in Math._catalans is actually
-            // a correct Catalan number, computed from scratch using the formula:
-            //   C(n) = (2n)! / ((n+1)! * n!)
-            // Only computes values that finish within 10 seconds; larger values would need
-            // verification via an external trusted resource (e.g. OEIS A000108: https://oeis.org/A000108).
+            // a correct Catalan number. For values that can be computed locally within 10 seconds
+            // using the formula C(n) = (2n)! / ((n+1)! * n!), an independent BigInteger computation
+            // is used. For values that take longer, the expected value is fetched from OEIS A000108
+            // (https://oeis.org/A000108) via HTTP.
             for (ulong n = 0; n <= Math.MaximumCatalanIndex; n++)
             {
                 var computed = ComputeCatalanWithTimeLimit(n);
+                BigInteger expected;
                 if (computed is null)
                 {
-                    // Computation exceeded 10 seconds — skip and rely on external verification.
-                    continue;
+                    // Computation exceeded 10 seconds — verify against OEIS A000108.
+                    Assert.True(OeisCatalans.TryGetValue(n, out expected),
+                        $"OEIS A000108 did not contain a value for n={n}");
+                }
+                else
+                {
+                    expected = computed.Value;
                 }
                 var precalculated = Math.Catalan<ulong>(n);
-                Assert.Equal((ulong)computed, precalculated);
+                Assert.Equal((ulong)expected, precalculated);
             }
         }
     }